What is BSON and what data types does MongoDB support?

Question

Accepted Answer

**BSON** (Binary JSON) is the binary format MongoDB uses to store documents — it extends JSON with additional **data types** (like dates, ObjectId, binary, and proper number types) and is efficient to store and traverse. Understanding BSON types helps you store data correctly.

## BSON — binary JSON with more types

```text
JSON has limited types (string, number, boolean, null, object, array).
BSON adds: ObjectId, Date, Binary, Decimal128, distinct Int/Long/Double, Timestamp, etc.
→ BSON is more efficient (binary, typed, traversable) and richer than plain JSON text.
```

## Common BSON data types

```js
{
  _id: ObjectId("..."),          // ObjectId — 12-byte unique id (the default _id type)
  name: "Ann",                    // String
  age: NumberInt(30),             // Int32 (32-bit integer)
  views: NumberLong(10000000000), // Int64 (64-bit — for large numbers)
  price: NumberDecimal("9.99"),   // Decimal128 — EXACT decimal (use for money!)
  rating: 4.5,                     // Double (default for numbers)
  active: true,                    // Boolean
  createdAt: ISODate("2024-01-15"),// Date (a proper date type, not a string)
  data: BinData(0, "..."),         // Binary data
  tags: ["a", "b"],                // Array
  address: { city: "NY" },          // Embedded document (object)
  deletedAt: null                   // Null
}
```

## ObjectId — the default _id

```js
// ObjectId is a 12-byte id: timestamp + machine/process + counter → globally unique
// It even encodes a creation timestamp:
ObjectId("...").getTimestamp();   // get when the document was created
```

The **ObjectId** (default `_id`) is unique and contains a timestamp — so it's roughly time-ordered and you get creation time for free.

## Important type considerations

```text
✓ Use proper DATE type (ISODate), not date strings → enables date queries/sorting
✓ Use Decimal128 (NumberDecimal) for MONEY → exact (avoid Double's rounding errors)
✓ Be aware of Int32 vs Int64 vs Double — numbers default to Double; large ints need Long
✓ ObjectId vs custom _id — you can use your own _id, but ObjectId is convenient/unique
```

## Why it matters

Understanding BSON and MongoDB's data types is valuable for **storing data correctly and efficiently**, so it's useful foundational knowledge for working with MongoDB.

Knowing that MongoDB uses **BSON** (binary JSON, richer and more efficient than plain JSON) and the **data types it supports** beyond basic JSON — especially proper **Date** types, **ObjectId**, **Decimal128**, and distinct integer/double types — is important for representing data accurately.

Several type considerations matter practically: using a proper **Date type** (ISODate) rather than date strings (enabling correct date queries and sorting — a common mistake to store dates as strings), using **Decimal128 (NumberDecimal) for money** (exact decimal arithmetic, avoiding the rounding errors of Double — the same critical correctness issue as in SQL), and being aware of number type distinctions (numbers default to Double; large integers need Int64/Long).

Understanding the **ObjectId** (the default `_id` — a 12-byte unique identifier that conveniently encodes a creation timestamp, so it's roughly time-ordered and gives you creation time for free) is useful for working with document identifiers.

Since storing data with the right types affects correctness (money exactness, date functionality), efficiency, and queryability, and since BSON's richer type system (especially Date, Decimal128, and ObjectId) is how MongoDB represents data accurately, understanding BSON and MongoDB's data types — the available types, the money/date considerations, and ObjectId — is valuable, practically-relevant knowledge for designing MongoDB data correctly and avoiding common type-related mistakes (like string dates or floating-point money), a useful aspect of working effectively with the database.