How does i18n-keyless work without translation keys?

i18n-keyless replaces translation keys with the real words already in your code. Instead of writing header.welcome.title and maintaining a matching entry in a locale JSON file, you write the actual sentence, and the service handles translation. It's aimed at teams using coding agents, and it's free to self-host or starts at €4/month hosted. The trade-off: you depend on a service (or your own deployment of it) to resolve text at runtime, and offline behavior falls back to untranslated real words rather than raw keys.

The core difference: real words instead of keys

In a traditional i18n setup, your code contains identifiers:

t('header.welcome.title')

and a separate file maps that identifier to text per locale. Every new string means a new key, a new entry, and a new translation — for each language.

With i18n-keyless, the string itself is the source:

t('Welcome back')

There is no key registry to maintain. The site describes this as "no keys system" — the reasoning being that generating and maintaining keys is mechanical work that shouldn't require developer attention.

What this changes in practice

No locale JSON to load or merge

Because there's no key-to-string mapping file, there's nothing to load at runtime and nothing to merge when multiple people edit translations. The site lists "no locale JSON to load, no merge conflict" as a direct benefit. In a key-based workflow, two developers adding keys to the same locale file is a routine source of conflicts; here that file doesn't exist.

The codebase stays readable

With keys, reading code means reading identifiers. The site makes the point that you can miss a grammatically wrong sentence because you're reading some.key.name instead of the sentence itself. With real words in place, the content is visible where it's used.

Failure mode is different

This is the most concrete behavioral difference. In a key system, a missing or unloaded translation shows the raw key to users — something like header.welcome.title. With i18n-keyless, the worst case (for example, offline) is that users see the untranslated real words, which are still readable. The site frames this as the key advantage: the fallback is never gibberish.

The maintenance math the site cites

The pitch includes a rough cost comparison for key-based systems:

These are the vendor's own estimates, not measured benchmarks, so treat them as an illustration of the workflow overhead rather than a guarantee. The underlying claim — that each key requires coordination across languages — is accurate for key-based systems.

How setup and integration work

The site advertises a 5-minute setup and a single API with twelve SDKs. The listed targets are:

• React — React Native, Expo, Next.js, Remix, TanStack Start, Astro
• Vue — Nuxt
• Angular
• Plain HTML — Svelte, Alpine, htmx via one script tag
• Node.js
• Laravel / PHP
• Rails / Ruby
• Flutter / Dart
• Swift — iOS, macOS, Vapor
• Kotlin — Android, Ktor
• Python — Django, Flask, FastAPI
• Go

There's also an MCP server, which is relevant if your coding agent is doing the integration work — the agent can call the service directly rather than you wiring it by hand.

What happens if the service shuts down

The site addresses this directly with a "What if the service shuts down?" section. The relevant facts from the page: it's free self-hosted, or hosted from €4/month. Self-hosting is the answer to the shutdown concern — if you run it yourself, there's no external dependency to lose. If you use the hosted version, you're relying on the vendor's continuity.

When this fits and when it doesn't

Choose i18n-keyless if:

• You want i18n in place from day one without slowing feature work
• You're using a coding agent and want it to get translations right without key bookkeeping
• You're willing to self-host, or accept a hosted dependency starting at €4/month
• Your priority is a clean, readable codebase over fine-grained control of every string ID

A key-based system may still fit better if:

• You need stable identifiers decoupled from source text (for example, strings that change often but must keep the same reference)
• You have strict offline or air-gapped requirements and don't want to self-host
• Your existing tooling and translator workflows are built entirely around key files

The decision mostly comes down to whether you value the absence of key management more than the control that explicit keys provide.