Go global. One PR.
Without touching a single file yourself.

Langflare connects to your GitHub repo, scans every .jsx/.tsx file, wraps hardcoded strings in t() calls, builds your translation JSON files, and opens a clean PR — in minutes, not months. Standard react-i18next. No vendor SDK. No lock-in.

Standard react-i18next. Zero vendor lock-in.

Full migration + translation in one PR.

Ongoing sync to keep you clean.

https://github.com/your-org/your-react-repo

Get My Free Quote

No credit card required. We treat your code as ephemeral data.

Automatic Extraction

Langflare reads code intent, not just syntax. It finds every user-facing string across your entire React codebase — including ternaries, template literals, and Zod validation messages — and ignores logic strings that shouldn't be translated.

Instant Translation

Choose your target languages. Langflare translates every extracted string with context-awareness — your domain, your UI patterns — and writes the JSON locale files directly into the PR.

Built on the tools your team already uses.

react-i18nextNext.jsTypeScriptGitHub

Teams spend weeks manually extracting strings, creating keys, and keeping JSON files in sync. Cursor helps, but it still misses edge cases. The real problem isn't finding the strings — it's everything that breaks when you try to automate it at scale.

— A pain point shared across dozens of React engineering teams

Every approach has a fatal flaw. Except one.

The Manual Grind

Regex, grep, find & replace

The Mechanism

Dumb pattern matching.

The Failure

It can't tell the difference between const id = 'submit-btn' (a CSS selector) and <Button>Submit</Button> (a UI string). Every false positive is a regression. Large teams report spending weeks just fixing what the script broke.

High risk of regressions

The AI Shortcut

Cursor, Copilot, or raw ChatGPT

The Mechanism

Probabilistic next-token prediction.

The Failure

Still misses edge cases. Hallucinates keys. Confuses logic strings with UI strings. Breaks template literals. And even when it gets it right, there's no ongoing governance — new hardcoded strings creep back in with every PR.

High risk of regressions

The Langflare Approach

Context-aware agent + structured pipeline

The Mechanism

Reads code intent, not just syntax.

The Result

A specialized agent walks your entire codebase — understanding DOM context, ternaries, template literals, Zod schemas. It wraps strings, builds JSON files, translates them, and opens a single clean PR. Then installs guardrails so you stay clean.

Compiler-verified safety

From legacy codebase to global-ready. In one afternoon.

Here's exactly what happens after you connect your repo.

Connect & Analyze

Connect your GitHub repo. Langflare clones it into an isolated environment, scans every .jsx, .tsx, .js, and .ts file, and counts every hardcoded string it finds.

Detects your framework (Next.js App Router, Vite, Remix)
Identifies translatable strings vs. logic strings
Estimates migration scope and shows you a price quote

✓ Detected: Next.js 14 (App Router)

✓ Found: 1,247 translatable strings across 89 files

✓ Estimated cost: $12.40 — approve to continue

Choose Languages & Approve

Review the migration scope. Select which languages you want to target. Approve the quote and Langflare kicks off the migration.

Target languages:

✓ Spanish

✓ French

✓ German

Japanese

Get Your PR

Langflare opens a pull request against your repo with everything done:

react-i18next installed and configured
Every string wrapped in t('namespace:key') calls
JSON translation files created for every language
Translated by a context-aware AI — not Google Translate

✓ PR opened: feat/i18n-migration

✓ 1,247 strings extracted

✓ 89 files modified

✓ 4 languages translated

Stay Clean (Optional)

Install the CI guardrail to prevent new hardcoded strings from creeping back in.

Pre-commit hook blocks new hardcoded strings before they ship
Run pnpm sync-locales to translate new keys to all your languages
Git-tracked: Langflare uses your commit history to find only new strings

⚠ Pre-commit: 2 new hardcoded strings

src/components/Modal.tsx:14

src/pages/Profile.tsx:38

→ Run: pnpm sync-locales

✓ 2 strings translated. Commit unblocked.

The edge cases that break every other tool.

Production React code is messy. Ternaries, template literals, Zod schemas, aria attributes — here's how Langflare handles what regex and raw AI miss.

Semantic Disambiguation

It knows what's UI text and what's not.

<div id="submit-btn">Ignored

<Button>Submit Form</Button>Extracted

aria-label, alt, titleConfigurable

Complex String Interpolation

Ternaries and template literals — handled correctly.

Ternaries

{isActive ? "Online" : "Offline"}

{isActive ? t("status.online") : t("status.offline")}

Template Literals

`Welcome back, ${user.firstName}`

t("welcome_user", { name: user.firstName })

Validation Schema Support

Error messages inside your Zod/Yup schemas get extracted too.

Zod / Yup

.min(5, "Password is too short")

.min(5, t("validation.password_too_short"))

Cleanup today. Governance forever.

One PR to migrate your legacy strings. One command to keep new ones in sync.

Available Now

Phase 1: Deep Clean

One-Time Migration

Connect your repo and Langflare generates a comprehensive pull request. react-i18next gets installed, every hardcoded string gets wrapped, and your JSON translation files are created and translated — all in one PR. You merge standard React code. No vendor binaries.

Strings grouped into logical namespaces
Consistent key naming conventions across your codebase
Standard react-i18next — your app works without Langflare

Get Started

feat/i18n-migration — diff

- <Button>Save Changes</Button>

+ <Button>{t('common:save-changes')}</Button>

+ en.json: { "save-changes": "Save Changes" }

+ es.json: { "save-changes": "Guardar Cambios" }

+ fr.json: { "save-changes": "Enregistrer" }

⚠ pre-commit: 3 new hardcoded strings

src/components/UserCard.tsx:42

src/pages/Settings.tsx:18

src/pages/Settings.tsx:31

→ Run: pnpm sync-locales

✓ 3 strings translated across 4 locales

✓ Commit unblocked

Available at Launch

Phase 2: CI/CD Protection

Available at Launch

Once migrated, Langflare installs a pre-commit hook that watches every new commit. If you add new hardcoded strings, the hook catches them before they ship. Run pnpm sync-locales to translate them to all your target languages at once.

Pre-commit hook catches new hardcoded strings before they ship
pnpm sync-locales translates new keys to all languages in one command
Git-tracked: Langflare only processes strings added since your last sync

Learn More

Your code is yours.

We know you're granting us access to sensitive code. Here's exactly what we do — and don't — do with it.

Ephemeral Processing

Your repo is cloned into an isolated temporary environment. Once the PR is generated, the clone is deleted. We do not store your source code.

Code is processed via Anthropic's Claude API under their data policies.

Scoped Permissions

We use GitHub App tokens with granular permissions. We cannot see your organization's other repos—only the ones you explicitly grant access to.

The "Output" Guarantee

The result of using Langflare is standard text files and standard React code. If you stop paying us, your app keeps working. Zero vendor lock-in.

Pay off your technical debt. Then keep it clean.

One-time migration to get you global. Usage-based credits to stay that way.

Starter

For indie apps and side projects going global.

$199/ project

Up to 100 Files

Scans every .jsx, .tsx, .js, .ts file
Wraps all strings in t() calls
Creates namespaced JSON translation files
Translates to your target languages
Opens a single clean PR

Get My Free Quote

Growth

For established products with real user bases.

$699/ project

Up to 500 Files

Scans every .jsx, .tsx, .js, .ts file
Wraps all strings in t() calls
Creates namespaced JSON translation files
Translates to your target languages
Opens a single clean PR
Priority support

Get My Free Quote

Scale

For large codebases with years of technical debt.

$1,499/ project

Up to 1,500 Files

Scans every .jsx, .tsx, .js, .ts file
Wraps all strings in t() calls
Creates namespaced JSON translation files
Translates to your target languages
Opens a single clean PR
Priority support
Custom namespace strategy

Get My Free Quote

Monolith with 2,000+ files? Run the free audit and we'll quote you based on actual string density.

Frequently Asked Questions

Everything you need to know before connecting your repo.

Your app is one PR away from going global.

Connect your GitHub repo, get a free quote, and have your migration PR ready by the end of the day.

Audit My Repo for FreeFree scan. No credit card. Your code is treated as ephemeral — deleted after the PR is generated.

Go global. One PR.Without touching a single file yourself.

Features

Automatic Extraction

Instant Translation

Every approach has a fatal flaw. Except one.

The Manual Grind

The AI Shortcut

The Langflare Approach

From legacy codebase to global-ready. In one afternoon.

Connect & Analyze

Choose Languages & Approve

Get Your PR

Stay Clean (Optional)

The edge cases that break every other tool.

Semantic Disambiguation

Complex String Interpolation

Validation Schema Support

Cleanup today. Governance forever.

Phase 1: Deep Clean

Phase 2: CI/CD Protection

Your code is yours.

Ephemeral Processing

Scoped Permissions

The "Output" Guarantee

Pay off your technical debt. Then keep it clean.

Starter

Growth

Scale

Frequently Asked Questions

What does the migration actually do?

Does this lock me into Langflare?

What frameworks does it support?

What if it misses a string or wraps the wrong thing?

How does the ongoing sync work — and what does it cost?

Can I control which files or directories are processed?

Your app is one PR away from going global.

Go global. One PR.
Without touching a single file yourself.