Data Types in MongoDB

The quotes in Long("9007199254740993") are required for values this large. JavaScript cannot represent that number exactly, and without quotes it changes before MongoDB ever receives it:

print(9007199254740993)

9007199254740992

Leaving the quotes off Long is worse than rounding. In our test with mongosh 2.3.8, Long(9007199254740993) stored 0, so always use the quoted form for large values. Decimal128 also takes a string, for the same reason. The older names NumberLong and NumberDecimal still work, and you will see them in older material.

A double stores most fractions approximately. That is acceptable for a rating, but not for money, as this comparison shows. Both sums add 0.1 and 0.2, once as doubles and once as decimals:

db.money.insertOne({ a: 0.1, b: 0.2, x: Decimal128("0.1"), y: Decimal128("0.2") })
db.money.aggregate([{ $project: { _id: 0, doubleSum: { $add: ["$a", "$b"] }, decimalSum: { $add: ["$x", "$y"] } } }])

[ { doubleSum: 0.30000000000000004, decimalSum: Decimal128('0.3') } ]

The cost of decimal is twice the space of a double, and you should use it where exact decimal values matter, such as financial data.

Different number types can represent the same value, and MongoDB compares them by value. A query for { age: 30 } matches an int, a long, a double or a decimal containing 30. To select one specific type, use $type in a query, as in { age: { $type: "int" } }. The aliases int32, int64 and decimal128 do not exist, and the server answers Unknown type name alias.

Boolean, Null and Missing

isStudent is a Boolean, which is either true or false.

middleName is null, which is a stored value meaning that the field exists and has no content. Compare it with nickname in the report, whose type is missing because the document has no such field. The stored documents differ in these two cases, even though a filter such as { middleName: null } matches both a null value and an absent field.

Array and Object

tags is an array, an ordered list. An array can contain values of different types, including other arrays and objects.

address is an object: a nested document with its own field names and values of any BSON type. This allows data that belongs to one user to stay in that user's document.

Binary Data

avatar contains a byte array, which is useful for small images, files or encrypted values. The first argument of BinData is a subtype, where 0 means generic binary. The second is the data in Base64, a way of writing bytes as plain characters, and "SGVsbG8=" here is the five bytes of the word Hello.

The Base64 text must be valid, because mongosh does not check it for you. BinData(0, "binarydatahere") is accepted even though its text is not valid Base64, and it comes back as binarydataherQ==, which is different from what was written. A document can be at most 16 mebibytes, and a larger file does not fit in one binary field. MongoDB offers a separate facility called GridFS for such files, which divides a file into smaller pieces.

Date

createdAt is a Date, a signed 64-bit integer counting the milliseconds since the Unix epoch (January 1, 1970). Dates are stored in UTC, and a time zone in your input only changes the value that gets stored:

new Date("2024-06-01T10:00:00-08:00")

ISODate('2024-06-01T18:00:00.000Z')

Always write new Date() in mongosh. Without new, Date() returns the current time as a string, and that value is stored with type string:

Date()
new Date()

Sun Nov 01 2026 07:12:05 GMT-0800 (Pacific Standard Time)
ISODate('2026-11-01T15:12:05.606Z')

Types You Will Rarely Store

The remaining types are less common in application data.

Regular Expression. A value such as /abc/i can be stored as a field with type regex, although it is much more common to use a regular expression in a query. This one finds users whose email ends in example.com:

db.users.find({ email: /example\.com$/ }, { name: 1, _id: 0 })

JavaScript. This type stores code as data. A function in an insert, such as { code: function() { return "Hello, MongoDB!"; } }, is stored with type javascript, and Code("function() { return 1; }") does the same thing. MongoDB does not run this code when you read the document, and you receive the text back.

JavaScript with Scope. This type stores code together with a set of variables, and it is deprecated. The form Code("function() { return x; }", { x: 1 }) creates one. Writing { $code: "...", $scope: { x: 1 } } in an insert does not, because the server stores that as an ordinary nested document with type object.

Timestamp. MongoDB uses this type internally, and it is not related to Date. It has 64 bits: 32 for seconds since the epoch, and 32 for a counter of operations within that second. When you insert Timestamp() into a top-level field other than _id, the server fills in the current time, but in a nested field it stays at zero. For dates in your own data, use Date.

db.misc.insertOne({ createdTs: Timestamp(), nested: { t: Timestamp() } })
db.misc.findOne({}, { _id: 0 })

{
  createdTs: Timestamp({ t: 1793546290, i: 6 }),
  nested: { t: Timestamp({ t: 0, i: 0 }) }
}

Min Key and Max Key. MinKey() compares lower than every other BSON value, and MaxKey() compares higher than every other value. If a field contains a mix of MinKey(), null, a number, a string, a date and MaxKey(), an ascending sort returns them in exactly that order. MongoDB uses these two values for internal comparisons, and applications seldom store them.

Undefined. This type is deprecated. In mongosh, inserting { u: undefined } stores null.