Insert Documents
On this page
➤ Use the Select your language drop-down menu in the upper-right to set the language of the following examples or select MongoDB Compass.
This page provides examples of insert operations in MongoDB.
You can insert documents in MongoDB by using the following methods:
Your programming language's driver.
The MongoDB Atlas UI. To learn more, see Insert Documents in the MongoDB Atlas UI.
Note
Creating a Collection
If the collection does not currently exist, insert operations will create the collection.
Insert Documents in the MongoDB Atlas UI
To insert a document in the MongoDB Atlas UI, complete the following steps. To learn more about working with documents in the MongoDB Atlas UI, see Create, View, Update, and Delete Documents.
In the MongoDB Atlas UI, go to the Clusters page for your project.
If it's not already displayed, select the organization that contains your desired project from the Organizations menu in the navigation bar.
If it's not already displayed, select your project from the Projects menu in the navigation bar.
If it's not already displayed, click Clusters in the sidebar.
The Clusters page displays.
Add the documents
Click Insert Document.
Click the {} icon, which opens the JSON view.
Paste the document array into the text entry field. For example, the following entry creates four documents, each of which contain three fields:
[ { "prodId": 100, "price": 20, "quantity": 125 }, { "prodId": 101, "price": 10, "quantity": 234 }, { "prodId": 102, "price": 15, "quantity": 432 }, { "prodId": 103, "price": 17, "quantity": 320 } ]
Insert a Single Document
db.collection.insertOne()
inserts a single
document into a collection.
The following example inserts a new document into the
inventory
collection. If the document does not specify
an _id
field, MongoDB adds the _id
field with an
ObjectId value to the new document. See
Insert Behavior.
To insert a single document using MongoDB Compass:
Navigate to the collection you wish to insert the document into:
In the left-hand MongoDB Compass navigation pane, click the database to which your target collection belongs.
From the database view, click the target collection name.
Click the Insert Document button:
For each field in the document, select the field type and fill in the field name and value. Add fields by clicking the last line number, then clicking Add Field After ...
For
Object
types, add nested fields by clicking the last field's number and selecting Add Field After ...For
Array
types, add additional elements to the array by clicking the last element's line number and selecting Add Array Element After ...
Once all fields have been filled out, click Insert.
The following example inserts a new document into the
test.inventory
collection:
IMongoCollection.InsertOne() inserts a single document into a collection.
The following example inserts a new document into the
inventory
collection. If the document does not specify
an _id
field, the C# driver adds the _id
field
with an ObjectId value to the new document. See
Insert Behavior.
Collection.InsertOne inserts a single document into a collection.
The following example inserts a new document into the
inventory
collection. If the document does not specify
an _id
field, the driver adds the _id
field
with an ObjectId value to the new document. See
Insert Behavior.
com.mongodb.reactivestreams.client.MongoCollection.insertOne inserts a single document into a collection with the Java Reactive Streams Driver:
{ item: "canvas", qty: 100, tags: ["cotton"], size: { h: 28, w: 35.5, uom: "cm" } }
The following example inserts the document above into the
inventory
collection. If the document does not specify
an _id
field, the driver adds the _id
field with an
ObjectId value to the new document. See
Insert Behavior.
com.mongodb.client.MongoCollection.insertOne inserts a single document into a collection.
The following example inserts a new document into the
inventory
collection. If the document does not specify
an _id
field, the driver adds the _id
field with an
ObjectId value to the new document. See
Insert Behavior.
motor.motor_asyncio.AsyncIOMotorCollection.insert_one
inserts a
single document into a
collection.
The following example inserts a new document into the
inventory
collection. If the document does not specify
an _id
field, the Motor driver adds the _id
field
with an ObjectId value to the new document. See
Insert Behavior.
Collection.insertOne() inserts a single document into a collection.
The following example inserts a new document into the
inventory
collection. If the document does not specify
an _id
field, the Node.js driver adds the _id
field
with an ObjectId value to the new document. See
Insert Behavior.
MongoDB::Collection::insert_one() inserts a single document into a collection.
The following example inserts a new document into the
inventory
collection. If the document does not specify
an _id
field, the Perl driver adds the _id
field
with an ObjectId value to the new document. See
Insert Behavior.
MongoDB\\Collection::insertOne()
inserts a single document into a
collection.
The following example inserts a new document into the
inventory
collection. If the document does not specify
an _id
field, the PHP driver adds the _id
field
with an ObjectId value to the new document. See
Insert Behavior.
pymongo.collection.Collection.insert_one
inserts a
single document into a
collection.
The following example inserts a new document into the
inventory
collection. If the document does not specify
an _id
field, the PyMongo driver adds the _id
field
with an ObjectId value to the new document. See
Insert Behavior.
Mongo::Collection#insert_one() inserts a single document into a collection.
The following example inserts a new document into the
inventory
collection. If the document does not specify
an _id
field, the Ruby driver adds the _id
field
with an ObjectId value to the new document. See
Insert Behavior.
collection.insertOne() inserts a single document into a collection.
The following example inserts a new document into the
inventory
collection. If the document does not specify
an _id
field, the Scala driver adds the _id
field
with an ObjectId value to the new document. See
Insert Behavior.
db.inventory.insertOne( { item: "canvas", qty: 100, tags: ["cotton"], size: { h: 28, w: 35.5, uom: "cm" } } )
var document = new BsonDocument { { "item", "canvas" }, { "qty", 100 }, { "tags", new BsonArray { "cotton" } }, { "size", new BsonDocument { { "h", 28 }, { "w", 35.5 }, { "uom", "cm" } } } }; collection.InsertOne(document);
result, err := coll.InsertOne( context.TODO(), bson.D{ {"item", "canvas"}, {"qty", 100}, {"tags", bson.A{"cotton"}}, {"size", bson.D{ {"h", 28}, {"w", 35.5}, {"uom", "cm"}, }}, })
Document canvas = new Document("item", "canvas") .append("qty", 100) .append("tags", singletonList("cotton")); Document size = new Document("h", 28) .append("w", 35.5) .append("uom", "cm"); canvas.put("size", size); Publisher<Success> insertOnePublisher = collection.insertOne(canvas);
Document canvas = new Document("item", "canvas") .append("qty", 100) .append("tags", singletonList("cotton")); Document size = new Document("h", 28) .append("w", 35.5) .append("uom", "cm"); canvas.put("size", size); collection.insertOne(canvas);
await db.inventory.insert_one( { "item": "canvas", "qty": 100, "tags": ["cotton"], "size": {"h": 28, "w": 35.5, "uom": "cm"}, } )
await db.collection('inventory').insertOne({ item: 'canvas', qty: 100, tags: ['cotton'], size: { h: 28, w: 35.5, uom: 'cm' } });
$db->coll("inventory")->insert_one( { item => "canvas", qty => 100, tags => ["cotton"], size => { h => 28, w => 35.5, uom => "cm" } } );
$insertOneResult = $db->inventory->insertOne([ 'item' => 'canvas', 'qty' => 100, 'tags' => ['cotton'], 'size' => ['h' => 28, 'w' => 35.5, 'uom' => 'cm'], ]);
db.inventory.insert_one( { "item": "canvas", "qty": 100, "tags": ["cotton"], "size": {"h": 28, "w": 35.5, "uom": "cm"}, } )
client[:inventory].insert_one({ item: 'canvas', qty: 100, tags: [ 'cotton' ], size: { h: 28, w: 35.5, uom: 'cm' } })
collection.insertOne( Document("item" -> "canvas", "qty" -> 100, "tags" -> Seq("cotton"), "size" -> Document("h" -> 28, "w" -> 35.5, "uom" -> "cm")) ).execute()
insertOne()
returns a document that
includes the newly inserted document's _id
field value. For
an example of a return document, see
db.collection.insertOne() reference.
Note
MongoDB Compass generates the _id
field and its value
automatically. The generated
ObjectId consists of a
unique randomly generated hexadecimal value.
You can change this value prior to inserting your document
so long as it remains unique and is a valid ObjectId
.
For more information on the _id
field, see
_id Field.
Collection.InsertOne
function returns an instance of
InsertOneResult whose
InsertedID
attribute contains the _id
of the newly
inserted document.
com.mongodb.client.MongoCollection.insertOne returns an
instance of InsertOneResult.
You can access the _id
field of the inserted document by
calling the getInsertedId() method on the result.
insert_one
returns an
instance of pymongo.results.InsertOneResult
whose
inserted_id
field contains the _id
of the newly
inserted document.
insertOne() returns a
promise that provides a result
. The result.insertedId
promise contains the _id
of the newly inserted document.
Upon successful insert, the
insert_one() method returns
an instance of
MongoDB::InsertOneResult whose
inserted_id
attribute contains the _id
of the newly
inserted document.
Upon successful insert, the
insertOne()
method returns an instance of
MongoDB\\InsertOneResult
whose
getInsertedId()
method returns the _id
of the newly inserted document.
insert_one
returns an
instance of pymongo.results.InsertOneResult
whose
inserted_id
field contains the _id
of the newly
inserted document.
Upon successful insert, the
insert_one()
method returns an instance of
Mongo::Operation::Result, whose
inserted_id
attribute contains the _id
of the newly
inserted document.
Upon successful insert, the
collection.insertOne()
method returns an instance of
collection.insertOne().results(); whose
inserted_id
attribute contains the _id
of the newly
inserted document.
To retrieve the document that you just inserted, query the collection:
db.inventory.find( { item: "canvas" } )
Specify a filter in the MongoDB Compass query bar and click Find to execute the query.
The above filter specifies that MongoDB Compass only return
documents where the item
field is equal to canvas
.
For more information on the MongoDB Compass Query Bar, see the Compass Query Bar documentation.
var filter = Builders<BsonDocument>.Filter.Eq("item", "canvas"); var result = collection.Find(filter).ToList();
cursor, err := coll.Find( context.TODO(), bson.D{{"item", "canvas"}}, )
FindPublisher<Document> findPublisher = collection.find(eq("item", "canvas"));
FindIterable<Document> findIterable = collection.find(eq("item", "canvas"));
cursor = db.inventory.find({"item": "canvas"})
const cursor = db.collection('inventory').find({ item: 'canvas' });
$cursor = $db->coll("inventory")->find( { item => "canvas" } );
$cursor = $db->inventory->find(['item' => 'canvas']);
cursor = db.inventory.find({"item": "canvas"})
client[:inventory].find(item: 'canvas')
val observable = collection.find(equal("item", "canvas"))
Insert Multiple Documents
➤ Use the Select your language drop-down menu in the upper-right to set the language of the examples on this page.
db.collection.insertMany()
can insert multiple
documents into a collection. Pass an
array of documents to the method.
The following example inserts three new documents into the
inventory
collection. If the documents do not specify an
_id
field, MongoDB adds the _id
field with an ObjectId
value to each document. See Insert Behavior.
IMongoCollection.InsertMany() can insert multiple documents into a collection. Pass an enumerable collection of documents to the method.
The following example inserts three new documents into the
inventory
collection. If the documents do not specify an
_id
field, the driver adds the _id
field with
an ObjectId value to each document. See Insert Behavior.
Collection.InsertMany can insert multiple documents into a collection.
The following example inserts three new documents into the
inventory
collection. If the documents do not specify an
_id
field, the driver adds the _id
field with
an ObjectId value to each document. See Insert Behavior.
com.mongodb.reactivestreams.client.MongoCollection.html.insertMany inserts the following documents with the Java Reactive Streams Driver:
{ item: "journal", qty: 25, tags: ["blank", "red"], size: { h: 14, w: 21, uom: "cm" } } { item: "mat", qty: 85, tags: ["gray"], size: { h: 27.9, w: 35.5, uom: "cm" } } { item: "mousepad", qty: 25, tags: ["gel", "blue"], size: { h: 19, w: 22.85, uom: "cm" } }
The following example inserts three new documents into the
inventory
collection. If the documents do not specify an
_id
field, the driver adds the _id
field with
an ObjectId value to each document. See Insert Behavior.
com.mongodb.client.MongoCollection.insertMany can insert multiple documents into a collection. Pass a list of documents to the method.
The following example inserts three new documents into the
inventory
collection. If the documents do not specify an
_id
field, the driver adds the _id
field with
an ObjectId value to each document. See Insert Behavior.
motor.motor_asyncio.AsyncIOMotorCollection.insert_many
can insert multiple documents
into a collection. Pass an iterable of documents to the method.
The following example inserts three new documents into the
inventory
collection. If the documents do not specify an
_id
field, the PyMongo driver adds the _id
field with
an ObjectId value to each document. See Insert Behavior.
Collection.insertMany() can insert multiple documents into a collection. Pass an array of documents to the method.
The following example inserts three new documents into the
inventory
collection. If the documents do not specify an
_id
field, the Node.js driver adds the _id
field with
an ObjectId value to each document. See
Insert Behavior.
MongoDB::Collection::insert_many() can insert multiple documents into a collection. Pass an array reference of documents to the method.
The following example inserts three new documents into the
inventory
collection. If the documents do not specify an
_id
field, the Perl driver adds the _id
field with
an ObjectId value to each document. See Insert Behavior.
MongoDB\\Collection::insertMany()
can insert multiple documents into a
collection. Pass an array of documents to the method.
The following example inserts three new documents into the
inventory
collection. If the documents do not specify an
_id
field, the PHP driver adds the _id
field with
an ObjectId value to each document. See Insert Behavior.
pymongo.collection.Collection.insert_many
can insert
multiple documents into a
collection. Pass an iterable of documents to the method.
The following example inserts three new documents into the
inventory
collection. If the documents do not specify an
_id
field, the PyMongo driver adds the _id
field with
an ObjectId value to each document. See Insert Behavior.
Mongo::Collection#insert_many() can insert multiple documents into a collection. Pass an array of documents to the method.
The following example inserts three new documents into the
inventory
collection. If the documents do not specify an
_id
field, the Ruby driver adds the _id
field with
an ObjectId value to each document. See Insert Behavior.
collection.insertMany() can insert multiple documents into a collection.
The following example inserts three new documents into the
inventory
collection. If the documents do not specify an
_id
field, the Scala driver adds the _id
field with
an ObjectId value to each document. See Insert Behavior.
db.inventory.insertMany([ { item: "journal", qty: 25, tags: ["blank", "red"], size: { h: 14, w: 21, uom: "cm" } }, { item: "mat", qty: 85, tags: ["gray"], size: { h: 27.9, w: 35.5, uom: "cm" } }, { item: "mousepad", qty: 25, tags: ["gel", "blue"], size: { h: 19, w: 22.85, uom: "cm" } } ])
[ { "item": "canvas", "qty": 100, "size": { "h": 28, "w": 35.5, "uom": "cm" }, "status": "A" }, { "item": "journal", "qty": 25, "size": { "h": 14, "w": 21, "uom": "cm" }, "status": "A" }, { "item": "mat", "qty": 85, "size": { "h": 27.9, "w": 35.5, "uom": "cm" }, "status": "A" }, { "item": "mousepad", "qty": 25, "size": { "h": 19, "w": 22.85, "uom": "cm" }, "status": "P" }, { "item": "notebook", "qty": 50, "size": { "h": 8.5, "w": 11, "uom": "in" }, "status": "P" }, { "item": "paper", "qty": 100, "size": { "h": 8.5, "w": 11, "uom": "in" }, "status": "D" }, { "item": "planner", "qty": 75, "size": { "h": 22.85, "w": 30, "uom": "cm" }, "status": "D" }, { "item": "postcard", "qty": 45, "size": { "h": 10, "w": 15.25, "uom": "cm" }, "status": "A" }, { "item": "sketchbook", "qty": 80, "size": { "h": 14, "w": 21, "uom": "cm" }, "status": "A" }, { "item": "sketch pad", "qty": 95, "size": { "h": 22.85, "w": 30.5, "uom": "cm" }, "status": "A" } ]
For instructions on inserting documents using MongoDB Compass, see Insert Documents.
var documents = new BsonDocument[] { new BsonDocument { { "item", "journal" }, { "qty", 25 }, { "tags", new BsonArray { "blank", "red" } }, { "size", new BsonDocument { { "h", 14 }, { "w", 21 }, { "uom", "cm"} } } }, new BsonDocument { { "item", "mat" }, { "qty", 85 }, { "tags", new BsonArray { "gray" } }, { "size", new BsonDocument { { "h", 27.9 }, { "w", 35.5 }, { "uom", "cm"} } } }, new BsonDocument { { "item", "mousepad" }, { "qty", 25 }, { "tags", new BsonArray { "gel", "blue" } }, { "size", new BsonDocument { { "h", 19 }, { "w", 22.85 }, { "uom", "cm"} } } }, }; collection.InsertMany(documents);
result, err := coll.InsertMany( context.TODO(), []interface{}{ bson.D{ {"item", "journal"}, {"qty", int32(25)}, {"tags", bson.A{"blank", "red"}}, {"size", bson.D{ {"h", 14}, {"w", 21}, {"uom", "cm"}, }}, }, bson.D{ {"item", "mat"}, {"qty", int32(25)}, {"tags", bson.A{"gray"}}, {"size", bson.D{ {"h", 27.9}, {"w", 35.5}, {"uom", "cm"}, }}, }, bson.D{ {"item", "mousepad"}, {"qty", 25}, {"tags", bson.A{"gel", "blue"}}, {"size", bson.D{ {"h", 19}, {"w", 22.85}, {"uom", "cm"}, }}, }, })
Document journal = new Document("item", "journal") .append("qty", 25) .append("tags", asList("blank", "red")); Document journalSize = new Document("h", 14) .append("w", 21) .append("uom", "cm"); journal.put("size", journalSize); Document mat = new Document("item", "mat") .append("qty", 85) .append("tags", singletonList("gray")); Document matSize = new Document("h", 27.9) .append("w", 35.5) .append("uom", "cm"); mat.put("size", matSize); Document mousePad = new Document("item", "mousePad") .append("qty", 25) .append("tags", asList("gel", "blue")); Document mousePadSize = new Document("h", 19) .append("w", 22.85) .append("uom", "cm"); mousePad.put("size", mousePadSize); Publisher<Success> insertManyPublisher = collection.insertMany(asList(journal, mat, mousePad));
Document journal = new Document("item", "journal") .append("qty", 25) .append("tags", asList("blank", "red")); Document journalSize = new Document("h", 14) .append("w", 21) .append("uom", "cm"); journal.put("size", journalSize); Document mat = new Document("item", "mat") .append("qty", 85) .append("tags", singletonList("gray")); Document matSize = new Document("h", 27.9) .append("w", 35.5) .append("uom", "cm"); mat.put("size", matSize); Document mousePad = new Document("item", "mousePad") .append("qty", 25) .append("tags", asList("gel", "blue")); Document mousePadSize = new Document("h", 19) .append("w", 22.85) .append("uom", "cm"); mousePad.put("size", mousePadSize); collection.insertMany(asList(journal, mat, mousePad));
await db.inventory.insert_many( [ { "item": "journal", "qty": 25, "tags": ["blank", "red"], "size": {"h": 14, "w": 21, "uom": "cm"}, }, { "item": "mat", "qty": 85, "tags": ["gray"], "size": {"h": 27.9, "w": 35.5, "uom": "cm"}, }, { "item": "mousepad", "qty": 25, "tags": ["gel", "blue"], "size": {"h": 19, "w": 22.85, "uom": "cm"}, }, ] )
await db.collection('inventory').insertMany([ { item: 'journal', qty: 25, tags: ['blank', 'red'], size: { h: 14, w: 21, uom: 'cm' } }, { item: 'mat', qty: 85, tags: ['gray'], size: { h: 27.9, w: 35.5, uom: 'cm' } }, { item: 'mousepad', qty: 25, tags: ['gel', 'blue'], size: { h: 19, w: 22.85, uom: 'cm' } } ]);
$db->coll("inventory")->insert_many( [ { item => "journal", qty => 25, tags => [ "blank", "red" ], size => { h => 14, w => 21, uom => "cm" } }, { item => "mat", qty => 85, tags => ["gray"], size => { h => 27.9, w => 35.5, uom => "cm" } }, { item => "mousepad", qty => 25, tags => [ "gel", "blue" ], size => { h => 19, w => 22.85, uom => "cm" } } ] );
$insertManyResult = $db->inventory->insertMany([ [ 'item' => 'journal', 'qty' => 25, 'tags' => ['blank', 'red'], 'size' => ['h' => 14, 'w' => 21, 'uom' => 'cm'], ], [ 'item' => 'mat', 'qty' => 85, 'tags' => ['gray'], 'size' => ['h' => 27.9, 'w' => 35.5, 'uom' => 'cm'], ], [ 'item' => 'mousepad', 'qty' => 25, 'tags' => ['gel', 'blue'], 'size' => ['h' => 19, 'w' => 22.85, 'uom' => 'cm'], ], ]);
db.inventory.insert_many( [ { "item": "journal", "qty": 25, "tags": ["blank", "red"], "size": {"h": 14, "w": 21, "uom": "cm"}, }, { "item": "mat", "qty": 85, "tags": ["gray"], "size": {"h": 27.9, "w": 35.5, "uom": "cm"}, }, { "item": "mousepad", "qty": 25, "tags": ["gel", "blue"], "size": {"h": 19, "w": 22.85, "uom": "cm"}, }, ] )
client[:inventory].insert_many([{ item: 'journal', qty: 25, tags: ['blank', 'red'], size: { h: 14, w: 21, uom: 'cm' } }, { item: 'mat', qty: 85, tags: ['gray'], size: { h: 27.9, w: 35.5, uom: 'cm' } }, { item: 'mousepad', qty: 25, tags: ['gel', 'blue'], size: { h: 19, w: 22.85, uom: 'cm' } } ])
collection.insertMany(Seq( Document("item" -> "journal", "qty" -> 25, "tags" -> Seq("blank", "red"), "size" -> Document("h" -> 14, "w" -> 21, "uom" -> "cm")), Document("item" -> "mat", "qty" -> 85, "tags" -> Seq("gray"), "size" -> Document("h" -> 27.9, "w" -> 35.5, "uom" -> "cm")), Document("item" -> "mousepad", "qty" -> 25, "tags" -> Seq("gel", "blue"), "size" -> Document("h" -> 19, "w" -> 22.85, "uom" -> "cm")) )).execute()
insertMany()
returns a document that includes
the newly inserted documents _id
field values. See the
reference for an example.
To retrieve the inserted documents, query the collection:
To retrieve the inserted documents, query the collection:
To retrieve the inserted documents, query the collection:
com.mongodb.reactivestreams.client.MongoCollection.html.insertMany
returns a Publisher
object. The Publisher
inserts the document into a collection
when subscribers request data.
To retrieve the inserted documents, query the collection:
To retrieve the inserted documents, query the collection:
insert_many
returns an instance of pymongo.results.InsertManyResult
whose inserted_ids
field is a list containing the _id
of each newly inserted document.
To retrieve the inserted documents, query the collection:
insertMany() returns a
promise that provides a result
. The result.insertedIds
field contains an array with the _id
of each newly inserted
document.
To retrieve the inserted documents, query the collection:
Upon successful insert, the
insert_many() method
returns an instance of
MongoDB::InsertManyResult
whose inserted_ids
attribute is a list containing the
_id
of each newly inserted document.
To retrieve the inserted documents, query the collection:
Upon successful insert, the
insertMany()
method
returns an instance of
MongoDB\\InsertManyResult
whose
getInsertedIds()
method returns the _id
of each newly inserted document.
To retrieve the inserted documents, query the collection:
insert_many
returns
an instance of pymongo.results.InsertManyResult
whose inserted_ids
field is a list containing the _id
of each newly inserted document.
To retrieve the inserted documents, query the collection:
Upon successful insert, the
insert_many() method
returns an instance of
Mongo::BulkWrite::Result
whose inserted_ids
attribute is a list containing the
_id
of each newly inserted document.
To retrieve the inserted documents, query the collection:
Upon successful insert, the
insertMany()
method returns an Observable with a type parameter indicating when
the operation has completed or with either a
com.mongodb.DuplicateKeyException
or
com.mongodb.MongoException
.
To retrieve the inserted documents, query the collection:
db.inventory.find( {} )
var filter = Builders<BsonDocument>.Filter.Empty; var result = collection.Find(filter).ToList();
cursor, err := coll.Find( context.TODO(), bson.D{}, )
FindPublisher<Document> findPublisher = collection.find(new Document());
FindIterable<Document> findIterable = collection.find(new Document());
cursor = db.inventory.find({})
const cursor = db.collection('inventory').find({});
$cursor = $db->coll("inventory")->find( {} );
$cursor = $db->inventory->find([]);
cursor = db.inventory.find({})
client[:inventory].find({})
var findObservable = collection.find(Document())
Insert Behavior
Collection Creation
If the collection does not currently exist, insert operations will create the collection.
_id
Field
In MongoDB, each document stored in a standard collection requires a unique
_id field that acts as a primary key. If an inserted
document omits the _id
field, the MongoDB driver automatically
generates an ObjectId for the _id
field.
This also applies to documents inserted through update operations with upsert: true.
Atomicity
All write operations in MongoDB are atomic on the level of a single document. For more information on MongoDB and atomicity, see Atomicity and Transactions
Write Acknowledgement
With write concerns, you can specify the level of acknowledgment requested from MongoDB for write operations. For details, see Write Concern.