Will your translation actually run — or just read fine?

A translator renames {name} to {username} and the app shows a blank. A plural is missing its “one” form and every single item reads wrong. Paste your base locale file and a translation to catch the mechanical failures — missing keys, broken placeholders, wrong plural forms — before they ship.

  • Seven placeholder styles, auto-detected
  • Plural forms checked per language (CLDR)
  • Two target locales in one run
  • Free, no account, nothing uploads

Check your translations

Try it:

Up to 500 KB and 5,000 strings per file. Nothing is uploaded — the check runs on your device.

Privacy you can verify, not just trust

Locale files often carry unreleased product names, internal feature flags and copy you have not shipped yet — uploading them to a website to check them would be backwards. This checker can't leak them: your files are parsed and compared with plain JavaScript on your device, and they never leave the device — the only third-party requests are the site's own analytics, which count page views. Don't take our word for it:

New cross-origin requests during use: 0
  1. Press F12 to open developer tools, then the Network tab.
  2. Paste a locale file and press “Check translations”. Watch: apart from the site's analytics, nothing new is requested — no uploads, and no data ever leaves your device.
  3. Extra credit: disconnect your internet after this page loads — the checker still works.

How to check a translation file

Most translation bugs are not bad writing. They are mechanical: a key that exists in English but never made it into German, a placeholder a translator renamed without knowing the app passes values by name, a plural form a language needs that nobody wrote. Each one is invisible in the translation file itself and only shows up when a real user opens that screen in that language — usually after release. Checking the files against each other before shipping catches all of them in seconds.

To use it:

  1. Paste the base file. Usually en.json — the file the developers wrote first. Paste the JSON, drop the file onto the box, or pick it with the file button. Nested objects are flattened to dotted keys (app.welcome), so any nesting style works.
  2. Paste the translation. One or two target locales, each with its locale code (de, fr, ar, ja…). The code matters: it is what the plural check uses to know which forms that language needs.
  3. Press “Check translations”. Every key is compared: same keys, same placeholders, right plural forms, same HTML tags. Errors are the ones that break the app (missing keys, renamed or dropped placeholders, missing plural forms, empty values); warnings are the ones to look at (untranslated strings, extra keys, duplicated text).
  4. Work through the table. Each row names the key, the severity and the exact problem — “Placeholder {name} became {username}” rather than a vague “mismatch”. Fix the file, paste it again, and re-check until the verdict is PASS.
  5. Export the report. Copy it into a pull-request comment, or download the Markdown, CSV or JSON version and attach it to the translation ticket, so the translator sees exactly which keys to fix.

What makes this checker different

A key coverage checker answers one question: do both files have the same keys? That is necessary and not enough. The failures that actually break apps live one level deeper: a placeholder renamed from {name} to {username}, a %d that became %s, a plural missing the “one” form that German needs, a string left in English because nobody noticed. The tools that do check placeholders either handle one format at a time — you have to tell them whether your project uses {name} or {{name}} — or they do not parse ICU plurals at all, so the plural check never happens. This page does all of it in one run: seven placeholder styles auto-detected, ICU plurals and selects parsed, plural completeness checked against the real CLDR categories for the target language, and two locales checked together. The nearest comparable web tool checks one pair of files, one placeholder format, and states plainly that it does not parse ICU plural or select syntax. If all you need is a key list, that is enough; if you need to know whether the translation will actually run, this is the check.

When is this the right check?

Before every release that touches a locale file; when a translation comes back from a translator or a machine-translation pass; when a developer adds a new string and wants to know which languages are now behind; and when a user reports a blank, a raw {name} on screen, or a sentence that reads wrong only in one language. It is also the check to run after merging a translation pull request — the diff may look clean while a placeholder quietly changed inside a string.

Honest limitations

It cannot judge translation quality

A string can pass every check here and still read badly, use the wrong tone, or mistranslate a term. Structure is checkable; quality needs a human reader of that language. Use this tool to catch breakages, not to approve wording.

Plural rules come from the browser

The plural categories are read from the browser's own Intl.PluralRules, which follows the CLDR data shipped with that browser. If a locale code is unknown, the plural check is skipped and the report says so, rather than guessing.

ICU parsing is a subset

Plurals, selects, numbers and dates are parsed, including placeholders nested inside plural options. Exotic ICU features — custom formats, nested selects inside selects, and rich-text tags inside ICU options — are read as plain text, which can produce a warning where a full ICU parser would not.

Renamed placeholders are a best guess

When the same number of placeholders is missing as is added, the checker reports them as renames paired in order. If a translator renamed two placeholders at once, the pairing may be wrong — the error itself (something changed) is real either way.

HTML tags are compared, not rendered

A tag mismatch is a warning, not an error: some frameworks strip tags, others render them, and a dropped <b> may be harmless in one app and visible in another. Read the warning against how your app renders the string.

Keys are matched by name, not meaning

A key that was renamed in the base file looks like a missing key plus an extra key. That is correct behaviour — the translation really does not have the new key — but the fix is to rename it in the translation, not to add a duplicate.

Frequently asked questions

What is a translation placeholder?

A placeholder is a slot inside a translated string that the app fills in at runtime — a name, a number, a date. In {name} the app inserts a person's name; in {count, plural, one {# item} other {# items}} it inserts a count and picks the right plural form; in %1$s it inserts the first argument. If a translator renames, drops or mistypes one, the app either shows a blank, shows the raw placeholder text, or crashes — which is why placeholders have to match the base file exactly, in every language.

Which placeholder formats does this checker understand?

Seven, auto-detected — you do not have to pick one first. Single-brace {name} (vue-i18n, formatjs), double-brace {{name}} (i18next, Angular), printf-style %s, %d and %1$s (Android, C), Python-style %(name)s, positional {0} (.NET, Java), %@ (iOS), and ICU MessageFormat plurals and selects such as {count, plural, one {# item} other {# items}}. HTML tags inside strings are compared too, so a dropped <b> or <a> is flagged.

How does the plural check work?

Different languages need different plural forms. English needs one and other; German the same; French needs one, many and other; Arabic needs zero, one, two, few, many and other; Japanese needs only other. The checker reads the plural categories your target language actually requires — the CLDR categories, through the browser's own Intl.PluralRules — and flags any that are missing from a translated plural, plus any category the language never uses. A missing form means that count silently falls back to 'other' and reads wrong.

Why is a renamed placeholder an error?

Because the app passes values by name. If the base string says {name} and the translation says {username}, the app has no value called username to insert — so the user sees a blank, the raw text {username}, or, in strict frameworks, an error. The same goes for a dropped placeholder (the value never appears) and a type change such as %d becoming %s (a number formatted as text). Renaming is the most common way a good translation breaks an app, and it is invisible until someone opens that screen in that language.

Can this checker tell me if a translation is good?

No — and it says so on the page. This checker verifies structure: the same keys, the same placeholders, the right plural forms, the same HTML tags. A string can pass every check here and still read badly, use the wrong tone, or mistranslate a term. Only a human reader of that language can judge quality. What this tool does is catch the mechanical failures that no amount of good writing can fix — the ones that break the screen instead of just reading awkwardly.

Does this checker upload my locale files?

No. Everything runs in your browser with plain JavaScript: the files you paste or drop are parsed and compared on your device, and nothing is sent anywhere. Locale files often contain unreleased product names, internal feature flags and customer-facing copy you have not shipped yet, so keeping them local matters. The only third-party requests are the site's own analytics, which count page views. You can verify it yourself with the network-request counter in the privacy section below the checker — or disconnect your internet after the page loads and run the check anyway.

How is this different from an i18n key coverage checker?

A key coverage checker answers one question: do both files have the same keys? This checker answers that plus the questions that actually break apps: do the placeholders match, in any of the seven styles, with no format to pick first? Are the ICU plural forms complete for this specific language? Were strings left untranslated, left empty, or duplicated across keys? And it checks up to two target locales in one run instead of one pair at a time. If all you need is a key list, a coverage checker is enough; if you need to know whether the translation will actually run, this is the check.