If you are using pymongo, one way to achieve this is:

import datetime
from bson.objectid import ObjectId
minutes = 15
generated_time = datetime.datetime.today() - datetime.timedelta(minutes=minutes) 
dummy_object_id = ObjectId.from_datetime(generated_time)
query_result = list(database.collection.find({"_id": {"$gte": dummy_object_id}}))

When working with MongoDB in Node.js, you have the ability to query by any timestamp using built-in functions provided by Mongodb drivers:

var currentTimestamp = Date.now();
var objectIdFromTime = ObjectID.createFromTime(currentTimestamp / 1000);

If you need to search for records before the current time, you can simply generate a new ObjectId:

var objectIdBefore = new ObjectID(); // or use ObjectId in the mongo shell

For more information, check out the documentation at http://mongodb.github.io/node-mongodb-native/api-bson-generated/objectid.html

To extract the date from ObjectId in version 4.0, you can utilize the $convert function.

For example,

$convert: { input: "$_id", to: "date" } 

You can perform a query on the date by comparing between a start and end time for the date.

db.collectionname.find({
  "$expr":{
    "$and":[
      {"$gte":[{"$convert":{"input":"$_id","to":"date"}}, ISODate("2018-07-03T00:00:00.000Z")]},
      {"$lte":[{"$convert":{"input":"$_id","to":"date"}}, ISODate("2018-07-03T11:59:59.999Z")]}
    ]
  }
})

Alternatively, you can achieve the same using the shorthand $toDate.

db.collectionname.find({
  "$expr":{
    "$and":[
      {"$gte":[{"$toDate":"$_id"}, ISODate("2018-07-03T00:00:00.000Z")]},
      {"$lte":[{"$toDate":"$_id"},ISODate("2018-07-03T11:59:59.999Z")]}
    ]
  }
})

How can you search for the command (from date[2015-1-12] to Date[2015-1-15]):

db.collection.find({
  _id: {
    $gt: ObjectId(Math.floor((new Date('2015/1/12'))/1000).toString(16) + "0000000000000000"), 
    $lt: ObjectId(Math.floor((new Date('2015/1/15'))/1000).toString(16) + "0000000000000000")
  }
}).pretty()

Calculate the number of commands (from date[2015-1-12] to Date[2015-1-15]):

db.collection.count({
  _id: {
    $gt: ObjectId(Math.floor((new Date('2015/1/12'))/1000).toString(16) + "0000000000000000"), 
    $lt: ObjectId(Math.floor((new Date('2015/1/15'))/1000).toString(16) + "0000000000000000")
  }
})

Delete the commands (from date[2015-1-12] to Date[2015-1-15]):

db.collection.remove({
  _id: {
    $gt: ObjectId(Math.floor((new Date('2015/1/12'))/1000).toString(16) + "0000000000000000"), 
    $lt: ObjectId(Math.floor((new Date('2015/1/15'))/1000).toString(16) + "0000000000000000")
  }
})

If you want to query your collection chronologically based on the timestamp in the first 4 bytes of an ObjectId, you can simply order by id:

# To get the oldest items first, use pymongo.ASCENDING; for most recent first, use pymongo.DESCENDING
items = db.your_collection.find().sort("_id", pymongo.ASCENDING)

Once you have retrieved the documents, you can extract the generation time of the ObjectId using the following method:

id = some_object_id
generation_time = id.generation_time

Yes, it is possible to query objects by date using MongoDB's inserted ID.

db.collectionname.find({_id: {$lt: ObjectId.fromDate( new ISODate("TZformat") ) } });

Let's say we have a collection called users and we want to retrieve all users created before January 5th, 2018.

db.users.find({_id: {$lt: ObjectId.fromDate( new ISODate("2018-01-05T00:00:00.000Z") ) } });

To run a query for users created within the last 3 hours, you can use:

db.users.find({_id: {$lt: ObjectId.fromDate(new Date((new Date().getTime() - (1 * 3 * 60 * 60 * 1000))) ) } })

This will return all users created within the current time minus 3 hours.

I retrieved documents that are 60 days old from a MongoDB collection by executing the following query in the shell.

db.collection.find({_id: {$lt:new ObjectId( Math.floor(new Date(new Date()-1000*60*60*24*60).getTime()/1000).toString(16) + "0000000000000000" )}})

Looking to perform a range query? Check out this helpful resource that explains how to do it. For instance, if you want to query for data on a specific day (e.g., April 4th, 2015):

> var objIdMin = ObjectId(Math.floor((new Date('2015/4/4'))/1000).toString(16) + "0000000000000000")
> var objIdMax = ObjectId(Math.floor((new Date('2015/4/5'))/1000).toString(16) + "0000000000000000")
> db.collection.find({_id:{$gt: objIdMin, $lt: objIdMax}}).pretty()

Filtering Data in MongoDB Compass Made Easy.

Versions Used:

• Compass version: 1.25.0
• MongoDB version: 4.2.8

Simple Filter Option:

The solution provided by @s7vr was effective for me. Simply enter the following into the Filter field:

{$expr: { $and: [ {$gte: [{$toDate: "$_id"}, ISODate('2021-01-01')]}, {$lt: [{$toDate: "$_id"}, ISODate('2021-02-01')]} ] } }

Alternative Filter Option:

Another valid approach is to consider the month index starting from 0, like so:

{_id: {$gte: ObjectId(Date(2021, 0, 1) / 1000), $lt: ObjectId(Date(2021, 1, 1) / 1000) } }

Equivalent using ISODate:

{_id: {$gte: ObjectId(ISODate('2021-01-01') / 1000), $lt: ObjectId(Date('2021-02-01') / 1000) } }

After executing these queries, I conducted a performance analysis with the results as follows:

• Option 1: 39 ms, 0 indexes used, 30 ms in COLLSCAN
• Option 2: 0 ms, _id index used
• Option 3: 1 ms, _id index used, 1 ms in FETCH

Based on my evaluation, it seems that option 2 provides the best efficiency. However, I prefer Option 3 due to its simplicity of utilizing ISODate rather than dealing with 0-based indexing for months in Date objects.

According to the provided documentation:

o = new ObjectId()
date = o.getTimestamp()

By following this method, you will obtain a date in ISODate format.

For additional details, please refer to .

When utilizing MongoObjectID, you can retrieve results using the following approach:

db.mycollection.find({ _id: { $gt: ObjectId("5217a543dd99a6d9e0f74702").getTimestamp().getTime()}});

When working with Rails and mongoid, you have the ability to perform queries using the following syntax:

  time = Time.utc(2010, 1, 1)
  time_id = ObjectId.from_time(time)
  collection.find({'_id' => {'$lt' => time_id}})