The $arrayElemAt operator returns the element at a specific index in an array. It is one of the most useful array operators in MongoDB aggregation pipelines — perfect for grabbing the first item, the last item, or any position by number.
Pick one array element.
Index 0 is first item.
-1 gets last element.
Works on document fields.
Tags, items, history.
Invalid index → null.
In MongoDB’s aggregation framework, the $arrayElemAt operator returns a single element from an array at the given index. For example, { $arrayElemAt: [ "$tags", 0 ] } returns the first tag, and { $arrayElemAt: [ "$tags", -1 ] } returns the last tag. This is similar to JavaScript’s array[index] access inside a pipeline.
Indexes start at 0. Use -1 for the last element instead of calculating the array length manually.
The $arrayElemAt operator takes an array and an index:
{ $arrayElemAt: [ <array expression>, <index> ] }$arrayElemAt — returns the element at the specified zero-based index.-1 is the last element, -2 is second-to-last.$project, $addFields, or $set.null.For array ["a", "b", "c", "d"]:
"a" (first)"c" (third)"d" (last)null (out of range)| Question | Answer |
|---|---|
| Operator type | Aggregation expression operator (array) |
| Syntax | { $arrayElemAt: [ array, index ] } |
| Index base | Zero-based (0 = first element) |
| Negative index | Supported (-1 = last) |
| Out of bounds | Returns null |
{
$arrayElemAt: ["$arr", 0]
}First element
{
$arrayElemAt: ["$arr", -1]
}Last element
{
$arrayElemAt: [["a","b"], 1]
}Returns "b"
{
$arrayElemAt: ["$arr", 99]
}Returns null
Extract first and last tags, access order line items, and handle edge cases with index bounds.
Pull specific elements from array fields using $project.
Suppose you have an orders collection with a tags array:
[
{ "_id": 1, "orderId": "ORD-101", "tags": [ "urgent", "paid", "shipped" ] },
{ "_id": 2, "orderId": "ORD-102", "tags": [ "draft", "pending" ] },
{ "_id": 3, "orderId": "ORD-103", "tags": [] }
]Extract the first tag from each order:
db.orders.aggregate([
{
$project: {
orderId: 1,
tags: 1,
firstTag: { $arrayElemAt: [ "$tags", 0 ] }
}
}
])0 is "urgent".0 is "draft".null.Use negative indexes, access nested item arrays, and guard against missing data.
Negative indexes count from the end of the array:
db.orders.aggregate([
{
$project: {
orderId: 1,
firstTag: { $arrayElemAt: [ "$tags", 0 ] },
lastTag: { $arrayElemAt: [ "$tags", -1 ] },
secondTag: { $arrayElemAt: [ "$tags", 1 ] }
}
}
])-1 always targets the last element without needing $size. Index 1 returns null when the array is too short.
Extract the product name from the first line item:
db.orders.aggregate([
{
$project: {
orderId: 1,
primaryItem: {
$arrayElemAt: [ "$items", 0 ]
}
}
},
{
$project: {
orderId: 1,
primaryProduct: "$primaryItem.name",
primaryQty: "$primaryItem.qty"
}
}
])$arrayElemAt returns the whole object at index 0. A second $project stage pulls fields from that object.
Provide a fallback when the index is out of range or the array is empty:
db.orders.aggregate([
{
$project: {
orderId: 1,
statusTag: {
$ifNull: [
{ $arrayElemAt: [ "$tags", -1 ] },
"unknown"
]
}
}
}
])When $arrayElemAt returns null (empty array or bad index), $ifNull substitutes "unknown" so reports stay readable.
items array.$arrayElemAt WorksThe pipeline evaluates the array expression — a field like "$tags" or a literal array.
MongoDB locates the element at the given index. Negative values count backward from the end.
If the index exists, that value is returned. Otherwise MongoDB returns null.
Use the result in further stages, sorting, grouping, or display fields.
The $arrayElemAt operator is a straightforward way to read one position from an array inside MongoDB aggregation pipelines. It supports zero-based and negative indexes, works on field arrays and literals, and returns null when the index is invalid.
For beginners, remember: index 0 is the first item, -1 is the last, and wrap with $ifNull when you need a fallback value.
-1 to get the last element without calculating length$ifNull for missing or empty arrays$project to read fields from object elements$arrayElemAt when the index is dynamic or computed$arrayElemAt when you need the whole array$first / $last accumulators in $groupnull results in downstream calculations$arrayElemAtUse these points when reading array data in aggregation pipelines.
One element by number.
Purpose[ array, index ]
0 = first element.
Indexing-1 = last element.
ShortcutReturns null.
Edge caseMove on to $arrayToObject to convert arrays into key-value objects.
5 people found this page helpful