JSON Translator
Translate only the string values inside a JSON file. Keys, nested structure, placeholders, and ICU plural rules stay intact, ready to drop into your i18n locales folder.
Values only
Keys, shape, and placeholders preserved
Try this with our Bulk Translator
Upload your en.json, pick a target language, and download es.json (or fr.json, de.json, ja.json) with identical keys and translated values. Run it once per locale.
Why translate JSON values and not keys
Internationalization frameworks look up text by a stable key. Your React component asks for the string at auth.signin.submit and gets back the user facing label in the user current locale. If a translator rewrites that key to autenticar.iniciarSesion.enviar in the Spanish file, the lookup fails and the UI falls back to the key string itself or to a hard coded default. Translating keys breaks the application. Translating only values is the correct behavior for i18n.
A JSON translator walks the parse tree, picks out every string that sits in a value position, and translates just those. Numbers stay as numbers. Booleans stay as booleans. Nested arrays and objects keep their depth and order. The output JSON validates against the same schema as the input, with the same paths to every leaf, only the human readable strings rewritten in the target language.
On top of that, modern locale files use placeholders and plural rules that a naive translator would mangle. ICU pluralization, named placeholders in curly braces, HTML fragments embedded inside a string, and link tokens like a href all need to survive translation. The JSON translator detects these patterns and translates around them so the target string still works with your existing rendering code without any post processing on your side.
How to translate a JSON file
- 1
Upload your source JSON
Pick your en.json or whatever your master locale file is called. The parser checks that it is valid JSON and reports the count of string values it found. If you have several files, you can drop them all in and run them through together.
- 2
Select your target language
Choose from over one hundred target languages. The engine translates each string value while protecting placeholders and ICU plural branches. Keys, structure, and non string values are passed through untouched.
- 3
Download and drop in
Download the translated JSON. The file has the same shape as the source, which means you can move it straight into your locales directory and your i18n framework will load it without any further work. Repeat the same flow per target language.
Where JSON translation fits
React and Next.js locale files
Apps using react-intl, next-intl, or i18next typically store strings in JSON files per locale. Upload en.json, choose a target language, and get back a file ready for the locales directory. Component lookups by key continue to work, the only thing that changes is the rendered text for users in that locale.
Mobile app string bundles
Many cross platform mobile apps keep their UI copy in JSON bundles that load at startup. A JSON translator gives you a ready to ship bundle for each target locale. The same key set drives the UI in every language, and adding a new language is a one file drop instead of a multi day rewrite.
API responses with copy fields
Sometimes a backend ships static copy as JSON, used for onboarding flows, marketing banners, or feature flags with text content. Translate the JSON file once per target language and serve the localized version based on the request locale, with no changes to the API contract or the consuming clients.
Config files with help text
Developer tools sometimes ship JSON schemas with embedded help text. Translating just the string fields gives a localized schema that still validates against the same parser. Identifiers, default values, and structural keys all stay intact so the schema continues to drive forms and validation as before.
Frequently Asked Questions
What does a JSON translator translate exactly?
Only the string values, never the keys. Your code uses keys like welcome_title or button.save to look up text at runtime, so if a key gets translated the code breaks. The translator walks the JSON tree, finds every string value, sends those for translation, and writes a new JSON file with the same key structure and the translated values in place. Numbers, booleans, nulls, and arrays of non strings pass through unchanged.
Does it support nested JSON and i18n files?
Yes. Nested objects with arbitrary depth are handled. Common i18n shapes such as react-intl message files, i18next locale bundles, Vue i18n trees, and Rails YAML converted to JSON all work. The full path of each key is preserved, so a string at messages.errors.required in the source stays at messages.errors.required in the translated output with its value translated to the target language.
What about ICU message format and placeholders?
Placeholders like {name}, {count, plural, one {item} other {items}}, and HTML fragments inside the string value are detected and protected. The translator translates the natural language portions around them while leaving the placeholder tokens exactly intact. Pluralization branches inside ICU messages are translated per branch so each plural form reads naturally in the target language.
Can I translate one JSON file into several languages?
Yes. Run the same source JSON through the bulk translator once per target language. You will get back en.json, es.json, fr.json, de.json, and so on, each with identical structure and translated values. This is the exact shape most i18n frameworks expect when you drop the files into a locales directory, so deployment is usually just copying the new files into place.
How are arrays handled?
An array of strings becomes an array of translated strings in the same order. An array of objects keeps its order and each object inside is walked recursively, with only the string values inside translated. Mixed type arrays are preserved item by item, so an array that contains a string then a number then an object keeps that exact shape with only the string item translated.
Is my JSON kept private?
Yes. Uploaded JSON is parsed in memory, the extracted strings are translated, and the result is written back into the same structure for download. Files are not retained for analytics, training, or any third party. The translated output is yours to download and use, and nothing about your application or its copy is stored once your session ends.