Question: How does using skip and limit in MongoDB affect performance?


MongoDB provides the skip() and limit() methods to paginate query results. However, using these methods can have varying impacts on query performance, especially as the size of the dataset grows.

Understanding skip() and limit()

  • The limit() method in MongoDB is used to specify the maximum number of documents the query should return.
  • The skip() method is used to skip over a specific number of documents from the beginning of the result set.

Performance Considerations

Impact of skip() on Performance:

Using skip() can significantly impact performance for large datasets. When you use skip(), MongoDB still scans through all the documents that precede the skipped documents. Therefore, the larger the skip value, the longer it takes for the query to execute because MongoDB has to traverse more documents.


In the above example, if the collection has a large number of documents, skipping the first 10,000 can lead to performance degradation.

Optimizing with Indexes:

Indexes can mitigate some of the performance issues. If your query can leverage an index, MongoDB can locate the starting document more efficiently. However, even with indexes, high skip values can still lead to slower query execution times.

Alternatives to Using skip() for Pagination:

To avoid the performance hit from using skip(), consider alternative pagination strategies such as:

  • Range Queries: Instead of skipping documents, use range queries to paginate through results. This method involves querying documents based on a field that either uniquely identifies them or is closely related to the sort order.
db.collection.find({ _id: { $gt: lastIdSeen } }).limit(10)

Here, lastIdSeen represents the _id of the last document from the previous page. This approach is more efficient than using skip() because it directly seeks to the next set of documents without traversing the preceding ones.

  • Bucket Pattern: For time-series or log data, consider organizing your data into buckets (e.g., one bucket per day). Querying specific buckets then limits the data scope, avoiding the need to skip many documents.


While skip() and limit() are useful for implementing pagination in MongoDB, their performance can degrade for large datasets. Consider using range queries or other alternatives for more efficient pagination. Always test and analyze the performance of your queries in the context of your specific use case and data structure.

Was this content helpful?

Start building today

Dragonfly is fully compatible with the Redis ecosystem and requires no code changes to implement.