MongoDB Data Types: Complete Guide With Examples

MongoDB Date and Time Data Types

MongoDB has two types that deal with time. They sound similar, but they are used for very different things. One is for your actual application data. The other is mostly internal.

9. Date

Date stores a specific point in time. It is just a number, the milliseconds since January 1, 1970 (called the Unix epoch).

db.orders.insertOne({ product: "Keyboard", orderedAt: new Date() })

You can also set a specific date instead of using the current time:

db.orders.insertOne({ product: "Mouse", orderedAt: new Date("2026-01-15") })

A few things to remember:

• Date does not store a time zone. It stores a plain timestamp. Your app or driver handles the time zone conversion when displaying it.
• Store dates as an actual Date type like "2026-01-15".
• Use Date for anything the user is facing: order dates, sign-up dates, appointment times, and so on.

10. Timestamp

Timestamp looks like Date, but it is not meant for your application data. MongoDB uses it internally, mainly in the oplog, to track replication and sharding events.

A Timestamp is made of two parts:

• A 32-bit value for the time (seconds since epoch)
• A 32-bit counter, to keep operations in order within the same second

You'll rarely create one yourself. It mostly shows up if you're inspecting MongoDB's internals or working with replication.

db.system.replset.find()

Date vs Timestamp

Simple way to remember the difference:

Rule, if you are storing a date or time for your app, always use Date. Never use Timestamp for that. Timestamp is reserved for MongoDB's own replication logic, not for things like "created at" or "last login" fields.

Also read: What Is MongoDB? Introduction, Data Modeling, Terminology & Hierarchy

Structural MongoDB Data Types

MongoDB isn't limited to storing flat, simple values. It can also store lists and nested documents inside a single document. This is one of the biggest reasons people choose MongoDB over a traditional table-based database.

11. Array

Array stores a list of values inside one field. The values can be the same type, or mixed types.

db.users.insertOne({ name: "Priya Mehta", skills: ["JavaScript", "MongoDB", "Node.js"] })

You can even mix data types in the same array:

db.orders.insertOne({ product: "Laptop", tags: ["electronics", 2026, true] })

A few practical points:

• You can query arrays directly. MongoDB checks if any element matches:

db.users.find({ skills: "MongoDB" })

• Arrays can hold other arrays or objects too. That's how you build things like a list of addresses or a list of order items inside one document.
• If an array keeps growing without limit, like logging every single event forever, it can bloat your document size. Keep that in mind before designing a schema around large arrays.

12. Object or Embedded Document

Object lets you nest a full document inside another document. Instead of linking to a separate collection, you keep related data together in one place.

db.users.insertOne({
  name: "Karan Malhotra",
  address: {
    city: "Delhi",
    pincode: "110001",
    country: "India"
  }
})

To query a nested field, use dot notation:

db.users.find({ "address.city": "Delhi" })

Embedded documents work well when the nested data is always accessed together with the parent, like a user and their address. It saves you from doing a separate lookup or join.

But if the nested data grows large or needs to be queried on its own often, like thousands of order line items, it's usually better to use a separate collection instead of embedding everything.

Array vs Object

Quick way to tell them apart:

Also read: The Future Scope of MongoDB: Advantages, Improvements & Challenges

Advanced MongoDB Data Types

These types do not show up as often. But they are useful for specific jobs, storing files, matching patterns, or saving actual code inside a document.

13. Binary Data

Binary Data stores raw, non-text data. Think images, PDFs, encrypted values, or UUIDs.

db.files.insertOne({
  name: "profile-photo.png",
  data: BinData(0, "SGVsbG8gV29ybGQ=")
})

A few things worth knowing:

• Binary data is stored as-is. MongoDB does not try to interpret or parse it.
• Small files can be stored directly as Binary Data. Larger files, anything close to or over 16MB, should use GridFS instead, since that's built to handle big files in chunks.
• Binary Data is also commonly used for storing UUIDs, when you need a unique ID format different from ObjectId.

14. Regular Expression

Regular Expression stores a pattern, the same kind you'd use in JavaScript regex. It lets you match text patterns directly in your queries.

db.users.find({ name: { $regex: "^Sh", $options: "i" } })

You can also store a compiled regex pattern as a field value, though this is far less common than using regex inside a query.

15. JavaScript

JavaScript stores actual JavaScript code as a value in a document. It was originally meant to be used with server-side functions like $where or map-reduce.

db.users.insertOne({
  name: "Sample Script",
  validate: function() { return this.age > 18; }
})

In practice, this type is rarely used today. Most modern MongoDB apps handle logic in the application layer, not inside the database. It still exists for backward compatibility.

16. JavaScript with Scope

JavaScript with Scope is the same idea, but it also stores a set of variables (a "scope") alongside the code, so the function has access to specific values when it runs.

{
  code: "function() { return this.price > minPrice; }",
  scope: { minPrice: 100 }
}

Also read: Most Common MongoDB Commands for MongoDB Beginners

MinKey and MaxKey Data Types

MinKey and MaxKey aren't really data types you store in your documents. They're special values used for comparisons. Mostly behind the scenes.

17. MinKey

MinKey is always the smallest possible value in BSON. No matter what you compare it to, MinKey is considered lower.

db.data.find({ field: { $gt: MinKey() } })

MongoDB uses MinKey internally, especially in sharding, to represent the lowest boundary of a shard's range.

18. MaxKey

MaxKey is the opposite. It's always the largest possible value in BSON. Everything else is considered smaller than it.

db.data.find({ field: { $lt: MaxKey() } })

Like MinKey, MaxKey shows up mostly in sharding, marking the upper boundary of a shard's range.

Also read: Top 20 MongoDB Project Ideas for Beginners with Source Code in 2026

How to Choose the Right MongoDB Data Type

The right type affects storage size, query speed, and how well your data holds up over time. Here is a quick way to decide.

Match the Type to the Value

• Text → String
• True/false → Boolean
• Small whole number → Int32
• Large whole number → Int64
• Decimal, rounding OK → Double
• Money or exact decimals → Decimal128

Decide: Embed or Separate?

• Always used with its parent (like an address) → Object
• A list of similar items (like tags) → Array
• Large, frequently queried on its own, or shared across documents → separate collection instead

Common Mistakes to Avoid

• Dates as strings (breaks sorting and date math)
• Numbers as strings without good reason
• Double for money (use Decimal128)
• Timestamp for app fields like "created at" (that's for MongoDB's internal use)

Quick Check

1. Will I do math on this? → Keep it numeric.
2. Does precision matter? → Decimal128, not Double.
3. Will this grow unbounded? → Rethink the array.
4. Queried often on its own? → Maybe its own collection.

Also read: Understanding MongoDB Architecture: Key Components, Functionality, and Advantages

Conclusion

MongoDB offers far more than strings and numbers. Types like Decimal128, Array, and Object each solve a specific problem, whether it's storing money accurately, nesting related data, or supporting internal replication.

The key rule: pick a type based on what the data actually is, not what it looks like. A phone number isn't a number. A date shouldn't be a string. Money should never be a Double. Getting this right early saves you from messy migrations and broken queries later.

Once you're comfortable with these types, the natural next step is learning indexing strategies and schema design patterns, since how you structure data matters as much as which types you pick.

Have questions about which course fits your career goals? Book a free consultation call with our experts today.