MongoDB Data Types & BSON Format
A Super Fun, Easy, and Powerful Guide for Beginner to Expert Level
Imagine you are packing a magic backpack for a trip. You can put in toys, books, photos, numbers, maps, and even secret codes — all in one bag! MongoDB does the same with your data using BSON (Binary JSON). This tutorial explains MongoDB data types and BSON format in the simplest way but with deep insights for pros too. We’ll use:
- Fun examples (like a student diary)
- Real images (from MongoDB docs)
- Beginner → Expert tips
Let’s open the magic backpack!
📘 Table of Contents
- Part 1: What is BSON?
- Part 2: MongoDB Data Types – The Magic Items in Your Backpack
- Part 3: BSON in Action – See the Magic!
- Part 4: Data Type Cheat Sheet (Print & Stick!)
- Part 5: Common Mistakes & Fixes
- Part 6: Mini Project – Build a "Student Card"
- Part 7: Tips for All Levels
- FAQ – Frequently Asked Questions
- Resources
Part 1: What is BSON?
JSON vs BSON : The Magic Difference
JSON (Human-Readable) vs BSON (MongoDB’s Secret Code)
- Text like a letter → JSON
- Binary like a robot language → BSON
- Slow to send → JSON
- Super fast → BSON
- No dates, no big numbers → JSON
- Full support for all types → BSON
| JSON (Human-Readable) | BSON (MongoDB’s Secret Code) |
|---|---|
| Text like a letter Slow to send No dates, no big numbers |
Binary like a robot language Super fast Full support for all types |
Think of it like this:
JSON = Writing a postcard
BSON = Sending a high-speed encrypted video
MongoDB converts your data into BSON behind the scenes so it can store and fetch it super fast.
Why BSON is Awesome (For Experts)
- Binary → 10x faster than JSON
- Supports 32 data types (vs JSON’s 6)
- Stores metadata like field order
- Enables rich queries (e.g., find all dates in 2025)
Part 2: MongoDB Data Types – The Magic Items in Your Backpack
Let’s meet the 12 most important data types with real-life examples!
1. String – Words, Names, Messages
{
"name": "Priya",
"message": "I love coding!"
}Like: Writing your name on a notebook
Use: Names, emails, comments
💡 Expert Tip: UTF-8 supported. Max 16MB per document.
2. Integer – Whole Numbers (32-bit & 64-bit)
{
"age": 13,
"score": 95
}Like: Counting marbles
- Int32 → -2.1 billion to 2.1 billion
- Int64 → Much bigger (use for IDs, counters)
db.students.insertOne({ age: NumberInt(13) }) // 32-bit
db.students.insertOne({ age: NumberLong(9007199254740992) }) // 64-bit3. Double – Decimal Numbers
{
"height": 5.5,
"temperature": 36.6
}Like: Measuring height in feet
Use: Prices, ratings, GPS
{ "price": 19.99 }4. Boolean – True or False
{
"isStudent": true,
"hasSubmitted": false
}Like: Light switch: ON or OFF
Use: Flags, settings
5. Date – Time & Date
{ "birthday": ISODate("2012-05-15T00:00:00Z") }Like: Marking your birthday on a calendar
db.events.insertOne({
name: "Sports Day",
date: new Date() // Current time
})6. ObjectId – Unique ID (Auto-Generated)
{ "_id": ObjectId("671a3f1d8e4b2c1f9d5e7a2c") }Like: A special sticker with a unique code on every toy
Structure (12 bytes):
- Timestamp (4)
- Machine ID (3)
- Process ID (2)
- Counter (3)
Why it’s cool: Globally unique, Time-ordered, No central ID server needed
7. Array – Lists of Anything!
{
"hobbies": ["cricket", "drawing", "coding"],
"scores": [95, 88, 100]
}Like: A lunchbox with multiple snacks
db.students.find({ hobbies: "cricket" })8. Embedded Document – Data Inside Data
{
"name": "Amit",
"address": {
"street": "MG Road",
"city": "Delhi",
"pin": 110001
}
}Like: A folder inside a folder
db.students.find({ "address.city": "Delhi" })Real-World Example:
Using embedded documents is perfect for e-commerce orders:
{
"orderId": 12345,
"customer": {
"name": "Priya",
"email": "priya@example.com"
},
"items": [
{"product": "Book", "qty": 2},
{"product": "Pen", "qty": 5}
]
}
9. Null – Empty or Missing
{ "middleName": null }Like: A blank space in a form
10. Binary Data – Photos, Files, Secrets
db.files.insertOne({
name: "photo.jpg",
data: BinData(0, "base64string...")
})Like: Storing a real photo in your diary
Use Case: Thumbnails, encrypted data
11. Regular Expression – Pattern Search
db.users.find({ name: /^A/ }) // Names starting with A
db.users.find({ name: /kumar$/i }) // Ends with "kumar", case-insensitiveLike: Searching with wildcards
12. JavaScript Code – Store Functions (Rare!)
{ "func": { "$code": "function() { return 'Hi'; }" } }Part 3: BSON in Action – See the Magic!
Let’s insert a student and see how MongoDB stores it:
use school
db.students.insertOne({
name: "Rohan",
age: 13,
height: 5.4,
isActive: true,
birthday: ISODate("2012-03-10"),
hobbies: ["cricket", "music"],
address: {
city: "Mumbai",
pin: 400001
}
})Behind the Scenes (BSON View)
MongoDB converts this to binary BSON:
\x16\x00\x00\x00 // Document length
\x02 name: \x00 ... // String
\x10 age: \x0D\x00... // 32-bit int
\x01 height: ... // Double
\x08 isActive: \x01 // Boolean
\x09 birthday: ... // Date
\x04 hobbies: ... // Array
\x03 address: ... // Sub-document
\x00 // EndPart 4: Data Type Cheat Sheet (Print & Stick!)
| Type | Example | mongosh Syntax |
|---|---|---|
| String | "Rohan" | "Rohan" |
| Integer (32) | 13 | NumberInt(13) |
| Integer (64) | 9007199254740992 | NumberLong("...") |
| Double | 5.5 | 5.5 |
| Boolean | true | true |
| Date | 2025-10-30 | ISODate("2025-10-30") |
| ObjectId | Auto-generated | ObjectId() |
| Array | ["a", "b"] | ["a", "b"] |
| Embedded Doc | { city: "Delhi" } | { city: "Delhi" } |
| Null | null | null |
Part 5: Common Mistakes & Fixes
| Mistake | Fix |
|---|---|
| Using 13 as string "13" | Use numbers for math: age: 13 |
| Storing dates as strings | Use ISODate() for proper sorting |
| Forgetting NumberLong() for big nums | Use NumberLong(1234567890123) |
| Arrays with mixed types | Avoid! Keep types consistent |
Part 6: Mini Project – Build a "Student Card"
db.cards.insertOne({
_id: ObjectId(),
name: "Sanya",
rollNo: NumberInt(25),
grade: 8.5,
isPrefect: true,
joinDate: ISODate("2024-04-01T00:00:00Z"),
subjects: ["Math", "Science", "English"],
marks: {
math: 92,
science: 88,
english: 90
},
photo: BinData(0, "base64string..."), // Optional
notes: null
})Now Query It!
// Find 8th graders with >90 in Math
db.cards.find({
"marks.math": { $gt: 90 }
})
// Update grade
db.cards.updateOne(
{ name: "Sanya" },
{ $set: { grade: 8.7 } }
)Try in Compass! See it as a beautiful card.
Try It Yourself:
Insert a new student with your own hobbies and query only students who like "music".
// Hint:
db.students.find({ hobbies: "music" })
Part 7: Tips for All Levels
For Beginners
- Use Compass GUI to see types visually
- Practice with insertOne() and find()
- Make a "Game Inventory" with arrays
For Medium Learners
Use schema validation to enforce types:
db.createCollection("students", {
validator: {
$jsonSchema: {
bsonType: "object",
required: ["name", "age"],
properties: {
name: { bsonType: "string" },
age: { bsonType: "int" }
}
}
}
})For Experts
- Use BSON type checking in drivers
- Optimize with partial indexes on specific types
- Use Decimal128 for money:
{ price: NumberDecimal("19.99") }
Final Words
You now know:
- BSON = MongoDB’s super-fast binary format
- 12+ data types = From strings to photos
- How to store, query, and master data like a pro!
Fun Learned: Infinite
Your Mission:
use myBackpack
db.items.insertOne({
name: "Magic Wand",
power: 9000,
isLegendary: true,
discovered: new Date()
})You’re now a MongoDB Data Wizard!
Frequently Asked Questions (FAQ)
1. What is BSON in MongoDB?
BSON (Binary JSON) is MongoDB’s binary format for storing data. It extends JSON by supporting additional data types like Date, ObjectId, and Binary, making storage and querying faster and more flexible.
2. Why does MongoDB use BSON instead of JSON?
MongoDB uses BSON because it’s faster and more efficient than JSON. It supports rich data types, preserves field order, and allows quick encoding/decoding for large-scale operations.
3. What are the most common MongoDB data types?
The most commonly used MongoDB data types include String, Integer, Double, Boolean, Date, ObjectId, Array, and Embedded Documents.
4. What is the difference between Int32, Int64, and Double in MongoDB?
Int32 and Int64 store whole numbers with 32-bit and 64-bit precision respectively. Double stores floating-point numbers (decimals) using IEEE-754 format. Use Int32 for small counters, Int64 for large IDs, and Double for measurements or prices.
5. How can I view BSON data in human-readable format?
MongoDB automatically converts BSON to JSON when displaying data in tools like mongosh or Compass. You can also use tojson() in the shell to see readable JSON output.
6. What is ObjectId and how is it generated?
ObjectId is a 12-byte unique identifier generated automatically by MongoDB. It includes a timestamp, machine ID, process ID, and a counter — ensuring global uniqueness and time ordering.
7. When should I use Embedded Documents vs References?
Use Embedded Documents when data is frequently read together (e.g., user profile with address). Use References when data is large or shared across documents (e.g., users referencing a separate roles collection).
8. What is Decimal128 and when should I use it?
Decimal128 is a high-precision numeric type used for financial or scientific data. Use it for currency, measurements, or when precision beyond Double is required.
9. What are common mistakes beginners make with MongoDB data types?
- Storing numbers as strings (e.g., "13" instead of 13).
- Using string dates instead of ISODate().
- Mixing data types in arrays.
- Ignoring NumberLong() for large integers.
10. How can I practice MongoDB data types easily?
Use the MongoDB Atlas free tier or Compass GUI to create collections, insert sample documents, and explore BSON structure visually.
Resources:
Keep packing your magic backpack!
💡 Have questions? Drop a comment below!