New — semantic translation QA

Catch broken translationsbefore you ship them

Dropped placeholders, missing keys and collapsed plurals, caught with no API key at all. Then a semantic pass reads each translation and finds the ones that are simply wrong — the errors every structural checker misses.

terminal

$ npx @shipi18n/cli check ./locales -s en

No key, no account, no config file. Add your own LLM key only for the semantic pass.

Star on GitHub Read the docs

Your key, your model

Bring your own OpenAI or Anthropic key — or plug in any model with a ten-line adapter. You pay your provider directly, at cost, with no markup in between.

No account, no server

Nothing to sign up for and nothing to host. The packages run on your machine or in your CI, and your source strings never pass through our infrastructure.

Apache-2.0, all of it

Every package is open source, from the translation engine to the GitHub Action. Read the prompts, fork the engine, or vendor it into your own build.

Model Context Protocol

Check your translations from your editor

Add the MCP server to Claude Desktop, Cursor or any MCP client and validate your locale files by asking for it — missing keys, dropped placeholders, collapsed plurals, glossary breaches.

The validation tools need no API key. They are deterministic — no model call at all. For meaning-level review, the server hands your agent the translation pairs and the criteria, and your agent reasons about them with the model it already has. Translating new strings is the one thing that needs your own provider key.

View @shipi18n/mcp on npm

claude_desktop_config.json

{
  "mcpServers": {
    "shipi18n": {
      "command": "npx",
      "args": ["-y", "@shipi18n/mcp"]
    }
  }
}

Placeholders survive the round trip

The reason machine-translated locale files break in production is that the model rewrites the parts that aren't prose. Ours don't.

Source

en.json

{
  "greeting": "Hello, {{name}}!",
  "cart": "You have {{count}} items",
  "loaded": "Loaded %d of %s files",
  "terms": "I agree to the <b>Terms</b>",
  "ref": "See $t(common.greeting)"
}

Translated

es.json

{
  "greeting": "¡Hola, {{name}}!",
  "cart": "Tienes {{count}} artículos",
  "loaded": "Se cargaron %d de %s archivos",
  "terms": "Acepto los <b>Términos</b>",
  "ref": "Ver $t(common.greeting)"
}

Interpolation, printf tokens, i18next references and inline HTML are extracted before the request and validated after it. If a placeholder goes missing, you get a warning instead of a broken string in production.

Five packages, one engine

Use the one that fits your workflow — they all share the same translation core.

Five packages, one engine
Package	What it does	Install
@shipi18n/cli	Translate locale files from your terminal or a script.	`npm i -D @shipi18n/cli`
@shipi18n/mcp	Translate from Claude Desktop, Cursor or any MCP client.	`npx @shipi18n/mcp`
@shipi18n/core	The engine itself — use it directly in Node.	`npm i @shipi18n/core`
vite-plugin-shipi18n	Translate at build time, with caching, as part of your Vite build.	`npm i -D vite-plugin-shipi18n`
shipi18n-github-action	Keep translations in sync automatically on every push or pull request.	`uses: Shipi18n/shipi18n-github-action@v2`

vite.config.js

import shipi18n from 'vite-plugin-shipi18n'

export default {
  plugins: [
    shipi18n({
      provider: 'anthropic',
      targetLanguages: ['es', 'fr', 'de'],
    }),
  ],
}

Wire it into your build

Translation belongs in the same place as the rest of your build — not in a browser tab someone has to remember to open.

Incremental by default: only new and changed keys are sent to the model.
Run it in CI with the GitHub Action and commit the result, or open a pull request for review.
Build-time caching means a rebuild costs nothing when your strings haven't changed.

This page is the demo

Everything you're reading exists in 11 languages, and every one of them was produced by the tool this page is about. Use the language switcher at the top and read it in Arabic, Japanese or German.

No sandbox, no sample data — just the output, in production, on the site you're already looking at.

Questions

What does it cost?: The packages are free and Apache-2.0 licensed. You pay your LLM provider for the tokens you use, at their prices, with nothing added on top. Translating a typical locale file into a handful of languages costs a few cents.
Where does my API key go?: Into your environment, and from there straight to your provider. There is no Shipi18n server in the path — we never see your key or your strings. Checking translations needs no key at all, because it runs no model.
Is the output actually good?: It's whatever your model produces, guided by prompts tuned for locale files rather than prose — the translator is told about neighbouring keys, placeholders and the fact that it's translating UI. Judge it from this site, which is translated the same way.
Which providers are supported?: Anthropic and OpenAI ship in the box. Any object with a complete(prompt) method is a valid adapter, so a local model, a proxy or an internal gateway takes about ten lines to wire up.
How many languages can it handle?: Any language your model speaks — there is no per-language list to buy into. Regional variants like pt-BR fall back to pt when you want them to.

Check your locale files in a minute

One command, nothing installed, no API key. Add a key later only if you want meaning checked too.

$ npx @shipi18n/cli check ./locales -s en

Star on GitHub

Apache-2.0 · works with Anthropic and OpenAI · MCP server included