v2 is out — free and open source

Translate your locale fileswith your own LLM

A thin, well-tested layer over the model you already pay for. No account, no hosted API, no per-word pricing — your strings go straight from your machine to your provider.

terminal

$ npx @shipi18n/cli translate locales/en.json -t es,fr,de

Set ANTHROPIC_API_KEY or OPENAI_API_KEY and you're done.

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

Translate from your editor

Add the MCP server to Claude Desktop, Cursor or any MCP client and translate locale files by asking for it — no context switch, no separate tool.

It works with no API key at all. With MCP sampling, the model already running in your client does the translation, so there is nothing to configure and nothing to pay for.

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. The one exception is the MCP server's sampling mode, which uses no key at all.
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.

Translate your first file in a minute

No signup, no config file, no waiting for an API key to be approved.

$ npx @shipi18n/cli translate locales/en.json -t es,fr,de

Star on GitHub

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