BSON vs JSON
JSON (JavaScript Object Notation) is a human-readable text format with a small set of types: strings, numbers, booleans, null, arrays, and objects. BSON (Binary JSON) is the binary-encoded superset MongoDB actually uses to store and transmit documents; it adds richer types like Date, ObjectId, Decimal128, Int32, Int64, Binary data, and Regular Expression, and encodes length prefixes so a parser can skip over fields or arrays without scanning every character, unlike text-based JSON parsing.
Cricket analogy: JSON's plain 'number' type versus BSON's distinct Int32, Int64, and Decimal128 is like a scoreboard showing just 'runs' versus a broadcaster's detailed stats system distinguishing strike rate, boundary count, and net run rate as separate typed fields.
Type Fidelity: Dates, IDs, and Precise Numbers
JSON has no native Date type, so dates are typically stored as ISO 8601 strings and must be parsed back into a Date object by application code, with all the timezone-handling bugs that implies. BSON's Date type stores dates as a 64-bit integer of milliseconds since the Unix epoch, so MongoDB can compare, sort, and index dates natively without string parsing, and Decimal128 stores exact decimal values (crucial for currency) rather than the floating-point approximation JSON's generic number type would use for something like 19.99.
Cricket analogy: Storing a match start time as a native BSON Date instead of a JSON string is like a stadium's official clock system tracking kickoff in a structured timestamp instead of an announcer's spoken '3 PM local time' that someone has to manually reinterpret.
Why It Matters for Performance
Because BSON encodes the byte length of documents, arrays, and strings up front, MongoDB's storage engine can traverse or skip over data without scanning it character by character the way a JSON.parse() call must, which speeds up operations like projections that only need a few fields from a large document. The tradeoff is that BSON is not human-readable in its raw binary form and is slightly larger than equivalent minified JSON due to these length prefixes and type markers, though tools like mongosh and MongoDB Compass render it back into a readable, JSON-like representation for you.
Cricket analogy: BSON letting MongoDB skip straight to a needed field via a length prefix is like a stats analyst jumping directly to the 45th over of a match using a timestamped index, instead of watching the whole match from ball one to find that moment.
// JSON representation you might send over an API
{
"name": "Wireless Mouse",
"price": 24.99,
"createdAt": "2026-07-10T14:00:00Z"
}
// The same data as stored by MongoDB, conceptually, in BSON
{
name: "Wireless Mouse", // BSON String
price: NumberDecimal("24.99"), // BSON Decimal128, exact
createdAt: ISODate("2026-07-10T14:00:00Z"), // BSON Date, 64-bit ms since epoch
_id: ObjectId("64f1c2a9e4b0f5a1d8c9e123") // BSON ObjectId, 12 bytes
}When you view documents in mongosh or MongoDB Compass, you're seeing a JSON-like text rendering of the underlying BSON — tools like Extended JSON are used to represent BSON-only types such as ObjectId and Decimal128 unambiguously when converting to and from text.
Don't assume a number stored in MongoDB is a JSON-style double by default: without explicitly using NumberDecimal() or a driver's Decimal128 type, numeric literals typed in mongosh are stored as doubles, which can introduce floating-point rounding errors for monetary values.
- JSON is a human-readable text format with a small set of basic types.
- BSON is the binary superset MongoDB uses internally, adding types like Date, ObjectId, and Decimal128.
- BSON's length prefixes let a parser skip over data instead of scanning every character.
- BSON's native Date type avoids the timezone-parsing bugs of JSON's ISO string dates.
- Decimal128 stores exact decimal values, important for currency, unlike JSON's floating-point numbers.
- BSON documents are slightly larger than minified JSON due to type markers and length prefixes.
- Tools like mongosh and Compass render BSON back into a readable, JSON-like view for humans.
Practice what you learned
1. What is BSON?
2. Which BSON type is used for storing exact decimal values, important for currency?
3. How does BSON's Date type represent dates internally?
4. Why can BSON parsing skip over fields more efficiently than parsing plain JSON text?
5. What happens if you type a plain numeric literal like 19.99 in mongosh without using NumberDecimal()?
Was this page helpful?
You May Also Like
Documents and Collections
How MongoDB structures data into documents and collections, including field types, embedding versus referencing, and the _id field.
What Is MongoDB?
An introduction to MongoDB as a document-oriented NoSQL database, how it differs from relational databases, and when it makes sense to use it.
The Mongo Shell and mongosh
How to use mongosh, MongoDB's modern JavaScript-based shell, for interactive queries, scripting, and administration.