What is the maximum size of a MongoDB document?

16 MB. A single BSON document cannot exceed 16 megabytes. For larger data, reference it in another collection or use GridFS.

Is BSON larger or smaller than JSON?

It depends. BSON adds type bytes and length prefixes, which can make small documents slightly larger, but it stores numbers and dates in compact fixed-width binary rather than as text, which is often smaller for number-heavy data.

Why is my document too large?

Usually an unbounded array or a large embedded blob. Check the biggest fields, and move large or ever-growing data into a referenced collection or GridFS.

Can I paste a document in mongo shell format?

Yes. Shell syntax such as ObjectId("6a7b27c71d2aab315fbc84f2") and ISODate("2025-03-23T09:00:00Z") is supported, alongside NumberInt, NumberLong, NumberDecimal, Timestamp, BinData, UUID, DBRef, Code, MinKey, MaxKey and regular expression literals. Unquoted field names, single-quoted strings, trailing commas and comments are accepted too, so you can paste straight from mongosh or Compass without converting anything to Extended JSON first.

Why does the same integer show two different sizes?

A bare number like 42 is stored as a 4-byte int32 by the MongoDB drivers, but as an 8-byte double by mongosh, where a number literal is a JavaScript double. Use the toggle to pick which one matches where your document came from. Explicitly typed values such as NumberLong("42") are exact and are unaffected by the setting.

Which field is making my document too big?

The per-field breakdown shows every field's byte cost sorted largest first, with nested documents and arrays expandable. The rows sum exactly to the document total at every level, so the field at the top is the one to fix - usually an unbounded array or an embedded binary blob.

BSON Size Calculator: Check the MongoDB 16MB Limit

More information about BSON document size

MongoDB stores documents as BSON (Binary JSON), a binary encoding of your JSON-like data. BSON is not the same size as the JSON text: each field carries a type byte and a length prefix, and values are stored in fixed binary widths. This tool measures that encoded size by serialising your document with MongoDB's official bson library — the same code path a driver uses to put a document on the wire.

Which formats you can paste

All three of the formats you're likely to have on your clipboard:

JSON — {"userId": "USR-0001", "active": true}
Extended JSON, as exported by mongoexport or shown in Compass — {"_id": {"$oid": "6a7b27c71d2aab315fbc84f2"}}
mongo shell / mongosh syntax — {_id: ObjectId("6a7b27c71d2aab315fbc84f2"), createdAt: ISODate("2025-03-23T09:00:00Z")}

Shell types are all supported: ObjectId(), ISODate(), NumberInt(), NumberLong(), NumberDecimal(), Timestamp(), BinData(), UUID(), DBRef(), Code(), MinKey, MaxKey and regular expression literals such as /^ab/i. So are the conveniences the shell allows: unquoted field names, single-quoted strings, trailing commas and comments.

Why a plain integer has two possible sizes

A bare number such as 42 is the one genuinely ambiguous value in a pasted document. The drivers store an integer that fits in 32 bits as a 4-byte int32. mongosh does not: a number literal there is a JavaScript double, so the same field is stored as an 8-byte double. Four bytes per field sounds trivial until you paste a document with hundreds of numbers in it.

Use the toggle under the input to say which one you want. If you copied the document out of mongosh, pick double. If you're modelling what your application will write, pick int32. Values with an explicit type — NumberLong("42"), {"$numberInt": "42"} — are exact and ignore the setting entirely.

The 16 MB limit

A single BSON document cannot exceed 16 MB. Hit that ceiling and writes fail, so it's worth watching for documents with large arrays or embedded blobs. If you're approaching the limit, reference large sub-documents in a separate collection or store binary payloads in GridFS.

How BSON size is calculated

A document is a 4-byte length, its elements, and a 1-byte terminator.
Each element is a type byte, the field name as a null-terminated string, and the value.
Strings are a 4-byte length plus their UTF-8 bytes plus a null byte; an int32 is 4 bytes, a double or date is 8, an ObjectId is 12, a Decimal128 is 16.
An array is stored as a document whose field names are "0", "1", "2" and so on — which is why long arrays cost more than they look, and why the index names start to matter past a thousand entries.

Reading the per-field breakdown

The breakdown lists every field with its full cost — type byte, field name and value — sorted largest first, so the field responsible for an oversized document is at the top. Nested documents and arrays expand, and the numbers add up exactly: the rows at any level sum to their parent. A document that's too large is nearly always one unbounded array or one embedded blob, and this is the fastest way to find out which.

BSON Document Size Calculator