Addition calculator
Add 0.1 and 0.2 and get exactly 0.3, not 0.30000000000000004, and total a column of invoices without opening a spreadsheet. Every value is checked first, so a stray label or an empty entry stops the sum instead of hiding a wrong total. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- Addends
- 19.99, 4.5, 0.75
- Total
- 25.24
- Quantity
- 3
- Sum
- 25.24
The addition calculator sums two or more numbers and returns the exact total in a single call. Paste a list of values — prices, measurements, scores, quantities — and get back their sum without opening a spreadsheet or trusting a pocket calculator with a long column of figures. Every addend is validated as a finite number, so a stray label or an empty cell stops the calculation with a clear error instead of silently producing a wrong total.
Add a column of numbers without a spreadsheet
Spreadsheets are wonderful tools, but they are heavy artillery for the simplest arithmetic job there is: adding a few numbers together. Every day someone opens a full spreadsheet application, waits for it to load, pastes values into cells, types a SUM formula and reads one cell — just to learn that three invoices total 412.37. The addition calculator exists for that moment.
You give it two or more numbers, as many as you need, and it returns their sum immediately, with no files to save, no formulas to debug and no risk of an accidental edit to a cell you did not notice. Because the input is a plain list rather than a grid, it works just as well from a chat message, a curl command or a script as it does from the form on this page.
The tool is deliberately narrow: it does one operation, addition, and it does it exactly, so you never have to wonder whether a more elaborate feature quietly changed your numbers on the way in.
How the total is computed, and why it is exact
Every value you send is checked before any arithmetic happens. Once validated, the numbers are added in order and the result is rounded to twelve decimal places, which removes the well-known floating-point artifacts of binary arithmetic: 0.1 plus 0.2 comes back as 0.3, not as 0.30000000000000004. The algorithm is fully deterministic — no network calls, no randomness, no clock — so the same input always produces the same output on the server and in your browser.
That property is what makes the result safe to use in invoices, reconciliation jobs and automated checks that compare totals against an expected figure.
Where an exact total saves time
On its own, adding numbers looks too small to automate. Inside a pipeline, it is the kind of step that quietly appears everywhere. A reporting job that totals daily sales across regions, a monitoring script that sums error counts from several services, an expense tool that adds line items before applying tax — all of them need a trustworthy total of a short list of numbers, and all of them benefit when that step is a single deterministic call instead of logic re-implemented in every script.
When a total matters, it should come from one place, computed one way.
What you can do with it
Total a list of prices or expenses
Add the line items of a quote, an expense report or a shopping list and get one exact total, with any malformed value flagged by position instead of silently skipped.
Aggregate metrics in a script
Sum counters from several sources — requests, errors, signups — inside a pipeline, using one deterministic call instead of ad-hoc arithmetic in every script.
FAQ
How many numbers can I add at once?
For longer lists, split them and sum the partial totals.
What happens if one value is not a number?
NaN, Infinity, strings and empty values are all rejected.
Is the result exact?
Yes. The sum is rounded to twelve decimal places, so floating-point artifacts like 0.1 + 0.2 = 0.30000000000000004 never appear in the output.
Are my numbers stored anywhere?
No. The values are processed in memory and discarded; only the total is returned.
How do I add up a list of prices?
Enter each price as a separate number. The calculator returns the total and also tells you how many numbers it added: three prices that come to 25.24 show a count of 3, so you can spot one that was left out.
Related tools
For developers — API access
Everything on this page is available programmatically. This section is for teams who want to wire it into their own systems; everyone else can just use the tool above.
API endpoint
Prefer to automate it? One authenticated POST creates the task; the result comes back by webhook or a signed link. The same capability also runs here on the web, by email and from Telegram — and soon from our app too.
Call it from your stack
curl -X POST https://api.kit.forhosting.com/math/addition \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"addends":[19.99,4.5,0.75]}'const res = await fetch("https://api.kit.forhosting.com/math/addition", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"addends": [
19.99,
4.5,
0.75
]
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/math/addition",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"addends": [
19.99,
4.5,
0.75
]
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/math/addition", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"addends":[19.99,4.5,0.75]}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"addends":[19.99,4.5,0.75]}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/math/addition", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"addends": [
19.99,
4.5,
0.75
]
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "math.addition",
"status": "queued",
"_links": {
"result": "/tasks/tsk_…/result"
}
}The API is asynchronous: the call returns a task_id immediately and the result arrives by webhook. Polling is capped at 1 req/s per task.
Pricing
Published price — no tokens, no invented credits. A failed task is never charged.
Limits
max_addends | 10000 |
Errors
| HTTP | Code | Meaning |
|---|---|---|
401 | unauthorized | Missing or invalid API key. |
402 | insufficient_balance | Your balance doesn't cover the task price. |
404 | unknown_type | That task type doesn't exist. |
429 | rate_limited | Too many requests. Use the webhook instead of polling. |
Technical notes
The same deterministic code runs free in your browser on this page and behind the paid API, so what you test by hand is exactly what your pipeline gets when you automate it.
How the total is computed, and why it is exact
An addend must be a finite number: NaN, Infinity, a text string, a boolean or an empty value is rejected with a typed error that names the offending position, and the request is not billed. This strictness is the point — a total that silently skips a malformed value is worse than no total at all, because it looks correct while being wrong.
Where an addition endpoint earns its place
Teams use this endpoint as the arithmetic brick in larger workflows: fetch the values, sum them here, pass the total to the next step. It runs on our global edge, nothing you send is stored, and the free browser version on this page shares the very same code, so the number you see while testing is the number your automation will see in production.
Integration use cases
Check homework and mental math
Verify the sum of a column of numbers while learning arithmetic, with the free browser version that runs the same code as the paid API.
Technical questions
What does it cost?
$0.002 per request, with no per-unit surcharge. It is also free to run in your browser on this page.
Does the free browser version give the same result as the API?
Exactly the same. Both run the same deterministic code, so the total you see while testing by hand is the total your automation will receive.