MongoDB find(): A Complete Beginner's Guide to Querying Data

MongoDB is a popular NoSQL database designed for flexibility and performance. Unlike traditional relational databases that use structured tables and SQL, MongoDB stores data in flexible, JSON-like documents. This makes it ideal for developers working with dynamic or semi-structured data.

One of the most important operations you’ll perform in MongoDB is querying data, and the most commonly used method to do this is find(). Whether you’re just getting started or looking to improve your query skills, understanding how find() works is essential for navigating and manipulating your MongoDB data effectively.

Imagine you’re exploring a movie database. You want to find all science fiction films released after the year 2000, or perhaps list all user comments made in a specific time frame. That’s where find() shines.

In this article, you’ll learn how to use the find() method to retrieve documents from a collection, apply filters, project fields, sort results, and optimize performance—all while working with the sample_mflix dataset.

For a hands-on walkthrough of using MongoDB in data science workflows, check out the Introduction to MongoDB in Python course.

Introduction to find() in MongoDB

The find() method is MongoDB’s primary way to retrieve documents from a collection. It returns a cursor to the documents that match the specified query. You can then iterate over this cursor, or convert it to an array, depending on your application’s needs.

Here is the full syntax:

db.collection.find(<query>, <projection>, <options>)

Parameters

• query (optional): A document that defines the criteria for selecting documents. If you omit this parameter or pass an empty document ({}), find() will return all documents in the collection.
• projection (optional): A document that specifies which fields to return. You can include (1) or exclude (0) fields. By default, MongoDB returns all fields, including _id.
• options (optional): An additional document to configure query behavior. You can set things like sort order, pagination limits, timeouts, and index hints.

Example

To make the concepts as clear and applicable as possible, we’ll use the MongoDB Atlas sample dataset—specifically, the sample_mflix database. This dataset includes collections such as movies, comments, users, and theaters, which we’ll reference throughout the article to demonstrate each example.

db.books.find(
  { year: { $gte: 2000 } },              // query: books published in or after 2000
  { title: 1, author: 1, _id: 0 },        // projection: include only title and author
  { sort: { title: 1 }, limit: 5 }       // options: sort by title, return only 5 books
)

This query:

• Filters books published in the year 2000 or later.
• Returns only the title and author fields (excludes _id).
• Sorts the results alphabetically by title (A-Z).
• Limits the output to the first five matching books.

Figure 1. This query finds movies released after 2000, sorted by title and limited to five results.

The result is a cursor, which lazily loads matching documents as you iterate over them. You can use .toArray() or .forEach() to process the results.

If you’re connected through the MongoDB shell (mongosh) and don’t assign the result to a variable, only the first 20 documents will display by default. To view additional documents, type it and press Enter. This process will continue fetching the next batch from the cursor.

> Note: The above is a shell-specific behavior, not a MongoDB limitation. In most MongoDB drivers (e.g., Node.js, Python, Java), calling .toArray() or iterating over the cursor automatically fetches all matching results. Cursor behavior may vary depending on the environment and language you’re using.

Figure 2. This query retrieves all movies, returning only the _id field and using the cursor to fetch additional results.

If you’re new to NoSQL databases, the Introduction to NoSQL course offers foundational concepts that complement this tutorial.

Writing Your First Queries

Continuing with the movie example, let’s say you want to fetch all movies in the Sci-Fi genre. Here’s how you’d do that:

db.movies.find({ genres: "Sci-Fi" })

Now, you want only movies released in or after the year 2000:

db.movies.find({ year: { $gte: 2000 } })

And if you want both? Combine conditions:

db.movies.find({ genres: "Sci-Fi", year: { $gte: 2000 } })

Alternatively, you can write it explicitly using $and:

db.movies.find({ $and: [ { genres: "Sci-Fi" }, { year: { $gte: 2000 } } ] })

Both queries return the same result—documents with the genre Sci-Fi and the release year 2000 or later. The first form is more concise and preferred when the fields are different.

Figure 3. These are different ways to write the query that produce the same result.

Use find() like a filter funnel—each condition narrows down your results.

Using Comparison and Logical Operators

Now, let’s review how to use comparison and logical operators to take your queries to the next level.

Comparison operators

• $eq, $ne: equal, not equal
• $gt, $gte, $lt, $lte: greater/less than (or equal)
• $in, $nin: in or not in array

Imagine you're tracking customer orders and want orders between $100 and $500:

db.orders.find({ total: { $gte: 100, $lte: 500 } })

Logical operators

• $and, $or, $nor, $not

Now, imagine you want to show products in the "Books" category or priced under $20. Here’s an example query:

db.products.find({ $or: [ { category: "Books" }, { price: { $lt: 20 } } ] })

Querying nested fields

You can access nested fields using dot notation:

db.customers.find({ "address.city": "Chicago" })

Projecting Fields

Projection allows you to return only what you need, which can significantly improve performance and clarity.

db.movies.find({}, { directors: 1, languages: 1, _id: 0 })

Important: When specifying a projection, MongoDB requires you to choose between two modes: Either include specific fields (1) or exclude specific fields (0). You cannot mix both styles in the same projection, except for the _id field, which can be excluded even when other fields are included.

✅ Valid (inclusion only):

db.movies.find({}, { directors: 1, languages: 1 })

✅ Valid (exclusion only):

db.movies.find({}, { directors: 0, _id: 0 })

❌ Invalid (mix of inclusion and exclusion):

db.movies.find({}, { directors: 1, languages: 0 }) // Not allowed

The only exception is the _id field, which you can exclude even when including other fields:

db.movies.find({}, { directors: 1, _id: 0 }) // Allowed

Figure 4. This example demonstrates the error triggered by mixing field inclusion and exclusion in a single projection, which MongoDB does not allow, except for `_id`.

Sorting, Limiting, and Skipping Results

When working with large datasets, showing users only a portion of the data at a time is common—a technique known as pagination. For example, a streaming app might show 10 movies per page instead of loading thousands at once. This not only improves performance but also enhances the user experience.

In MongoDB, pagination is achieved using a combination of sort(), limit(), and skip().

SQL vs. MongoDB: Basic comparison

If you’re coming from an SQL background, here’s how common pagination concepts compare:

Basic query in SQL: 

SELECT * FROM movies WHERE year >= 2000

The same can be expressed in MongoDB as follows:

db.movies.find({ year: { $gte: 2000 } })

Field selection in SQL: 

SELECT title, year FROM movies

Field selection in MongoDB: 

db.movies.find({}, { title: 1, year: 1, _id: 0 })

Now, let’s look at a few more examples of common query operations:

Sorting:

• SQL: ORDER BY title ASC
• MongoDB: .sort({ title: 1 })

Limiting:

• SQL: LIMIT 10
• MongoDB: .limit(10)

Skipping:

• SQL: OFFSET 10
• MongoDB: .skip(10)

Understanding these parallels can help SQL users transition more easily to MongoDB’s document-based query system.

Sorting results

Sorting helps you organize your results based on a specific field—for instance, to sort movies by title in alphabetical order:

db.movies.find().sort({ title: 1 }) // ascending (A–Z)

• 1 means ascending order (A-Z, 0-9)
• -1 means descending order (Z-A, 9-0)

Limiting results

Return only a certain number of results—for example, the first 10:

db.movies.find().limit(10)

This is useful when implementing “Top 10” lists or initial views.

Skipping results

Use this to skip documents. It’s often used with limit() for pagination:

db.movies.find().skip(10).limit(10)

This skips the first 10 documents and returns the next 10, effectively showing Page 2 when pageSize = 10.

Pagination formula:

skip = (pageNumber - 1) * pageSize

> Note: Using skip() for deep pagination (e.g., skip(10000)) can be inefficient, as MongoDB still scans and discards the skipped documents. For better performance with large datasets, consider range-based pagination using indexed fields like _id.

Combined example: Page 3, 10 movies per page, sorted by title

db.movies.find()
  .sort({ title: 1 })
  .skip(20)
  .limit(10)

This pattern is also helpful for features like “load more” or infinite scroll.

Figure 5. This query retrieves the third page of results (10 movies per page), ordered by title.

Working With Cursors

The find() method returns a cursor—a pointer to the result set. You can iterate over it:

const cursor = db.movies.find({ type: "movie" });
cursor.forEach(doc => print(doc.name));

Or convert it to an array:

const results = db.collection.find().toArray();

Figure 6. After calling `find()`, you receive a cursor. You can use it to iterate over documents or convert the full result set into an array.

> Note: The cursor object is available in mongosh or code via drivers (e.g., Node.js, Python). GUI tools like MongoDB Compass handle cursors internally. You won’t access or iterate over them directly.

Advanced Cursor Options

To fine-tune your queries, you can use additional cursor methods:

db.users.find({ age: { $gte: 30 } })
  .sort({ name: 1 })
  .limit(10)
  .skip(5)
  .maxTimeMS(200)
  .hint({ age: 1 })

• maxTimeMS(ms): aborts the query if it takes too long
• hint(): forces MongoDB to use a specific index
• batchSize(n): controls the number of docs per batch

Preparing for interviews? Explore the Top 25 MongoDB Interview Questions and Answers to test your understanding of core concepts like find().

Indexes and Performance Optimization

Indexes are like cheat sheets—they help MongoDB retrieve documents faster.

Creating an index

db.movies.createIndex({ type: 1 })

Using .explain()

db.users.find({ type: "movie" }).explain()

This reveals whether indexes are being used and how efficient your query is.

Without an index:

Figure 7. Run `explain()` on the query before indexing.

Creating an index: 

Figure 8. Create a simple index on the type field.

With an index: 

Figure 9. Run the same query with `explain()`, now using an index.

You can see that the stage that was previously CollScan (scanning the collection) has become Fetch + IXSCAN, which is basically using the index + searching for other data that is not part of the index (since we are returning everything).

Using MongoDB Compass to Visualize Queries

If you prefer visual tools, MongoDB Compass is the official GUI client. It allows you to:

• Visually build queries using filters.
• Preview documents and indexes.
• Optimize and validate query performance.

You can even switch to the "JSON view" to copy/paste queries into your code.

Using Atlas + AI to Generate Queries

If you're using MongoDB Atlas, you can leverage Atlas Search with the AI-powered query builder.

Just type a natural-language prompt like:

"Show me all customers from Brazil who placed orders over $100 in the last month."

Atlas suggests a matching MongoDB query using find() or $search. It’s an excellent productivity booster, especially when you're unsure of the syntax.

Figure 10. Use Compass to generate a query from natural language.

Common Pitfalls and How to Avoid Them

• Querying unindexed fields → Leads to slow performance
• Large result sets → Use pagination (limit + skip)
• Inefficient projections → Always project only the needed fields
• Type mismatches → Ensure field types match (e.g., number vs. string)
• Mixing inclusion and exclusion in projections → Not allowed, except for _id

Comparing MongoDB find() to SQL

If you're coming from an SQL background, understanding how MongoDB’s find() compares to familiar SQL queries can make the transition easier. Here's a general comparison of common operations:

As you can see, MongoDB’s syntax is more JavaScript-like and expressive in JSON format, while SQL is more declarative and structured. Knowing these parallels will help you feel at home more quickly in MongoDB.

Summary and Best Practices

• Think of find() as your data filter—combine conditions for precise results.
• Always project only necessary fields for clarity and performance.
• Use indexes to avoid slow scans.
• Use Compass if you prefer visual feedback and faster iteration.
• Take advantage of MongoDB Atlas's AI assistant to generate queries faster.
• Explore advanced cursor options for fine-grained control over results.

Whether you’re building a startup dashboard, a data analytics tool, or an e-commerce back end, mastering find() will make your MongoDB experience smoother, faster, and more effective.

Stay tuned for more MongoDB insights in future articles!

Looking to validate your MongoDB skills? Read the Complete Guide to MongoDB Certification to explore your options.