Translate I18n JSON/ARB by l10n.dev

AI-powered localization in VS Code. Translate i18n JSON and ARB files directly in your editor using l10n.dev's intelligent translation service.

Features

• 🤖 AI-Powered Translation: Context-aware translations using advanced AI.
• 165 Languages: Translate to any of 165 supported languages.
• Flutter Localization Support: Full support for ARB (Application Resource Bundle) files used in Flutter apps. Automatically handles @@locale and @@last_modified metadata.
• 🔧 Customizable Translation Style: Configure translations to use contractions (e.g., "don't" vs "do not"), enable shortening when translations exceed source text length, and generate plural forms for i18next compatibility.
• 🔄 Translate Only New Strings: When a target file already exists, choose to translate only new strings and update the existing file, or create a new file with a copy number. Perfect for iterative localization workflows.
• 🌐 i18next Plural Forms Support: Automatically generates all required plural form strings with correct plural suffixes when enabled—ideal for i18next projects. For languages with complex pluralization rules (like Russian, Arabic, or Polish), the extension ensures every necessary form is created, even if your source file only has _one or _other. This guarantees your app works correctly in every locale, with no missing or incorrect plural forms.
• 🛠️ Developer-Friendly Features: Preserves placeholders, HTML tags, and formatting while adapting dates and numbers to target locales. Intelligently avoids translating things that shouldn't be translated (proper names, urls, technical terms, etc.). Learn more in this article: i18n vs l10n: Why Developers Should Care and How AI Can Help.
• 🔒 Type Safety: Preserves JSON data types during translation—numbers remain numbers, booleans stay booleans, and null values are maintained. AI translates only string content without converting other data types to strings.
• 🔐 Secure API Key Storage: Your API Keys are stored securely using VS Code's built-in secrets manager.
• 🎯 Smart Language Detection: Automatically detects target languages from your project structure for seamless file organization.
• 🌍 Translate to All Languages: Translate your file to all detected languages at once with a single command.
• 🌐 i18next Support: Works seamlessly with i18next and other common i18n formats.
• 🧩 Source Text as Keys: Supports projects using source text as translation keys.
• 🕵️ Smart Error Detection & Chunking: Automatically detects and retries translations if placeholders or formatting are lost by the AI. For large files, l10n.dev splits content into manageable chunks, maintaining links and context between segments. This prevents issues common with direct uploads to AI models (like Claude or GPT), where exceeding ~16,000 characters can cause the model to omit, merge, or shorten content—resulting in lost context and lower translation quality. l10n.dev's approach ensures high-quality, accurate translations even for large i18n files.
• 💰 Free: Users get 30,000 characters free monthly.

Getting Started

1. Get Your API Key

1. Visit l10n.dev/ws/keys
2. Sign up for a free account
3. Generate your API Key

2. Configure the Extension

1. Open VS Code Command Palette (Ctrl+Shift+P / Cmd+Shift+P)
2. Run l10n.dev: Set API Key
3. Paste your API Key when prompted

3. Translate Your Files

1. Right-click on any JSON or ARB file in the Explorer or Editor
2. Select Translate JSON to... or Translate ARB to...
3. Choose your target language (or select "Translate to All Languages" for batch translation)
4. If target file(s) exist, choose to update existing files or create new ones
5. Wait for translation to complete
6. Find your translated files in the appropriate language folders

Related Project: ai-l10n npm Package

Looking for a programmatic solution? Check out the ai-l10n npm package! This Node.js package provides the same powerful AI translation capabilities directly in your JavaScript/TypeScript projects.

Why use ai-l10n?

1. CI/CD Integration - Automate translations in your build pipeline or deployment workflows
2. Programmatic Control - Full API access with TypeScript support for custom translation logic and batch processing
3. CLI Support - Command-line interface for quick translations without opening VS Code
4. Framework Agnostic - Use with any Node.js project: React, Vue, Angular, Next.js, Express, or standalone scripts
5. Advanced Features - Access to l10n.dev API

Perfect for developers who want to integrate AI-powered localization into their automated workflows, build tools, or server-side applications.

ARB File Support (Flutter Localization)

The extension fully supports ARB (Application Resource Bundle) files used in Flutter applications:

• Automatic Metadata Updates: The API automatically updates @@locale to the target language code and @@last_modified to the current UTC timestamp
• Custom Prefixes: Supports custom file naming patterns (e.g., app_en_US.arb, my_app_fr.arb)
• Underscore Format: ARB files use underscores instead of hyphens (e.g., en_US instead of en-US)
• Perfect for Flutter: Seamlessly integrates with Flutter's localization workflow

Supported Project Structures

The extension automatically detects target languages from common i18n project structures and saves translated files accordingly:

Folder-based Structure

locales/
├── en/
│   ├── common.json
│   └── auth.json
├── es/
├── fr/
└── de/

How it works:

• Detection: Language code is identified from the folder name (e.g., en/, es/, fr/)
• File Saving: Creates the target language folder if it doesn't exist and saves the file with the same name as the source file
• Example: Translating locales/en/common.json to Spanish → locales/es/common.json
• Conflict Resolution: If the target file already exists, adds a copy number (e.g., common (1).json)

File-based Structure

i18n/
├── en.json
├── en-US.json
├── es.json
├── fr.json
├── de.json
└── zh-Hans-CN.json

l10n/
├── app_en.json
├── app_en_US.json
├── app_es.json
├── app_fr.json
├── app_de.json
└── app_zh_Hans_CN.json

How it works:

• Detection: Language code is identified from the filename (e.g., en.json, es.json, fr.json)
• File Saving: Saves the translated file using the target language code as the filename in the same folder
• Example: Translating i18n/en.json to Spanish → i18n/es.json
• Conflict Resolution: If the target file already exists, adds a copy number (e.g., es (1).json)

Unknown Structure Fallback

For projects that don't match the above patterns, the extension falls back to saving files with the format: {originalname}.{languagecode}.json in the same directory as the source file.

Configuration Options

Configure translation behavior in VS Code settings (Ctrl+, and search for "l10n-translate-i18n"):

• Use Contractions: Makes translations less formal (default: true)
• Use Shortening: Uses shortened forms if translation is longer than source (default: false)
• Generate Plural Forms: Generates additional plural form strings (e.g., for i18next) with plural suffixes. Do not enable for strict source-to-target mapping (default: false)

Commands

• Translate I18n: Set API Key - Securely configure API Key
• Translate I18n: Clear API Key - Clear API Key in VS Code secrets storage
• Translate I18n: Configure Translation Options - Open extension settings
• Translate I18n: Translate JSON to... - Translate JSON file
• Translate I18n: Translate ARB to... - Translate ARB file (Flutter localization)

Language Support

l10n.dev supports 165+ languages with varying proficiency levels:

• Strong (12 languages): English, Spanish, French, German, Chinese, Russian, etc.
• High (53 languages): Most European and Asian languages
• Moderate (100+ languages): Wide range of world languages

Pricing

• Free Characters: 30,000 characters for free monthly.
• Pay-as-you-go: Affordable character-based pricing. Visit l10n.dev/#pricing for current pricing.
• No subscription required

Troubleshooting

Common Issues

"API Key not configured"

• Run l10n.dev: Set API Key command
• Ensure you've copied the key correctly from l10n.dev/ws/keys

"Insufficient balance"

• Check your account balance at l10n.dev
• Purchase more characters if needed

"No languages detected"

• The extension will prompt you to enter a language code manually
• Use BCP-47 format (e.g., "es", "fr", "zh-CN", "en-US")

"Invalid JSON file"

• Ensure your JSON file is valid
• Check for syntax errors using VS Code's built-in JSON validation

Important: Working with Arrays in JSON

⚠️ When using "Translate Only New Strings": If your JSON contains arrays (not just objects), make sure the array indexes in your target file match those in the source file. This ensures translations remain consistent. When adding new strings, always append them to the end of the array.

Example:

// ✅ CORRECT: New items added at the end
// source.json
["Apple", "Banana", "Orange"]

// target.json (existing)
["Manzana", "Plátano"]

// After translation (new item appended)
["Manzana", "Plátano", "Naranja"]

// ❌ INCORRECT: Items inserted in the middle
// This will cause misalignment!
["Apple", "Cherry", "Banana", "Orange"]

For object-based JSON structures (recommended for i18n), this is not a concern as translations are matched by key names.

Support

• API Documentation: l10n.dev/api/doc
• Issues: Report bugs on github

Privacy & Security

• API Keys are stored securely using VS Code's encrypted secrets storage
• No source code or translations are stored on our servers beyond the processing time
• All communication with l10n.dev API is encrypted (HTTPS)

---

Made with ❤️ for developers who care about internationalization (i18n) and localization (l10n)

---

Tip: For translating a large number of files, use the I18N File Translation UI on l10n.dev. The VS Code extension translates files in real time via the Translate JSON API and does not store your JSON or translations on our servers. For very large files, translation may take several minutes and delivery cannot be guaranteed in all cases.

On the l10n.dev platform, you can securely create translation jobs for batch processing, set custom terminology, monitor progress in real time, and download your files when complete. You have full control: files can be deleted at any time. For automation and CI/CD workflows, our API lets you integrate localization seamlessly into your pipelines.

l10n.dev is built by developers for developers, with privacy, reliability, and quality as top priorities.