# Deleting Documents Safely

deleteOne and deleteMany remove the documents a filter matches, with no undo, so you run the same filter with find first; an empty filter deletes everything, drop removes the whole collection, and a soft delete hides a document without losing it.

Apprentice · MongoDB · Updated November 19, 2026

By Gregor Dzierzon

## After this lesson you can

- Delete documents with deleteOne and deleteMany after checking the same filter with find, and explain what an empty filter deletes
- Archive documents with a soft delete instead of deleting them, and find the documents that aren't archived
- Choose the update or delete a change to Sunday Kitchen's data needs, from $set, $unset, $inc, $push, $pull, $addToSet, upserts and deletes

## Key takeaways

- deleteOne removes the first document the filter matches, and deleteMany removes every match. deletedCount says how many went.
- A delete can't be undone. Run the same filter with find first, read what it finds, then change find to deleteMany.
- An empty filter matches every document, so deleteMany with an empty filter empties the collection. drop removes the collection itself.
- A soft delete sets a field such as archived to true instead of deleting, so the document can be hidden now and brought back later.

Clearing out test data, removing a canceled order, closing an account: sooner or later every app deletes something. A database has no recycle bin, so a delete with the wrong filter is gone for good, and the mistakes that cause it are small ones. You'll use what this lesson teaches every time you're about to remove data, at work and in your own projects.

The examples use Sunday Kitchen's 40 recipes from *Adding Many Documents with insertMany*. In `mongosh`, after `use sunday_kitchen`, load them again first:

```mongodb
load("sunday-kitchen-recipes.js")
```

```text
true
```

## deleteOne and deleteMany

A delete takes one argument: a filter, written exactly as in `find`. `deleteOne` removes the first document it matches, and `deleteMany` removes every match. Add a practice card, then delete it:

```mongodb
db.recipes.insertOne({ _id: 41, name: "Test Card", meal: "dinner", minutes: 1 })
```

```text
{ acknowledged: true, insertedId: 41 }
```

```mongodb
db.recipes.deleteOne({ _id: 41 })
```

```text
{ acknowledged: true, deletedCount: 1 }
```

`deletedCount` says how many documents went. Like an update that matches nothing, a delete that matches nothing isn't an error: it answers `deletedCount: 0`.

## Look before you delete

Sunday Kitchen is retiring the recipes rated below 3.8. Someone writes the filter with `$not`, from *Combining Conditions: $and, $or and $not*. Before deleting anything, run the very same filter with `find` and read what it finds:

```mongodb
db.recipes.find({ rating: { $not: { $gte: 3.8 } } }, { name: 1, rating: 1 })
```

```text
[
  { _id: 13, name: 'Veggie Stir-Fry' },
  { _id: 19, name: 'Lentil Soup', rating: null },
  { _id: 21, name: 'Palak Paneer' },
  { _id: 25, name: 'Bibimbap' },
  { _id: 29, name: 'Minestrone', rating: 3.7 },
  { _id: 32, name: 'Overnight Oats', rating: 3.6 },
  { _id: 35, name: 'Hummus', rating: null },
  { _id: 36, name: 'Spanakopita' },
  { _id: 39, name: 'Churros' }
]
```

Nine recipes, not two. `$not` matches every recipe whose rating isn't 3.8 or higher, and that includes the seven nobody has rated yet. As a `deleteMany`, this filter would have thrown away seven recipes that might be loved. `$lt` only matches real ratings:

```mongodb
db.recipes.find({ rating: { $lt: 3.8 } }, { name: 1, rating: 1 })
```

```text
[
  { _id: 29, name: 'Minestrone', rating: 3.7 },
  { _id: 32, name: 'Overnight Oats', rating: 3.6 }
]
```

That's the list Sunday Kitchen meant. Now change `find` to `deleteMany` and nothing else, so the filter you checked is the filter that runs:

```mongodb
db.recipes.deleteMany({ rating: { $lt: 3.8 } })
```

```text
{ acknowledged: true, deletedCount: 2 }
```

The habit is three steps: write the filter, run it with `find` (or `countDocuments` for a big collection) and read the answer, then change only the method name.

![Two steps side by side, both using the same filter card that reads rating $lt 3.8. Step 1, labeled find first, lifts two recipe cards out of a box for a look: Minestrone and Overnight Oats. Step 2, labeled then deleteMany, drops those same two cards into a shredder, with a tag reading deletedCount: 2.](https://fsdtrainingmedia.blob.core.windows.net/public/images/2026/11/e3dc48427a40410e9ad4aabc204a0980.webp)

## The empty filter deletes everything

An empty filter, `{}`, matches every document. That's what makes `find({})` list them all, and it's what makes this delete every recipe:

```mongodb
db.recipes.deleteMany({})
```

```text
{ acknowledged: true, deletedCount: 38 }
```

```mongodb
db.recipes.countDocuments()
```

```text
0
```

The collection is still there, empty. `drop()` (read "drop") removes the collection itself, which `sunday-kitchen-recipes.js` does at its start so it can load fresh:

```mongodb
db.recipes.drop()
```

```text
true
```

Load the recipes again before you go on:

```mongodb
load("sunday-kitchen-recipes.js")
```

```text
true
```

## Soft deletes: hide it, keep it

Sometimes deleting is the wrong tool: a recipe might come back next season, a cook may still have it in their favorites, or someone may ask what was removed. A **soft delete** marks the document instead of removing it, often with an `archived` field:

```mongodb
db.recipes.updateMany({ rating: { $lt: 3.8 } }, { $set: { archived: true } })
```

```text
{
  acknowledged: true,
  insertedId: null,
  matchedCount: 2,
  modifiedCount: 2,
  upsertedCount: 0
}
```

The menu then asks only for the recipes that aren't archived. `$ne: true` also matches the documents with no `archived` field, which is all the others:

```mongodb
db.recipes.countDocuments({ archived: { $ne: true } })
```

```text
38
```

Bringing a recipe back is one update, `$unset: { archived: "" }`. The cost is that every query that lists recipes has to remember the `archived` filter.

## Which change for which job

This chapter has given you a tool for each kind of change. Before you write one, name the kind:

| The change | The tool |
|---|---|
| Fix or add a field | `updateOne` with `$set` |
| Take a field away | `$unset` |
| Count up or down | `$inc` |
| Add to a list, repeats allowed | `$push` |
| Add to a list only once | `$addToSet` |
| Take every copy of an item out of a list | `$pull` |
| Create it, or change it if it's there | an update with `upsert: true` |
| Remove documents for good | `deleteMany`, after `find` with the same filter |
| Hide documents, but keep them | a soft delete: `$set: { archived: true }` |

## Check yourself

2 questions to try on the lesson page.

## So what

Deleting is the one change you can't take back. Checking the filter with `find` first, knowing what `{}` means, and archiving instead when you might need it back are what keep a cleanup from becoming a lost afternoon.

## Key terms

- [deleteOne and deleteMany](https://www.ask-codey.com/glossary/deleteone-and-deletemany)
- [Soft Delete](https://www.ask-codey.com/glossary/soft-delete)
- [drop()](https://www.ask-codey.com/glossary/drop)
- [Query Filter](https://www.ask-codey.com/glossary/query-filter)

## Related

- [Missing Fields, null and $exists](https://www.ask-codey.com/lessons/mongodb-missing-fields-null-and-exists)
- [Upserts and Replacing a Whole Document](https://www.ask-codey.com/lessons/mongodb-upserts-and-replaceone)

Source: https://www.ask-codey.com/lessons/mongodb-deleting-documents-safely
