Add thousands separators
1234567.89 becomes 1,234,567.89 in US style with two decimals, while European style writes 1,234,000 as 1.234.000. You pick the style and the decimals, so the result never depends on your computer's settings. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- Value
- 1,234,567.89
- Locale-style separator pair: us
- Us
- Decimal places
- 2
- Group separator
- ,
- Decimal mark
- .
- Style label
- US / UK (comma group, period decimal)
- Used decimals
- 2
Adding thousands separators turns a raw machine number into a string people can scan without counting digits. Enter a finite value, pick a locale style for the group character and decimal mark, optionally fix how many decimal places to show, and the tool returns a deterministic formatted string—one million two hundred thirty-four thousand as 1,234,000 in US style, 1.234.000 in European style, or space-grouped SI and French forms. Spreadsheet exports, invoice previews, dashboard labels, and documentation samples all need the same grouped display without depending on the host OS locale or Intl data packs.
What thousands separators and decimal marks mean in display strings
A thousands separator is a grouping character inserted every three digits of the integer part so large magnitudes stay readable: one million becomes one-comma-zero-zero-zero-comma-zero-zero-zero in United States style rather than a bare seven-digit run. The decimal mark is the character that splits the integer part from the fractional part; English-speaking locales usually use a period while much of continental Europe uses a comma.
Those two choices are independent of the numeric value itself: the number one thousand two hundred thirty-four and fifty-six hundredths is the same quantity whether you write 1,234.56 or 1.234,56 or 1 234,56. Confusing the two marks is a classic spreadsheet and CSV disaster—importing European invoices into a US tool can silently drop fractional cents or multiply values by a thousand.
This capability therefore does not try to guess what a mixed string means; it only accepts a plain finite number (or a strict ungrouped numeric string) and emits a display form under an explicit style. US style pairs a comma group with a period decimal; EU style swaps them; French style uses a space group with a comma decimal; Swiss style uses an apostrophe group with a period decimal; SI-like style uses a space group with a period decimal.
Fixed decimal places pad or round the fractional part so money-like amounts always show two digits, while auto mode trims trailing zeros for cleaner integers and short fractions.
Practical tips, limits, and related searches
Strip group characters and currency symbols in your client before calling if the source is a localized paste; this tool formats bare numbers and will reject 1,234.56 as non-numeric by design so it never double-groups or misreads a European comma. Prefer fixed decimals equals two for currency-like displays and auto mode for integer counts and scientific magnitudes where trailing zeros would look artificial. Negative values keep a leading minus before the grouped integer part in every style.
Prefer this capability when you already have a numeric value and only need a readable grouped string; if you need currency codes, percent styles, or BCP-47 locale resolution, use a broader locale number formatter.
What you can do with it
Readable totals on invoices and receipts
Format order totals and tax lines with US or EU grouping so printed PDFs and email receipts stay easy to scan without changing the stored numeric amount.
Dashboard and report labels
Turn raw metrics from APIs into SI or French space-grouped strings for charts, CSV exports, and admin tables that mix audiences across locales.
FAQ
What does adding thousands separators do?
It inserts a grouping character every three digits of the integer part and uses a chosen decimal mark for the fractional part, turning 1234567.89 into forms like 1,234,567.89 or 1.234.567,89.
Which styles are supported?
us (comma group, period decimal), eu (period group, comma decimal), fr (space group, comma decimal), ch (apostrophe group, period decimal), and si (space group, period decimal). Default is us.
Can I paste a number that already has commas?
No. Input must be a plain finite number or ungrouped numeric string. Already-localized values are rejected as non-numeric so the tool never double-groups or misreads decimal commas.
How do fixed decimals work?
Set decimals to an integer from 0 to 20 to round and pad the fractional part. Omit decimals for auto mode, which trims trailing zeros while keeping meaningful fractional digits.
Is the thousands-separator formatter free?
The browser tool is free and runs locally.
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/fmt/thousands-separator \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"value":1234567.89}'const res = await fetch("https://api.kit.forhosting.com/fmt/thousands-separator", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"value": 1234567.89
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/fmt/thousands-separator",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"value": 1234567.89
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/fmt/thousands-separator", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"value":1234567.89}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"value":1234567.89}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/fmt/thousands-separator", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"value": 1234567.89
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "fmt.thousands_separator",
"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_abs | 1000000000000 |
max_decimals | 20 |
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
Non-numeric tokens, empty fields, and already-localized junk raise a clear invalid_input error instead of a silent wrong parse.
How to call the API and what comes back
Optional decimals is an integer from zero through twenty that fixes fractional width after rounding; omit it to keep auto fractional digits with trailing zeros removed. Send a JSON body with required field value (aliases n, number, input, amount, and x). The value may be a JSON number or a plain numeric string without group characters; scientific notation is accepted when it matches a strict finite pattern. Optional style selects the separator pair and defaults to us; accepted keys are us, eu, fr, ch, and si, with common aliases such as en, de, and swiss resolved to those keys. Absolute magnitude must stay within one trillion so digit strings remain finite and practical on the Worker and in the browser. On success the response echoes value, sets style to the resolved key, group_separator and decimal_mark to the characters actually used, style_label to a short English description, decimals to the fixed places or null for auto, used_decimals to how many fractional digits appear, formatted to the final display string, message to a one-line summary, and steps to an ordered audit of style choice, grouping, and result. Failed validation—missing value, non-numeric tokens, booleans or objects, non-finite numbers, magnitudes outside the absolute limit, or an unknown style—returns invalid_input and is never charged. Pricing is a flat $0.002 per successful request with unit item and zero marginal unit price.
Practical tips, limits, and related searches
When teaching or documenting, pair examples: one two three four five six seven point eight nine with US style yields 1,234,567.89; the same value with EU style yields 1.234.567,89; one thousand with French style yields 1 000; and a letter string such as not-a-number demonstrates the hard invalid_input path. This landing targets people searching for add thousands separators, format number with commas, thousand separator online, or decimal mark conversion for display; it is not a full locale-and-currency formatter with ISO-4217 symbols, not an Indian lakh/crore grouper, and not a CSV dialect detector. Failed tasks that return invalid_input do not consume prepaid balance, which keeps exploratory scripts cheap when callers deliberately send junk. Round-trip checks are easy: confirm the returned formatted string matches your expected group and decimal characters for the chosen style, confirm used_decimals matches fixed decimals when provided, and confirm that replacing the number with a non-numeric string flips the response to invalid_input with a message that mentions non-numeric input.
Integration use cases
Docs, tests, and screenshot fixtures
Generate stable expected display strings for unit tests and marketing screenshots without depending on the developer machine's OS locale.