The $toDouble operator converts values to a double (64-bit floating-point number) in MongoDB aggregation pipelines. Use it to parse numeric strings and enable arithmetic on imported or mixed-type data.
Values to float.
One expression.
Text to number.
Enable math ops.
Scores, averages.
Float vs exact.
In MongoDB’s aggregation framework, the $toDouble operator converts an expression to a 64-bit floating-point number (double). Imported CSV and JSON data often stores numbers as strings like "85.5" or "3.14". $toDouble parses those strings so you can use $multiply, $avg, $sum, and other numeric operators.
$toDouble is shorthand for { $convert: { input: <expression>, to: "double" } }. It is part of the type-conversion family alongside $toInt, $toDecimal, and $toString.
Use $toDouble for general numeric work like scores and measurements. For currency and financial calculations where every cent must be exact, prefer $toDecimal instead.
The $toDouble operator takes one expression:
{ $toDouble: <expression> }{ $toDouble: "85.5" }
// Result: 85.5
{ $toDouble: 42 }
// Result: 42.0
{ $toDouble: true }
// Result: 1.0
{ $toDouble: "$score" }
// Convert the score fieldnull — returns null.true becomes 1.0, false becomes 0.0.$project, $addFields, $set, or $group.| Question | Answer |
|---|---|
| Operator type | Aggregation expression operator (type conversion) |
| Syntax | { $toDouble: <expression> } |
| Output type | Double (64-bit float) |
| Equivalent | { $convert: { input: <expr>, to: "double" } } |
| Best for | Scores, measurements, averages, general math |
| Common stages | $project, $addFields, $group |
{
$toDouble: "$score"
}Parse text number
{
$toDouble: "3.14"
}Fixed value
{
$avg: {
$toDouble: "$rating"
}
}Mean of strings
{
$multiply: [
{ $toDouble: "$qty" },
{ $toDouble: "$rate" }
]
}Numeric math
Parse string scores, compute averages, multiply numeric fields, and compare double precision with decimal conversion.
Start with a students collection where scores are stored as strings and convert them with $toDouble.
Suppose you have a students collection with string scores from a CSV import:
[
{ "_id": 1, "name": "Alice", "score": "92.5" },
{ "_id": 2, "name": "Bob", "score": "78.0" },
{ "_id": 3, "name": "Carol", "score": "85.5" },
{ "_id": 4, "name": "Dave", "score": "91.0" }
]Parse the score string into a numeric double:
db.students.aggregate([
{
$project: {
name: 1,
score: 1,
numericScore: { $toDouble: "$score" }
}
}
])$toDouble parses numeric strings into doubles. Once converted, the field supports sorting, comparison, and arithmetic operators.
Compute averages, multiply fields, and sort by numeric values.
Convert string scores before computing the class average:
db.students.aggregate([
{
$group: {
_id: null,
averageScore: {
$avg: { $toDouble: "$score" }
},
count: { $sum: 1 }
}
}
])
// averageScore: 86.75
// (92.5 + 78.0 + 85.5 + 91.0) / 4$avg requires numeric input. Wrapping the field in $toDouble converts each string score before the average is calculated.
Calculate a weighted score from quantity and rate fields stored as strings:
db.metrics.aggregate([
{
$project: {
label: 1,
result: {
$multiply: [
{ $toDouble: "$quantity" },
{ $toDouble: "$rate" }
]
}
}
}
])
// quantity: "2.5", rate: "10" → result: 25.0Both operands must be numeric for $multiply. Convert each string field with $toDouble before the operation.
Convert scores to doubles, then sort highest to lowest:
db.students.aggregate([
{
$addFields: {
numericScore: { $toDouble: "$score" }
}
},
{
$sort: { numericScore: -1 }
},
{
$project: {
name: 1,
numericScore: 1
}
}
])Sorting string numbers alphabetically gives wrong results ("9" > "85"). Converting to double first ensures correct numeric ordering.
Booleans convert to 1.0 (true) or 0.0 (false):
db.settings.aggregate([
{
$project: {
flag: 1,
asNumber: { $toDouble: "$enabled" }
}
}
])
// enabled: true → asNumber: 1.0
// enabled: false → asNumber: 0.0This is useful when you need a numeric representation of a boolean flag for charts or statistical calculations.
When values may be invalid, use $convert with onError:
db.students.aggregate([
{
$project: {
name: 1,
numericScore: {
$convert: {
input: "$score",
to: "double",
onError: 0,
onNull: 0
}
}
}
}
])
// "92.5" → 92.5
// "N/A" → 0 (fallback)
// null → 0$toDouble errors on invalid strings. $convert with onError lets the pipeline continue with a safe default.
$avg, $stdDevPop, and other numeric aggregations on string fields.$toDouble WorksThe input resolves from a field path, numeric string, number, boolean, or nested expression.
Strings are parsed as numbers; integers, longs, and decimals are cast to 64-bit float.
The output supports $add, $multiply, $avg, sorting, and comparisons.
Use in math, aggregations, sorting, and reporting pipelines.
The $toDouble operator converts values to 64-bit floating-point numbers in MongoDB aggregation pipelines. It is the go-to choice for parsing numeric strings and enabling general math on mixed-type data.
For currency and financial calculations, use $toDecimal instead. For conversions with error handling, use $convert. Next in the series: $toInt.
$toDouble to parse numeric strings before math operations$sort when fields are stored as strings$convert with onError for messy imported data$toDecimal when penny-level precision matters$toDouble for currency when exact cents are required$multiply or $avg$toDouble$toDoubleUse these points when converting values to double in MongoDB.
64-bit float.
PurposeOne argument.
SyntaxText to number.
InputEnable math.
UsageUse $toDecimal.
CompareMove on to $toInt for integer conversion, or review $toDecimal for financial precision.
5 people found this page helpful