DeepL, Google Translation or an LLM: API Cost per Job
The bottom line: For a standardized 1M-character workload, Google Cloud NMT comes to $10.00 after applying its eligible monthly promotional credit, DeepL Growth costs $32.50 on a monthly billing cycle, and a lightweight LLM like GPT-6 Luna runs about $0.16 in raw token compute. Those wildly different bills buy very different developer experiences, failure modes, and review burdens.
Compare a translation API with an LLM workflow here; use the text-and-document guide for character allowances and formatted-file billing. DeepL vs Google vs Azure Translation: monthly text and document costs.
The reason this is so hard to compare is an apples-to-oranges accounting puzzle. Dedicated translation engines like DeepL and Google Cloud Translation bill primarily by source characters. General-purpose Large Language Models like GPT-6 bill by input and output tokens.
All list rates were verified on 25 October 2026 in US dollars, excluding local sales taxes. This guide contrasts dedicated machine-translation endpoints with generative LLM translation workflows. If you need formatted file parsing (DOCX, PDF) or Azure AI Translator comparisons, check our broader enterprise translation guide.
Use the right product and billing period
Billing rules and minimum fees diverge quickly across providers, so it's worth getting the fine print straight before comparing anything:
- DeepL API: The US API portal on DeepL's pricing page lists DeepL Growth at $32.50/month on monthly billing. That bundles 1M characters every month and bills $27.50 for each additional million characters. The annual commitment is advertised at $26/month billed annually ($312 upfront) for a shared pool of 12M characters per year. An annual shared pool works under different roll-over dynamics than a strict monthly cap, so the models below stick to transparent monthly billing. DeepL's free Developer tier is an evaluation sandbox, not a production baseline, and consumer DeepL Translator subscriptions don't grant API access.
- Google Cloud Translation: Google's pricing rules list standard Neural Machine Translation (NMT) at $20 per million source characters. Google provides an eligible $10.00 monthly billing credit shared across Translation Basic and Advanced APIs. The practical catch: this credit doesn't roll over to future months and doesn't apply to formatted document translation. The calculations below assume the credit is available.
- Google Translation LLM & Adaptive: Google also offers LLM-powered translation options. Google Translation LLM bills $10 per million input characters plus $10 per million output characters. Adaptive Translation lists $25 per million input characters plus $25 per million output characters. Translated output naturally expands or contracts across languages, so input and output counts rarely match. Don't treat either tier as a simple flat rate per source character.
- OpenAI LLM APIs: According to the current OpenAI rate card, GPT-6 Luna charges $0.10/M input tokens and $0.50/M output tokens. GPT-6.1 Sol charges $2.00/M input tokens and $10.00/M output tokens. These are raw token execution costs, not a statement about linguistic benchmark parity.
A reproducible 1M- and 10M-character scenario
To keep the comparison fair, imagine translating plain text into a single target language. Assume an average request size of 1,000 source characters, accompanied by 50 system prompt/instruction tokens, and expanding to 250 source tokens and 250 target output tokens per call.
These token ratios are explicit modeling inputs, not universal linguistic laws for Latin or non-Latin alphabets. Prompt caching, batch discounts, and retry overhead are excluded from this baseline table:
For 1M characters (1,000 requests):
- Input tokens: 1,000 × (50 instruction + 250 source) = 300,000 tokens (0.3M).
- Output tokens: 1,000 × 250 = 250,000 tokens (0.25M).
- GPT-6 Luna: 0.3 × $0.10 + 0.25 × $0.50 = $0.155, rounded to $0.16.
- GPT-6.1 Sol: 0.3 × $2.00 + 0.25 × $10.00 = $0.60 + $2.50 = $3.10.
| Workflow | 1M source characters | 10M source characters |
|---|---|---|
| DeepL Growth, monthly | $32.50 | $280.00 |
| Google NMT, eligible credit unused | $10.00 | $190.00 |
| GPT-6 Luna, assumed token workload | $0.16 | $1.55 |
| GPT-6.1 Sol, assumed token workload | $3.10 | $31.00 |
Here is how the scaling math works:
- At 10M characters, DeepL's monthly bill equals the base $32.50 (including the first 1M) plus 9 × $27.50 overage = $280.00.
- Google NMT equals (10M − 0.5M credit) × $20/M = $190.00. If your organization has already exhausted Google's monthly credit elsewhere in the project, the charges become $20.00 and $200.00 respectively.
- If you process zero words in a slow month, DeepL's subscription still costs $32.50, whereas pay-as-you-go LLM usage is $0. Conversely, sending whitespace or empty strings to Google can still register as a billable character event.
For Google's specialized generative endpoints, assuming output character length matches input, Translation LLM costs $20.00 at 1M characters and $200.00 at 10M characters, while Adaptive Translation costs $50.00 and $500.00. Neither option receives the standard NMT billing credit.
Change the token ratio instead of guessing by language
Text expansion varies widely by language family. Japanese, German, Finnish, and Arabic consume very different token volumes compared to English source text.
Keeping our baseline 1M-character job with 50 instruction tokens per call, here's how varying source and output token density shifts LLM bills:
| Assumed source / output tokens | Luna usage | Sol usage |
|---|---|---|
| 250 / 250 | $0.16 | $3.10 |
| 500 / 500 | $0.31 | $6.10 |
| 1,000 / 1,000 | $0.61 | $12.10 |
These three rows are hypothetical token workloads designed to test budget sensitivity, not rigid claims about specific language pairs. Run representative sample text through your model's exact tokenizer before sizing any budget. Also factor in formatting overhead, markdown tags, and retry buffers. A slightly higher token spend is well worth it if the model preserves layout structure and business terminology without post-editing.
Billing units differ in how they count characters, too. Google counts Unicode code points, not UTF-16 code units or raw bytes. In Google's official documentation example, a short paragraph of five Japanese characters enclosed by HTML tags counts as twelve billable characters. Don't strip markup tags blindly if your rendering pipeline relies on them to reconstruct the user interface.
More target languages multiply the work
When you localize a single 1M-character content library into three distinct target languages, you trigger three independent translation events totaling 3M source characters.
On monthly subscriptions:
- DeepL Growth costs $32.50 + 2 × $27.50 = $87.50.
- Google NMT costs (3M − 0.5M credit) × $20/M = $50.00.
- Three independent runs of GPT-6 Luna at our baseline cost 3 × $0.155 = $0.465, rounded to $0.47.
- Three independent runs of GPT-6.1 Sol cost 3 × $3.10 = $9.30.
Running a single multi-language prompt through an LLM changes the input/output dynamics and context window caching, so treat it as its own distinct pipeline and calculate it separately.
It's easy to forget the cost of quality assurance. Adding an illustrative ten hours of professional human review at $40/hour introduces $400.00 in editorial labor. That single line item dwarfs the entire API bill, which makes a difference of a few pennies between LLM tokens or NMT character tiers a distinctly secondary concern. My practical rule of thumb: if a human reviews the output anyway, pick the engine that cuts review time, not the one with the lowest sticker price.
Which approach should you choose?
- Use dedicated translation APIs (DeepL or Google NMT) when you need solid terminology glossaries, native document format handling (PDFs, Office docs), predictable per-character costs, and a low risk of hallucinated text or dropped paragraphs.
- Use an LLM (Luna or Sol) when you need dynamic tone adaptation, creative localization, summarization combined with translation, or context-aware brand voice refinement.
Both architectures call for some defensive engineering. Neither eliminates linguistic edge cases or translation errors, and API arithmetic shouldn't be mistaken for final translation quality. If translation is a core part of your product, spend your budget on evaluation and review. If it's a nice-to-have feature, the cheapest option that passes your sample tests is usually the right call.