The $rand operator generates a random floating-point number between 0 and 1 for each document in an aggregation pipeline. Use it for sampling, shuffling, A/B testing, and any workflow that needs probabilistic logic.
One value per document.
{ $rand: {} }
Filter by threshold.
Sort on random field.
Tests, lotteries, A/B.
Flexible vs fixed count.
In MongoDB’s aggregation framework, the $rand operator returns a pseudo-random double in the range [0, 1) — that is, greater than or equal to 0 and less than 1. Each document evaluated in the pipeline receives its own independent random value.
Unlike stages that pick a fixed number of documents (such as $sample), $rand gives you a numeric value you can compare, sort, scale, or store. This makes it ideal for percentage-based sampling and custom random logic.
$rand takes no arguments — always write { $rand: {} }. Use it inside $project or $addFields to add a random field, or inside $match with $expr to filter probabilistically.
The $rand operator takes an empty object (no parameters):
{ $rand: {} }{}.$project, $addFields, $set, or $match with $expr.{ $sampleRate: 0.2 } in $match for ~20% pass rate{ $expr: { $lt: [ { $rand: {} }, 0.2 ] } }| Question | Answer |
|---|---|
| Operator type | Aggregation expression operator (random) |
| Syntax | { $rand: {} } |
| Output range | [0, 1) — 0 inclusive, 1 exclusive |
| Arguments | None (empty object) |
| Common stages | $project, $addFields, $match + $expr |
{
randomScore: {
$rand: {}
}
}Add random field
$expr: {
$lt: [
{ $rand: {} },
0.2
]
}~20% of docs
$sort: {
shuffle: 1
}After $rand field
{
$floor: {
$multiply: [
{ $rand: {} },
100
]
}
}Scale to integer
Add random scores, sample a percentage of users, shuffle results, and scale random values to integer ranges.
Assign each document a random value between 0 and 1 with $project.
Suppose you have a users collection:
[
{ "_id": 1, "name": "Alice", "plan": "pro" },
{ "_id": 2, "name": "Bob", "plan": "free" },
{ "_id": 3, "name": "Carol", "plan": "pro" },
{ "_id": 4, "name": "Dave", "plan": "free" },
{ "_id": 5, "name": "Eve", "plan": "pro" }
]Add a randomScore field to every document:
db.users.aggregate([
{
$project: {
name: 1,
plan: 1,
randomScore: { $rand: {} }
}
}
])Each document gets an independent random double. Values change on every pipeline run, which is expected for pseudo-random generation.
Percentage sampling, shuffling, integer ranges, and A/B assignment.
Keep documents where the random value is below 0.2 (roughly 20%):
db.users.aggregate([
{
$match: {
$expr: {
$lt: [ { $rand: {} }, 0.2 ]
}
}
},
{
$project: {
name: 1,
plan: 1
}
}
])Because $rand is uniformly distributed in [0, 1), comparing it to 0.2 gives each document a ~20% chance of passing. The exact count varies per run.
Add a random field, sort by it, and limit results for a shuffled pick:
db.products.aggregate([
{
$addFields: {
shuffle: { $rand: {} }
}
},
{ $sort: { shuffle: 1 } },
{ $limit: 5 },
{
$project: {
name: 1,
price: 1
}
}
])Sorting on a random field produces a different document order each run. Use $limit to pick a random subset without the $sample stage.
Split users into group A or B based on a random threshold:
db.users.aggregate([
{
$project: {
name: 1,
testGroup: {
$cond: {
if: { $lt: [ { $rand: {} }, 0.5 ] },
then: "A",
else: "B"
}
}
}
}
])Users with $rand < 0.5 go to group A; the rest go to B. Pair $rand with $cond for simple 50/50 splits or adjust the threshold for uneven groups.
Multiply by 100 and floor for a random integer:
db.lottery.aggregate([
{
$project: {
ticketId: 1,
luckyNumber: {
$floor: {
$multiply: [ { $rand: {} }, 100 ]
}
}
}
}
])
// luckyNumber: 0 through 99$rand gives [0, 1). Multiplying by 100 gives [0, 100), and $floor truncates to integers 0–99. Change the multiplier for different ranges.
$cond and $rand.$limit for fair picks.$rand WorksWhen a stage evaluates { $rand: {} }, MongoDB invokes its random number generator for each document.
Each document receives a value in [0, 1) — independent of other documents in the same evaluation.
Store it in a field, compare it in $match, sort on it, or scale it with $multiply.
Sample, shuffle, split, or score documents with built-in randomness.
The $rand operator generates random numbers in [0, 1) inside MongoDB aggregation pipelines. With no arguments and simple syntax, it powers sampling, shuffling, A/B tests, and custom probabilistic filters.
Remember each run produces different values, and percentage sampling is approximate. Next in the series: $range.
{ $rand: {} } with an empty object$expr for percentage sampling$cond for A/B group assignment$sample when you need an exact document count$multiply and $floor for integer ranges$rand (it accepts none)$rand as a top-level query filter without $expr$randUse these points when adding randomness to aggregation pipelines.
Per document.
Purpose{ $rand: {} }
$lt threshold.
PatternSort on random field.
Use caseChanges each run.
Edge caseMove on to $range for generating sequences, or review $cond for conditional logic.
5 people found this page helpful