The $arrayToObject operator converts an array of key-value pairs into a single object. It is useful when your data stores properties as an array (like metadata or settings) and you need a normal document shape for querying or display.
Reshape key-value data.
Use k and v fields.
Use [key, value] pairs.
Transform document fields.
Settings, specs, metadata.
Pair with $objectToArray.
In MongoDB’s aggregation framework, the $arrayToObject operator takes an array where each element represents one key-value pair and returns a single object. For example, an array like [ { k: "color", v: "red" }, { k: "size", v: "L" } ] becomes { color: "red", size: "L" }.
Think of $arrayToObject as the opposite of $objectToArray. One turns objects into arrays; the other turns arrays back into objects.
The $arrayToObject operator takes one array expression:
{ $arrayToObject: <array expression> }// Format 1: k / v documents
[
{ k: "color", v: "red" },
{ k: "size", v: "L" }
]
// Format 2: two-element arrays
[
[ "color", "red" ],
[ "size", "L" ]
]k or first tuple element) must be a string.v or second tuple element) can be any BSON type.$project, $addFields, or $set.{}.[ { k: "a", v: 1 }, { k: "b", v: 2 } ]{ a: 1, b: 2 }[ ["x", true], ["y", false] ]{ x: true, y: false }| Question | Answer |
|---|---|
| Operator type | Aggregation expression operator (array transform) |
| Syntax | { $arrayToObject: <array> } |
| Key format | { k, v } or [ key, value ] |
| Key type | String (required) |
| Inverse operator | $objectToArray |
{
k: "a",
v: 1
}Document format
[
"a",
1
]Array format
{
$arrayToObject: "$specs"
}From document field
{
$arrayToObject: []
}Returns {}
Convert product specs, user settings, and literal key-value arrays into easy-to-read objects.
Transform stored metadata arrays into objects with $project.
Suppose you have a products collection with a specs array in k / v format:
[
{
"_id": 1,
"name": "T-Shirt",
"specs": [
{ "k": "color", "v": "blue" },
{ "k": "size", "v": "M" },
{ "k": "material", "v": "cotton" }
]
},
{
"_id": 2,
"name": "Jacket",
"specs": [
{ "k": "color", "v": "black" },
{ "k": "size", "v": "L" }
]
}
]Convert the specs array into a flat object:
db.products.aggregate([
{
$project: {
name: 1,
specsObject: { $arrayToObject: "$specs" }
}
}
])Each { k, v } pair becomes one property. The key string becomes the field name and the value becomes the field value.
Use tuple arrays, transform settings, and work with literal arrays.
When pairs are stored as [ key, value ] tuples instead of k / v documents:
db.config.aggregate([
{
$project: {
label: 1,
configObject: {
$arrayToObject: [
[ "debug", true ],
[ "retries", 3 ],
[ "region", "ap-south-1" ]
]
}
}
}
])MongoDB accepts both formats in the same array. The first element is the key string; the second is the value.
Convert a preferences array into dot-accessible fields:
db.users.aggregate([
{
$addFields: {
preferencesObject: { $arrayToObject: "$preferences" }
}
},
{
$project: {
username: 1,
theme: "$preferencesObject.theme",
notifications: "$preferencesObject.notifications",
language: "$preferencesObject.language"
}
}
])$addFields creates the object first; a follow-up $project pulls individual settings into top-level columns for dashboards or exports.
If the same key appears twice, the later entry overwrites the earlier one:
db.samples.aggregate([
{
$project: {
result: {
$arrayToObject: [
{ k: "status", v: "draft" },
{ k: "status", v: "published" }
]
}
}
}
])
// result: { status: "published" }Be careful when building arrays dynamically. Duplicate keys silently keep only the last value.
$arrayToObject WorksThe pipeline evaluates the array — a field like "$specs" or a literal array of pairs.
MongoDB extracts the key string and value from each element ({ k, v } or [ key, value ]).
All pairs are merged into one object. Duplicate keys keep the last value.
Access fields with dot notation like $specsObject.color.
The $arrayToObject operator is a practical reshaping tool when your data stores properties as key-value arrays. It supports both { k, v } documents and [ key, value ] tuples, and pairs naturally with $objectToArray for round-trip conversions.
For beginners, remember: keys must be strings, duplicate keys keep the last value, and an empty array becomes {}.
k/v or tuples) and stay consistent$objectToArray when you need the reverse$project to expose individual fields$arrayToObjectUse these points when reshaping array data in aggregation pipelines.
Key-value pairs → document.
Purpose{ k, v } or [k, v].
Keys must be strings.
RuleUse $objectToArray back.
PairingLast value wins.
Edge caseMove on to $asin or review $arrayElemAt for array indexing.
5 people found this page helpful