Ultimate DX for i18n

The cheapest and most efficient i18n for agentic coding

Keyless i18n your coding agent gets it right the first time: one file to edit, no locale JSON to load, no merge conflict, from £4 a month.

5-minute setup

Your entire i18n implementation in 5 minutes. Not joking.

No Keys System

Your brain shouldn't be involved in such meaningless tasks.

Global from day one

Ship to international markets without extra effort.

Set up i18n, keep your codebase clean and ship fast

There are multiple PITA with the current i18n solutions. The pains are so great that you delay i18n as much as possible.

It consumes time you should spend on the beach

Set up the keys' system: at least 1 hour of senior dev time

Back and forth for each new key: 1 minute per key, x500 keys, x2 languages = 17 hours

With i18n-keyless, you don’t need to worry about the i18n system at all. You can go to the beach and order a mojito.

Today most systems use keys to translate the text

This is painful to generate. This is painful to maintain.

When you see a text in the app, and you want to update it, you need to find the corresponding key.

With i18n-keyless, you don’t need to worry about the i18n system at all. Use your brain for something more interesting.

Leave translations to AI

With the key system, you need to manage the translations in the app.

Otherwise, your users will see someheader.welcome.title in their app.

With i18n-keyless, you don’t need to worry about the i18n system at all. Just write good headlines, focus on marketing, and get sales.

Codebases are beautiful... until i18n keys become infected

With the key system, when you read the code and the content, you have to read keys, not natural language.

Sometimes you should make a fix because a sentence is not grammatically correct. But you don't know that because you read keys.

With i18n-keyless, you don’t need to worry about the i18n system at all. The codebase remains beautiful.

Add i18n from day one without any impact on your development pace
Built for coding agents

MCP server to cover all your i18n needs

Plus six other reasons why the system is so optimised for agentic coding.

No name to invent

A key is a naming decision with no right answer. Two agents write login.submit and auth.button.send for the same button. Without keys there is no decision to make.

One file to edit, not twenty

A keyed change affects the component and every locale JSON file, and agents forget files. Here, a copy change is a single-file edit.

Zero merge conflicts in agent fleets

Five agents on five branches all edit en.json: a guaranteed conflict. There is no shared file, so worktrees and background agents never collide.

Cheap in tokens

To reuse a key, an agent must load the locale files into context on every edit. Keyless loads nothing: the text is right there in the component.

Readable diffs

The pull request shows real sentences. A human or a review agent can judge the copy without digging for what a key stands for.

One rule in your CLAUDE.md

Every i18n rule you write is a rule the agent can break. This one needs a single line — and the fallback is the real text, so a miss cannot show a.b.c on screen.

The only i18n rule your agent needs

# CLAUDE.md
Write the UI copy in English and wrap it in <T>…</T> from i18n-keyless-react.
That is the whole i18n setup.

Your agent can operate it, not just write it

Through the MCP server, the agent lists missing translations, reads one, overrides a bad one, or imports the copy you already have — with its own OAuth login, no key to paste.

Read the MCP guide
Perfect for MVPs

Launch globally from day one

Stop delaying i18n because of complexity. Implement it in 5 minutes, not days. Maintain your development velocity as if i18n wasn't implemented.

  • 5-minute implementation. Not kidding.

    One simple config object and you're done.

  • Maintain development velocity

    Code as if i18n wasn’t implemented at all.

  • Ship to global markets

    No refactoring needed as you scale to new languages.

  • SSR & SEO ready

    Works with Next.js, Remix, TanStack Start and Astro. Server-render any language for search engines — same 5-minute setup.

Traditional i18n

Set up key system (1 hour)
Create translation files (2 hours)
Refactor components (4 hours)
Test all languages (2 hours)
Fix layout issues (3 hours)
12+ hours of work

i18n-keyless

Add package (1 min)
Configure with API key (2 min)
Wrap text components (2 min)
5 minutes of work
How it works

It's no brainer to set up

Just the simplest config object and you're ready to go global.
And even more, your agent will set it up for you.

1. Basic setup

import * as I18nKeyless from "i18n-keyless-react";

I18nKeyless.init({
  API_KEY: "YOUR_API_KEY",
  storage: window.localStorage,
  languages: {
    primary: "en",
    supported: ["en", "fr"],
  },
});

2. Component Usage

import { I18nKeylessText } from "i18n-keyless-react";
// import { T } from "i18n-keyless-react"; // also works

// Just write in your primary language
<I18nKeylessText>
  Welcome to our website
</I18nKeylessText>

3. Server-side usage (e.g. Node.js)

import { awaitForTranslationOrFallbackToOriginal, type Lang } from 'i18n-keyless-node';

const title = await awaitForTranslationOrFallbackToOriginal('Come see my app!', user.lang as Lang);
const body = await awaitForTranslationOrFallbackToOriginal('So many new stuff!', user.lang as Lang);

await sendExpoPushNotification({ user, title, body });

4. For text outside components

import { getTranslation } from "i18n-keyless-react";

export default function Navigation() {
  return (
    <HomeTabs.Navigator>
      <HomeTabs.Screen
        options={{ tabBarLabel: getTranslation("Welcome") }}
        name="WELCOME"
      />
    </HomeTabs.Navigator>
  );
}

How translations work

i18n-keyless is a library, combined with an API service, that allows you to translate your text without the need to use keys.

If the translation is not found, there will be an asynchronous fetch to I18nKeyless' API to retrieve the translation via an AI API call.

This operation is usually performed in dev mode, while you're coding. If you miss one, in production only the first user missing the translation will see a glitch, then it'll be available instantly to users all over the globe.

App Store & Google Play

Your store listing in every language, on every release

Every update means new release notes, a description and keywords — for each language, on both stores. That is what stops you from adding languages. Not the app.

  • Release notes for every language, in one call

    Write the update once. awaitForTranslation returns it in each language you sell in, and your store config feeds it to EAS or fastlane.

  • 48 languages, mapped to the App Store slots

    pt-BR and pt-PT are two listings; en-GB, en-AU and en-CA are three. toAppStoreLocale puts each translation in the right one.

  • Fix a bad translation without a release

    In the app, one override in the dashboard is live at once — no hotfix build, no store review. In the listing, re-run the push.

  • Not priced per word

    A translator charges about £0.10 a word. 2,000 strings times 10 languages is a budget a solo developer does not have. Here words are not counted.

The whole recipe for an Expo app

// store.config.js — EAS Metadata awaits an async config
const { init, awaitForTranslation, toAppStoreLocale } = require("i18n-keyless-node");

const LANGS = ["en", "fr", "de", "ja", "pt-BR"];
const DESCRIPTION = "Bibi translates your app while you sleep…";

module.exports = async () => {
  init({ API_KEY: process.env.I18N_KEYLESS_KEY, languages: { primary: "en", supported: LANGS } });
  const info = {};
  for (const lang of LANGS) {
    info[toAppStoreLocale(lang)] = {
      title: await awaitForTranslation("Bibi", lang, { context: "App Store app name, 30 characters max" }),
      subtitle: await awaitForTranslation("Keyless i18n", lang, { context: "App Store subtitle, 30 characters max" }),
      description: await awaitForTranslation(DESCRIPTION, lang, { context: "App Store description" }),
    };
  }
  return { configVersion: 0, apple: { info } };
};

The same call writes fastlane metadata files for Google Play. Caps are advisory: put the limit in the context and check the length before you push.

Try it yourself

Interactive Sandbox

See how i18n-keyless works in real-time

Open a live, editable StackBlitz project to see translations resolve as you type.

Not yet existing testimonials

Developers love the simplicity

See what others are saying about i18n-keyless

I was able to add i18n to our MVP in literally 5 minutes. We launched in 7 languages without any extra development time. Our codebase stayed clean and we could focus on building features instead of managing translation keys.

JS

Jamie Smith

CTO at a Cool Startup

The mental overhead of managing translation keys was killing our productivity. With i18n-keyless, we just write natural language and everything works. It's as if i18n doesn't even exist in our workflow anymore.

AL

Alex Lee

Lead Developer at Another Cool Startup

We were about to delay i18n for our product until after launch. With i18n-keyless, we implemented it in our MVP phase and launched globally from day one. The ROI has been incredible.

MR

Maria Rodriguez

Founder at GlobalApp

Pricing

Simple, predictable pricing

One flat price for your scale.
Every feature in every plan.
No per-word fees, no token maths.

Starter
4/ month

Up to 1,000 monthly active users

For indie apps and new products

Indie
9/ month

Up to 5,000 monthly active users

For apps finding their audience

Growth
29/ month

Up to 50,000 monthly active users

For apps with real traction

Scale
99/ month

Up to 500,000 monthly active users

For products at scale

Every plan includes:

All 48 languages. The whole world, from day one

Unlimited translations, AI included. New strings translate themselves in production

Live translation of user-generated content (UGC)

Upgrade, downgrade or cancel at any time

More than 500,000 monthly active users? Contact us

What the same app costs somewhere else

Move the two sliders. The bill is for your app in all 48 languages.

1,000
2,500
SolutionYour monthly billYou pay perTranslationLanguages
i18n-keylesswe€4/ monthMonthly active users
Win win.
AI, unlimited, includedAll 48, from day one
Crowdin€88/ month1Hosted words: your words × 48
Crowdin AI, inside a quotaYou add each one
Intlayer€27/ month2Seats and projects
AI generation, within a quotaYou add each one
Lingo.dev€91/ month3A base fee, then AI tokens
The AI bill goes straight to youYou add each one
Locize€77/ month4Words × 48, and CDN downloads
You bring your own AI key10 on the largest published plan
Lokalise€132/ month5Seats, then keys
Translators billed separatelyYou add each one
Phrase€483/ month6Seats, then managed words
From $0.06 per word, billed separatelyYou add each one
Smartling€552/ month7Every word, every language
AI translation from $0.06 a wordYou add each one
Tolgee€49/ month8Keys and seats
Machine translation creditsYou fill each one
Weglot€1,678/ month9Words × languages, on a web page
Machine, inside a quota20 on the largest published plan

Public list prices, read in August 2026. Vendors change them, so please check. Each bill is our reading of the published ladder, and we always take the cheapest paid plan that holds your app. When a vendor bills the first translation once, we spread it over twelve months.

1 Crowdin publishes €44 a month for 60,000 hosted words on the Pro plan, billed annually. A hosted word is one word in one target language. We repeat that block price above 60,000.

2 Intlayer is open source. The $29 per month covers the CMS and the AI generation quota. Above the quota, you can use your own AI key, so we add the model bill at $10 for each million tokens, spread over twelve months.

3 Lingo.dev publishes $99 a month plus $2 for each million tokens of infrastructure, and it passes the model bill to you. We count 1.4 tokens for each word and $10 for each million tokens of model cost. The base fee is most of this number.

4 Locize publishes £7, £19 and £49 a month for 15,000, 30,000 and 60,000 words, with 1, 3 and 5 million CDN downloads. Above that it publishes $0.50 for each 1,000 extra words and $5 for each million extra downloads. We count thirty downloads for each user each month. No published plan supports 48 languages.

5 Lokalise publishes $144, $375 and $999 a month, and no key limit. We assume the three plans hold 5,000, 20,000 and 100,000 keys, and twelve words for each key. Human translation is billed separately.

6 The phrase publishes $525 a month for 1 million managed words on the software plan, and $1,245 for 3 million. We count one managed word for each word in each language, and we repeat the $1,245 block above for 3 million.

7 Smartling does not publish a platform price. We count only the AI translation, at the published $0.06 a word, spread over twelve months. Your real bill is higher.

8 Tolgee bills keys, not words, so we count twelve words for each key. It publishes £49 for 2,000 keys, £179 for 5,000 and £499 for 20,000, billed annually. Above that we repeat the £499 block. Machine translation credits are counted apart.

9 Weglot translates a web page, not an app. Its largest published plan is £699 a month for 20 languages, so we scale that price to 48 languages. Your words fit inside every one of these plans.

Every other line grows with your product. Ours is a flat price.

Try it yourself

Watch the Demo

Watch this short video to see i18n-keyless in action

Get API Key for One App

Your entire i18n implementation in 5 minutes. iykyk.