DeepL API Pricing, Plans & Limits 2026: Developer Guide¶

DeepL API Free gives you 500,000 characters per month at no cost - enough for a prototype or side project, but not production. API Pro is $5.49/month plus $25 per million characters, with no volume cap. Here’s everything on plans, billing quirks, rate limits, and actual costs so you can pick the right tier and budget accurately before you ship.

DeepL API Plans in 2026¶

DeepL offers three tiers for developers: API Free, API Pro, and Growth. Enterprise handles large-scale custom contracts.

API Free - the no-cost plan for development and testing. 500,000 characters per month, $0. Your API key ends in :fx - that’s how DeepL (and your code) distinguishes Free from paid accounts. Requests go to api-free.deepl.com, not the standard api.deepl.com.

API Pro - the main paid tier. Fixed $5.49/month subscription plus $25 per million characters. No volume cap - you pay only for what you actually translate.

Growth - designed for teams that need multiple API keys, more glossaries, and better economics at medium volumes. $26/month includes 12 million characters per year (~1M/month). Overage rate is $27.50 per million characters. Extras: 120 hours of speech-to-text per year, up to 10 API keys, 2,000 glossaries, CAT tool integration.

Annual billing saves 16% on paid plans. Enterprise is worth contacting sales if you’re consistently above 50M characters/month.

One pricing trend worth noting: according to metronome.com, the API cost $40 per million characters in November 2021, dropping to $25 by early 2025 - a nearly 40% reduction. In November 2025 DeepL raised consumer plan prices by 44-46% while continuing to lower API rates, deliberately making the API more accessible to developers.

How Character Billing Works: Where You’ll Pay More Than Expected¶

Characters are counted on source text, not the translation output. The unit is Unicode code points: one character = one code point regardless of language.

A few billing behaviors that regularly catch developers off guard:

HTML tags. If your text contains HTML and you don’t pass tag_handling=html, the tags are counted as regular text and billed accordingly. With tag_handling=html enabled, tags are ignored and only the text content between tags counts. Always enable this for web content.

Same source and target language. If you accidentally send source_lang=DE&target_lang=DE in testing or due to a bug, those characters still count against your quota.

Document translation minimum. This is the biggest surprise: when translating files (.docx, .pdf, etc.), DeepL charges a minimum of 50,000 characters even if the document is shorter. A one-page cover letter still costs you 50K characters - that’s $1.25 at Pro rates. If you’re translating many small documents, factor this into your cost model.

Whitespace counts. Spaces, line breaks, and tabs are all billed. Trimming unnecessary whitespace before sending can shave a few percent off costs at scale.

Maximum request size to /v2/translate is 128 KiB (headers capped at 16 KiB).

Document Format Limits¶

Image translation is currently in Beta and not billed on any plan - so translating text from screenshots or scanned PDFs is free right now. Worth testing while that window is open.

Rate Limits and Errors 429 and 456¶

DeepL doesn’t publish specific rate limit thresholds in their documentation - this is one of the most common complaints in developer forums. Two HTTP error codes you need to handle:

429 Too Many Requests - too many requests in a short window. This can happen on any plan if you parallelize aggressively. As one developer described in the deepl-node GitHub issue:

We have 15 concurrent functions attempting to translate ~72KB of text simultaneously. All getting timeout errors.

456 Quota Exceeded - monthly character quota exhausted. This error exists only on API Free (500K character cap). Pro and Growth don’t have a quota error because there’s no monthly cap.

The DeepL error handling documentation recommends exponential backoff when you receive 429. All official SDKs - Python, Node.js, .NET/C#, PHP, Java, Ruby - have retry with backoff built in, so if you’re using an official library, it handles this automatically.

On API Free, rate limits are stricter than on Pro, though DeepL doesn’t publish the numbers. Practical rule: if you’re firing more than 5-10 parallel requests, add a delay between batches or upgrade to Pro.

Key Developer Features¶

Glossaries¶

Glossaries let you lock in specific term translations - brand names, technical abbreviations, product terms. Unlike a simple search-and-replace, DeepL adapts glossary terms to the target language grammar - declensions, gender, number. Supported for 55 language pairs.

Growth includes up to 2,000 glossaries per account. Pro has no limit.

Formality¶

The formality=formal or formality=informal parameter controls register and is supported for 10 languages: Dutch, French, German, Italian, Japanese, Polish, Portuguese, Russian, Spanish, Vietnamese. Useful for products where the tone of address matters (B2C apps, official correspondence).

Languages and Beta Languages¶

The core set with full features (glossaries, formality, Clarify) is around 33 languages. An additional 75 languages are available in Beta via the enable_beta_languages parameter - but without glossary or formality support.

SDKs and Client Libraries¶

Official: Python, Node.js, .NET/C#, PHP, Java, Ruby. Community-maintained libraries exist for Dart, Go, and Rust.

Minimal Python example:

import deepl

translator = deepl.Translator("YOUR_AUTH_KEY")
result = translator.translate_text(
    "Please prepare the documents for tomorrow.",
    source_lang="EN",
    target_lang="DE",
    formality="formal"
)
print(result.text)
# "Bitte bereiten Sie die Dokumente bis morgen vor."

Custom Instructions¶

A newer parameter lets you pass custom instructions to the translation model - useful for setting tone, style, or domain-specific rules that the standard model wouldn’t apply on its own.

Real Costs at Scale¶

Concrete reference points: a standard document (contract, certificate) is about 2,000-5,000 characters. A 10-page landing site is 20,000-50,000 characters. A 100-page website is 200K-500K characters. A 200-page book is 500K-700K characters.

Growth includes 12M characters per year - if your usage spikes in some months and drops in others, Pro is more flexible since you pay only for actual usage.

The crossover point: at around 2.8M characters/month, Pro and Growth cost roughly the same. Below that - Growth is cheaper and gives more. Above that - Pro is cheaper at $25/1M vs Growth’s $27.50/1M overage.

That said, price isn’t the only variable. Growth’s 10 API keys matter if you need separate keys for prod/staging/dev environments or individual team members. And 2,000 glossaries is significant for language-heavy applications.

When to Stay on Free vs Upgrade¶

API Free makes sense for: - Development and testing before going to production - Side projects and MVPs where volume stays under 500K/month - Evaluating whether DeepL quality fits your use case (before committing to a paid plan)

API Pro makes sense for: - Any production application that needs reliability (Free quota can expire mid-month) - Single-key setups where one API key is enough - High-volume workloads above 3M characters/month (cheaper per character than Growth)

Growth makes sense for: - Teams needing multiple API keys for different environments or members - Volumes of 1M-3M characters/month where Growth is cheaper than Pro - Products with heavy glossary usage (2,000 glossaries) or speech-to-text needs

One migration gotcha: when moving from Free to Pro, update your endpoint in code from api-free.deepl.com to api.deepl.com. This is the most common mistake when upgrading.

FAQ¶

How much does DeepL API cost in 2026?¶

API Free is $0 with 500,000 characters/month. API Pro is $5.49/month + $25 per million characters, no cap. Growth is $26/month with 12M characters/year included, $27.50 per million overage. Enterprise pricing is custom - contact DeepL sales. Annual billing cuts costs by 16%.

What’s the difference between DeepL API Free and Pro?¶

Three main differences: 1) Free is capped at 500K characters/month, Pro has no cap. 2) Free uses api-free.deepl.com endpoint, Pro uses api.deepl.com. 3) Free has strict rate limits - in practice, more than 5-10 parallel requests regularly trigger 429s. Free keys have a :fx suffix.

How does DeepL count characters?¶

By source text length in Unicode code points. HTML tags don’t count if you enable tag_handling=html. Document translation has a 50,000-character minimum even if the file is shorter. Translating text with the same source and target language still counts toward your quota.

What should I do when I get error 429?¶

It means Too Many Requests. Official SDKs handle this automatically with built-in exponential backoff. For custom HTTP clients, implement retry with increasing delay. Error 456 (Free plan only) means your 500K monthly quota is exhausted - wait until the next billing cycle or upgrade to Pro.

Can I use the free plan in production?¶

Technically yes - the API Free plan allows production use within the 500K character/month limit. But there are real risks: strict rate limits, smaller document size caps, and if the quota runs out mid-month, translations stop working until the 1st. For anything customer-facing, Pro or Growth is worth the cost.

Can I have multiple API keys on the free plan?¶

No - API Free supports one key per account. Multiple keys are only available on Growth (up to 10). If you need separate prod/staging/dev keys, you’ll need Growth or separate accounts (the latter technically violates DeepL’s ToS).