How much does AI translation cost? DeepL, Google Translate, OpenAI compared (2026)
Translation budget conversations usually start with the wrong question. Teams ask "which provider is best" before they know what "best" means for their project. Cost per character, cost per token, quality for European languages versus Asian languages, context awareness, privacy compliance: these are different trade-offs, and the answer depends on your use case.
This post gives you the actual numbers for 2026 across the providers teams most commonly use, a framework for comparing them fairly, and practical guidance on where each one earns its price.
Who this is for: developers and product teams deciding how to budget AI or machine translation into a localization workflow.
For a broader overview of how AI and machine translation fits into a localization strategy, start with the AI and machine translation guide. If you want the full picture on quality differences with examples, see our DeepL, Google Translate, and OpenAI auto-translation comparison.
Why translation pricing is confusing
The core problem is that providers use different billing units:
- Traditional MT APIs (DeepL, Google Translate) bill per character
- LLM-based models (OpenAI, Gemini, Claude, DeepSeek) bill per token, split into input and output
English averages roughly 4 characters per token. CJK scripts (Japanese, Chinese) are more token-efficient; German compound words run slightly higher. For a rough estimate: 1,000 characters ≈ 250 input tokens + 250 output tokens.
Input vs output. Output tokens cost 3-5x more than input. Everything in your prompt: source text, system instructions, key descriptions, context, is billed as input. It seems small per call but compounds across thousands of keys and many languages. Batching multiple strings per request keeps it manageable.
Reasoning tokens. Models like OpenAI o-series or Gemini 2.5 Pro with thinking enabled run an internal chain-of-thought that can be billed separately or included into the output cost, and is not visible in the output. For standard UI string translation, avoid them; they add cost and latency without meaningful quality gains.
Practical note: most real software localization projects have far fewer than 1 million characters to translate. A mid-sized SaaS app might have 50,000-200,000 characters across all supported locales, counting only new or changed strings per sprint. Smart caching (only sending changed keys to the translation API) is often the single biggest cost lever available.
Traditional machine translation APIs
These providers use specialized neural MT engines built for translation. They are fast, predictable, and billed purely on character volume.
Google Cloud Translation
Pricing:
- 500,000 characters/month free (resets monthly, never expires)
- Basic NMT: $20 per million characters
- LLM Translation mode: $10 input + $10 output per million characters (no free tier)
- Adaptive Translation (fine-tuned on your data): $25 + $25 per million characters
Language support: 249 languages as of 2026: the broadest coverage of any major provider. In late 2025, Google upgraded its models with Gemini-powered quality improvements, particularly on idioms and conversational content.
Best for: teams that need to cover a wide range of languages fast, especially non-European ones (Arabic, Southeast Asian scripts, rare language pairs). The standard NMT is well-priced at $20/M, and the free tier is generous enough for development and staging.
Watch out for: billing counts HTML tags as characters when present in your strings. If you are sending rich-text content through the API, strip markup first or your actual cost will be noticeably higher than estimated.
DeepL API
Pricing:
- DeepL API Developer plan: 1 million characters as one-time credit for testing, no monthly fee
- DeepL API Growth plan: 1 million characters/month for $32.50/month (or €29.75/mo in Europe)
- usage limit is 50 million characters per month
- $27.50 for 1,000,000 extra characters
API Free and API Pro plans have been discontinued for new signups as of mid-2026, but existing users can continue on their current plan.
Language support: 30 available languages, plus concentrated in European pairs. DeepL consistently produces more natural-sounding output for English-German, English-French, English-Spanish, and other European pairs, mainly for longer or more complex strings. DeepL's next-gen LLM adds over 80 new language pairs in 2026.
Best for: European SaaS products with customer-facing copy where natural tone matters. Marketing pages, onboarding flows, and UI copy that users read carefully benefit from DeepL's quality advantage in supported pairs.
Watch out for: The cost is higher than Google NMT for the same character volume, and the free tier is more limited. For non-European languages, the quality gap narrows, so the price premium may not be justified.
Source: DeepL Translator languages, DeepL API pricing accessed June 2026.
Quick comparison
Here is a quick cost comparison for 1 million characters of input text (assuming output length is roughly the same):
| Provider | Cost per 1M chars | Free tier | Languages |
|---|---|---|---|
| Google NMT | $20 | 500K/mo | 249 |
| DeepL API Growth | $32.50 | 1M | 100+ |
| Microsoft Translator | $10 | 2M/mo | 100+ |
Microsoft Translator at $10/M and a 2M character permanent free tier is worth knowing about, particularly for teams that need broad coverage at lower cost and are not yet at the scale where DeepL's quality premium pays off.
LLM-based translation via API
LLMs are not translation-specialized engines. They are general-purpose language models that, given the right prompt and context, produce high-quality translations, particularly for nuanced, tone-sensitive, or ambiguous content. The cost structure and capabilities are different enough to treat separately.
How to convert LLM pricing to translation cost
LLMs bill per token. For translation, you have:
- Input tokens: your system prompt + the source text + any context (key descriptions, project description, character limits, tags)
- Output tokens: the translated text (+ any reasoning tokens if you enable thinking)
Output tokens typically cost 3-5x more than input tokens. For translation, a rough rule: output tokens ≈ input source-text tokens (output length roughly matches source length). The system prompt and context add overhead; typically 200-500 tokens per request, or much less if you batch many strings in one call.
For budget estimation, a useful approximation:
1,000 characters of source text ≈ 250 input tokens + 250 output tokens
At most mid-tier LLM prices, that makes AI translation comparable to or cheaper than character-based MT, if you batch efficiently.
OpenAI
OpenAI's models are the most widely used for LLM-based translation, with a range of options from budget to premium quality.
| Model | Input (1M tokens) | Output (1M tokens) | Notes |
|---|---|---|---|
| GPT-4o-mini | $0.15 | $0.60 | Best value for bulk UI strings |
| GPT-4o | $2.50 | $10.00 | Strong general quality |
| GPT-4.1 | $2.00 | $8.00 | Good balance of cost and capability |
| Batch API (any model) | 50% off | 50% off | Async, 24h turnaround |
GPT-4o-mini is the go-to for high-volume localization where cost is the primary concern. Quality is solid for most UI strings. At $0.15/M input and $0.60/M output, it competes directly with character-based MT on price while adding context awareness.
GPT-4o earns its price for marketing copy, onboarding flows, and content where tone matters. The context window (128K tokens) lets you batch many strings per request, which reduces per-key overhead from the system prompt.
Batch API is worth using for non-time-sensitive localization runs, translating all missing keys overnight at half the cost.
Google Gemini
Google's Gemini models are a strong alternative to OpenAI for translation, with competitive pricing and good quality across a wide range of languages.
| Model | Input (1M tokens) | Output (1M tokens) | Notes |
|---|---|---|---|
| Gemini 2.5 Flash-Lite | $0.10 | $0.40 | Cheapest capable model |
| Gemini 2.5 Flash | $0.30 | $2.50 | Strong throughput |
| Gemini 2.5 Pro | $1.25 | $10.00 | High reasoning quality |
Gemini 2.5 Flash is a strong choice for bulk translation where speed and cost matter more than peak nuance. It handles multilingual content well and is often the most cost-effective option for large batches. Gemini also offers a generous free tier via AI Studio: 15 requests per minute at no cost on Flash models, which covers development and prototyping.
Anthropic Claude
| Model | Input (1M tokens) | Output (1M tokens) | Notes |
|---|---|---|---|
| Claude Haiku 4.5 | $1.00 | $5.00 | Fast, budget-friendly |
| Claude Sonnet 4.6 | $3.00 | $15.00 | Nuanced output, strong for creative copy |
Claude's particular strength in translation is tone and cultural nuance. For marketing pages, voice-heavy onboarding, and brand-sensitive copy, Claude Sonnet produces output that reads more naturally to native speakers. It is not the cheapest option for bulk UI strings, but the quality gap is visible in customer-facing content.
DeepSeek V3
DeepSeek is a newer player in the LLM space, with a focus on cost-effective translation. Their V3.2 model is optimized for translation tasks and offers competitive pricing.
| Model | Input (1M tokens) | Output (1M tokens) | Notes |
|---|---|---|---|
| DeepSeek V3.2 | ~$0.22 | ~$0.34 | Remarkably cheap for the quality |
DeepSeek V3 has emerged as a budget-first option for teams that want LLM-quality output at near-MT prices. Particularly strong for East Asian languages (Mandarin, Japanese, Korean), which makes it interesting for teams targeting those markets where Google and DeepL are less differentiated. Available via OpenRouter.
OpenRouter: accessing multiple models via one API
OpenRouter is an API gateway that provides access to models from multiple providers like Claude, GPT, Gemini, DeepSeek, Llama, Mistral, through a single endpoint. It charges provider list prices plus a small markup.
The main practical use case for localization is mixing models per task: cheaper, faster models for bulk UI string runs and higher-quality models for tone-sensitive copy, without maintaining separate API keys and billing accounts per provider.
Real cost scenarios
These estimates assume efficient batching, with system prompt overhead amortized across many strings per request.
Scenario: 10,000 translation keys, English source, translating into 5 languages (DE, FR, ES, PT, JA)
Assume average key length of 60 characters = 600,000 characters of source text × 5 languages = 3M total characters to translate.
| Provider | Est. cost | Notes |
|---|---|---|
| Google NMT | ~$60 | After free tier |
| DeepL API Growth | ~$88 | Strong for DE/FR/ES/PT; limited JA quality |
| GPT-4o-mini | ~$10-15 | Context-aware, all 5 languages |
| Gemini 2.5 Flash | ~$15-25 | Fast, cost-efficient |
| Claude Haiku 4.5 | ~$30-45 | Good quality/cost balance |
| GPT-4o | ~$65-100 | Premium quality |
Key insight: GPT-4o-mini at $0.15/M input often undercuts traditional MT services in absolute cost, while adding context awareness and support for custom instructions. The per-character mental model from traditional MT underestimates how competitive LLMs have become at the budget tier.
Scenario: Only new strings (smart caching in action)
A product with 10,000 keys that ships weekly and adds 150 new keys per sprint:
- Without caching: paying to re-translate all 10,000 keys every run
- With caching: paying to translate only 150 new keys per run
At $0.15/M input tokens (GPT-4o-mini), 150 keys at 60 chars average = 9,000 characters ≈ 2,250 input tokens + 2,250 output tokens. Total per sprint: under $0.01.
This is why translation memory and smart caching: sending only new or changed keys to the API, is more impactful than provider choice for most teams.
How to choose
Use this as a starting framework:
Use Google NMT if:
- You need broad language coverage (100+ languages, especially Asian and African scripts)
- You want predictable character-based pricing with a permanent free tier
- You need fast turnaround for large volumes
Use DeepL if:
- Your target languages are primarily European (DE, FR, ES, IT, NL, PL, etc.)
- Customer-facing copy quality matters
- You are willing to pay a small premium for better natural-language output in supported pairs
Use GPT-4o-mini or Gemini 2.5 Flash if:
- You want LLM context awareness at near-MT prices
- You have varied content types (UI strings, help docs, marketing copy) in one workflow
- You want one provider that covers all your languages without quality gaps
Use Claude Sonnet or GPT-4o if:
- The content is brand-sensitive, marketing-heavy, or voice-driven
- Tone accuracy justifies a higher per-token cost
- You want the best output quality with no manual post-editing
Use DeepSeek V3 via OpenRouter if:
- East Asian languages are a priority
- Cost is a hard constraint and you need LLM-quality output
- You are comfortable with a less established provider
One more cost lever: your TMS
Provider pricing is only one part of the equation. How your translation management system sends content to the API affects cost at least as much.
A tool that re-translates your entire file every run costs 100x more than one that tracks which keys changed and sends only the delta. SimpleLocalize tracks translation state per key and only sends new or modified strings to the AI model. Combined with per-project context settings, the effective cost per language per sprint is usually a few dollars for most SaaS teams.
For a full walkthrough of how AI translation workflows fit into a broader localization pipeline, see our guide on AI-powered localization workflows and the AI-Powered Localization control center page.
Summary
Here is a quick cost comparison for 1 million characters of input text (assuming output length is roughly the same):
| Provider | Billing | Cost at 1M chars/tokens input | Strength |
|---|---|---|---|
| Google NMT | per character | $20 | Breadth, 249 languages |
| DeepL API Growth | per character | $27.50/mo | European language quality |
| GPT-4o-mini | per token | ~$3-5 equiv. | Cost-effective LLM quality |
| Gemini 2.5 Flash | per token | ~$5-8 equiv. | Speed and throughput |
| Claude Haiku 4.5 | per token | ~$20-30 equiv. | Balanced quality |
| GPT-4o | per token | ~$50-80 equiv. | Premium general quality |
| Claude Sonnet 4.6 | per token | ~$60-100 equiv. | Nuanced, tone-accurate output |
| DeepSeek V3 | per token | ~$3-5 equiv. | Budget LLM, strong on Asian pairs |
Character equivalents are rough estimates assuming 250 input + 250 output tokens per 1,000 source characters, with batched system prompts.
Pricing changes regularly, so always verify current rates before locking in a budget. Links to official pricing pages: OpenAI, Google Cloud Translation, DeepL API, OpenRouter.
