Smartcat parses your JSON, translates only the string values, and returns a file with the same keys and the same nesting — with your placeholder tokens locked as tags, using regex rules you define once — in any of 280+ languages.
1,000+ enterprise brands choose Smartcat for their translation and localization needs
A JSON translator converts the human-readable strings in a JSON file into another language without touching the file’s structure. Smartcat translates the string values in your locale files — keys, numbers, booleans and nesting stay exactly as they were, and placeholder tokens are locked as non-editable tags — so the translated file drops back into your i18n pipeline.
Just translating one file, once, for free? Use the free JSON translator — it’s the same engine with a browser-first flow.
280+
target languages
One en.json in; de.json, ja.json and pt-BR.json out. Keep en.json as your source of truth and generate every target locale from it in one project, instead of maintaining twelve files by hand.
103%
key-ID TM matches
Strings keep their key IDs, so translation memory can match the segment and its key — a level of reuse ordinary document formats, capped at 102% context matching, cannot reach.
6 GB
per document or project file
The published ceiling is a global one, not JSON-specific, with guidance to split anything over 1 GB into smaller parts for speed.
Paste an en.json into a generic translator and it treats the whole document as prose. What comes back parses in your editor — or doesn’t — and fails in production.
Keys get translated — "checkout_button" becomes "bouton_de_paiement" and every lookup in your code now returns undefined.
Placeholders get mangled — "Hello, {{userName}}" comes back as "Bonjour, {{nomUtilisateur}}" and the string renders with a raw token because the variable no longer resolves.
Plural forms collapse — an ICU message like {count, plural, one {# item} other {# items}} gets flattened into a single sentence, and pluralization silently breaks for every language that isn’t English.
Escaping corrupts — escaped quotes, \n and \uXXXX sequences are "helpfully" normalized, and the file that looked fine in a diff throws at JSON.parse.
None of these show up in review. They show up at runtime, one locale at a time. Working with other developer formats? Smartcat also parses gettext PO files and XLIFF in the same workspace, sharing one translation memory and glossary.
for ease of setup on G2
for ease of use on G2
enterprise brands
Type II compliant
Bring one real locale file to a 1:1 with a localization engineer: XPaths, placeholder rules and your release cadence, worked through on your own file. No commitment.
1. Upload your locale file
Upload en.json — or several locale files at once.
2. Define your placeholder rules
On the Placeholders tab in Settings, add a regular expression for each token format your codebase actually uses. Anything matching is imported as a locked, non-editable tag — the same mechanism covers JSON, TJSON, PO, RESX, XLIFF, XML, PHP and CSV.
3. Pick target languages
One file in, de.json, ja.json and pt-BR.json out, from 280+ options.
4. Review what matters
Open the editor to check strings, enforce glossary terms, or route a language to a human reviewer. Skip it when the AI draft is enough.
5. Download JSON
Same keys, same nesting, new language.
6. Or export the whole project at once
Select your projects, click Download, and you get a single ZIP with every file in its original format, sorted into folders.
2–3 days
Document turnaround, down from ten
Smith+Nephew cut translation turnaround from 10 days to two to three days with Smartcat.
30%
More translation output
Find out how Wunderman Thompson translates 30% more content without extending their budget while increasing quality.
31 hours
Saved every month
Babbel saves 31 hours a month across its marketing and L&D departments.
Upload en.json, download every other locale — keys, placeholders and nesting intact, and release two reuses almost everything release one taught the translation memory. 15 days, no credit card.
A JSON file (JavaScript Object Notation) is a lightweight, text-based format for storing and exchanging structured data. It’s commonly used for sharing information between web applications and servers because it’s easy for humans and machines to read and write. JSON files typically use key-value pairs and support data types like strings, numbers, arrays, and objects.
Structure is never edited — only string values are — so validity comes from the parse model rather than from luck. Smartcat separates structure from content: keys, numbers, booleans, nulls and nesting are locked, and only string values become translatable segments.
Nested object structures are supported and their shape is preserved. Strings carry their key IDs through the project, which is what lets translation memory match on the key as well as the text.
Yes, in both directions. Plurals can live in Smartcat either natively — each plural form as its own segment, created with all forms when you add the key — or as ICU MessageFormat syntax. On import you choose whether keys containing ICU syntax are parsed into individual segments or left as they are, and on export plural forms are written back as an ICU MessageFormat-compatible string.
Effectively yes. Use Update current document on the changed file: it replaces the file and pulls all existing translation work back out of the translation memory, so only new and edited strings are real work. Two caveats worth knowing before you rely on it — the update cancels any task assignments on that document, so linguists must be reassigned, and both Update and Upload consume Smartwords for retranslation.
Standard key-value JSON and nested objects are both documented as supported, and LOCJSON and TJSON are supported as separate formats in their own right.
The published ceiling is a global one, not a JSON-specific one: 6 GB per document or project file, with guidance to split anything over 1 GB into smaller parts for speed. No string-count limit is documented.
There is no cap on how many files go into one project — batch uploads of hundreds of locale files are supported, and the limit does not change by plan. The constraint is per-file size, not file count.
Yes, on the Anticipate and Autonomous plans, and it needs a company account — the API cannot be used from a freelancer account, and it is not switched on during the free trial.
It uploads files, retrieves translations, and supports async processing with notification callbacks; every method shares a 4 requests/second rate limit. Docs: developers.smartcat.com/api-guides/.
Smartcat is SOC 2 Type II compliant. Files are encrypted in transit and at rest, workspaces are isolated, and access is role-based. Details on the security page.
Machine translation can’t infer UI context from a key name. "Save" might be a button, a discount, or a noun — and the right translation differs in most languages.
For strings under about three words the AI draft is a starting point; the segment editor exists precisely so a human can check them against screenshots or context notes before release. Budget review time for short UI strings; skip it for long descriptive text.