What looks wrong?

We say this article was researched and checked. If it is wrong, we want the counter-example.

Skip to content
Petra Vlk

Nov 18, 202614 min read

DeepL automation means sending text to DeepL's API, directly or through a connector built on it (a workflow tool such as Activepieces can play that role), so translation runs without anyone pasting into the translator.

Done in under an hour, it leaves you with a working, repeatable translation step.

A DeepL translation workflow is a repeatable process in which your own systems, such as a script, app or no-code connector, authenticate with a DeepL API key, send text to the correct API endpoint for your plan, and receive the translation back automatically, within the API's documented limits.

Last checked 18 November 2026.

Set up DeepL automation quickly

Why automate DeepL

Of the blind-test groups DeepL reports, it won 66 and didn't win 8, so you're automating the engine that wins roughly nine comparisons in ten by its own count.

It's vendor-sourced, so treat it as a reason to test, not proof.

According to DeepL's analysis, evaluators preferred its output 2.3 times more often than Microsoft's, 1.7 times more than ChatGPT-4's (the version tested at the time) and 1.3 times more than Google's. The narrowest margin is Google, so if you already use Google, run your own sample before switching.

How much more often DeepL wins blind tests than rivals

Choose between DeepL API, built-in tools, and connectors

If you want the direct route, use the API: your code posts text and receives a translation. Built-in features, meaning the desktop app, browser extension and Word add-in, are still manual, one document at a time.

No-code connectors call the API for you from a trigger you configure, and Activepieces is one of them, with 750 integrations counted from its open source monorepo and an MIT-licensed core, so you likely won't need to build custom integrations for most workflows.

Activepieces workflow builder with HTTP request step selected and its settings panel open showing method, URL, headers, and…

Pick by how often the job repeats.

Route Setup time Code needed Best fit
DeepL API Under an hour Yes, one HTTP call Translation inside your own product or pipeline
Built-in features (app, browser, Word add-in) Minutes None One-off documents and individual users
No-code connectors Under an hour None Moving text between tools on a trigger

You need a plan that includes API access, an authentication key from your account, and the endpoint that matches that plan. A mismatch between key and endpoint is the usual cause of a failed first call, so the next section starts there.

This takes minutes, not a project: automate it in Activepieces free.

Stage 1: Get a DeepL API key and pick the endpoint

A DeepL key only works against the host that matches its plan: keys ending in :fx go to api-free.deepl.com, and every other key goes to api.deepl.com.

Create the account and copy the key

Sign up for DeepL API Free or API Pro, which are separate from a translator subscription, then open the account's API keys tab and copy the key.

Free allows 500,000 characters a month, so a 40-page manual can use the whole allowance before the month is half over.

$25 per million characters is the Pro rate, against $20 for Google, $15 for Amazon and $10 for Microsoft in the same comparison. You pay the highest per-character rate of the four, and the case for it is output quality, not price.

What translation APIs charge per million characters

DeepL API Free vs Pro base URL

API Free (Developer) API Pro (Growth)
Key suffix :fx none
Endpoint host api-free.deepl.com api.deepl.com
Monthly price $0 €4.99 base
Character allowance 500,000 pay as you go
Overage rate none; requests are refused at the cap $25 per million

On Free, hitting the cap means refused requests, not a bill. Pro keeps translating and bills the overage.

Call /v2/usage before you build anything else. It costs no characters and shows whether the key and host agree:

curl -H "Authorization: DeepL-Auth-Key YOUR_KEY:fx" \
 https://api-free.deepl.com/v2/usage

When the call works, it returns JSON with character_count and character_limit. A 403 means the key and host don't match. Swap the host, not the key.

Stage 2: Translate text with one API call

To translate text, you send a single authenticated POST to /v2/translate carrying text and target_lang, and the translation comes back in the JSON.

  1. Set the header Authorization: DeepL-Auth-Key YOUR_KEY.
  2. POST to /v2/translate on the host that matches your key: api-free.deepl.com for a Free key, api.deepl.com for a Pro key.
  3. Send text and target_lang.
  4. Optionally add source_lang, formality or tag_handling.
  5. Read translations[0].text from the response.
curl -X POST https://api-free.deepl.com/v2/translate \
 -H "Authorization: DeepL-Auth-Key YOUR_KEY" \
 -d "text=The invoice is overdue." \
 -d "target_lang=DE"
{"translations":[{"detected_source_language":"EN","text":"Die Rechnung ist überfällig."}]}

DeepL translate parameters worth setting

Leave source_lang off and DeepL detects the language, which is fine for clean prose and risky for short strings like product names. Set it when you know it.

Use formality where the target language distinguishes polite from casual address; on languages without the distinction the request can fail instead of being ignored, so check the response.

Set tag_handling to xml or html when the text carries markup, or the tags get translated as words. Pass glossary_id to pin terminology you created earlier.

Write codes in uppercase. Target codes for English and Portuguese have regional variants (EN-GB, EN-US, PT-BR, PT-PT); use them, because the bare form leaves the variant to DeepL.

Source codes take no regional suffix, so DeepL rejects EN-US sent as source_lang. Check the supported-languages list before shipping a language you haven't tested.

Stage 3: Translate documents and add a glossary

Translating a file takes one upload, a polling loop and one download. The target language must already have passed the supported-languages check above, because a document job won't tell you the output reads badly.

Upload, poll, and download translated documents

You hand DeepL the file, wait, then collect the result, because DeepL translates documents asynchronously.

  1. Send the file to /v2/document as a multipart upload, with the target language set.
  2. Keep the document_id and document_key from the response. You need the key to download, and DeepL doesn't show it again, so a script that discards it has paid for a translation it can't retrieve.
  3. Poll the document's status endpoint until it reports done. Treat an error status as a failed job and stop the loop, rather than polling forever.
  4. Download the translated file using the id and key.

A document file going into a slot on a translation machine, with a document_id ticket and a separate document_key key lying…

Before running a batch, read DeepL's documentation for the accepted file types, the size cap per file and how DeepL bills document translation. Catch an oversized or unsupported file on one test document, not halfway through a folder.

Once the loop works, terminology still follows DeepL's defaults. A glossary fixes that.

Create and apply a DeepL glossary

You create a glossary once, through the glossary endpoint, as a stored list of source-and-target term pairs for one language pair, and the response gives you a glossary_id. Keep that id with your configuration, not in the code of a single job.

DeepL's own blind-test record across language pairs

Then pass glossary_id on the translation request, along with the source and target languages the glossary was built for.

A mismatch between the glossary's language pair and the request is the usual reason a glossary appears to be ignored, so check that first when a product name still comes back translated.

A stencil on a shelf unused beside a wall painted with an altered name

You are done when the downloaded file is in the target language and your listed terms appear exactly as you defined them.

You can follow the rest of this with the builder open. Start free, no card.

Automate DeepL translation across your other apps

To retire the copy-paste step, a no-code flow is enough.

It watches for a new row, form entry or ticket, sends the text to DeepL with the same key you already use, and writes the translation back; it should still check that your glossary terms survive.

Zapier, Make, Activepieces or a script

Pick on two things: how much setup you'll tolerate, and what happens when DeepL says no.

Option Setup effort Error handling
Zapier Lowest. Pick a trigger, pick the DeepL action, paste the key. Failed runs are logged and can be replayed, but the retry behavior is the tool's, not yours.
Make Moderate. You wire modules on a canvas and map fields by hand. Per-module error routes let you branch on a failure instead of stopping the whole run.
Activepieces Moderate. Same trigger-and-action model, with a DeepL action among its 750 integrations. Every run leaves a trace you can read step by step, and the free plan allows unlimited flows.
A script Highest. You write the request, the loop and the scheduler. Complete control. You also own every retry, delay and log line.

Expect the documented limits to be what breaks these flows: a rate-limit response, a quota that runs out mid-month, a text too large for one request.

When a connector treats any error as "stop", rows stay untranslated and nobody is told. So read how each tool reports a failed step before you trust it, and send those failures somewhere a person will see them.

An untouched tray of papers beside a muffled bell

If nobody on your team wants to maintain code, choose a connector. The rest of this section builds the flow in Activepieces, where the free plan includes unlimited flows.

If you'd rather not wire the trigger by hand, Activepieces has a built-in chat: describe the job, for example "find rows with an empty translation column, send them to DeepL, write the result back", and what it publishes is a live flow in your account, the same flow you would have assembled by hand.

The DeepL action it uses is one of the 750 integrations counted from the open source monorepo, whose core is MIT-licensed, so the platform integrates with hundreds of other services.

The flow runs under the same RBAC and audit logs as any other flow, and its run trace lists what happened at each step, which is where a failed row gets noticed. MoneyGram, Moneypenny, Alan and FundingSocieties run Activepieces in production.

Activepieces flow builder showing a piece selector modal with spreadsheet integration options and a Schedule trigger step.

Build the workflow: trigger, translate, write back

In the screenshot, the builder shows a schedule trigger set to run every hour selected.

The spreadsheet integrations are listed in the picker, and a successful sample-data test is in the settings panel.

That passing test matters: it proves the trigger returns real rows before you spend any translation quota on them.

  1. Add the Schedule trigger, set the interval, and decide whether it runs on weekends. Run the sample-data test.
  2. Add the spreadsheet integration and choose Find Rows, filtering for rows whose translation column is empty.
  3. Add the DeepL action. Paste the same API key and choose the target language from your source column.
  4. Add Update Row, mapping DeepL's output into the empty translation column.
  5. Publish, then check one row against your glossary terms.

Filtering on the empty column keeps the flow from translating the same row twice.

Handle API limits and error codes

DeepL API error codes and fixes

When the allowance runs out on a capped plan, the API stops returning translations and starts returning one of six status codes, each with a usual cause and a fix.

Code Meaning Cause Fix
403 Forbidden Wrong key, or a key sent to the wrong endpoint Check that the key matches its plan's endpoint, free or paid
456 Quota exceeded Monthly character allowance used up on a capped plan Wait for the reset, raise the plan, or stop duplicate translations
429 Too many requests Calls arriving faster than the account allows Slow the loop and retry with growing delays
413 Payload too large Request body over the size cap Split the batch into smaller requests
400 Bad request Malformed parameter, unsupported language code, or empty text Read the error message and correct the field it names
503 Service unavailable Temporary fault on DeepL's side Retry later; do not treat it as a bug in your flow

Retry 429 and 503, because they pass on their own. Don't retry 403, 456, 413 or 400 unchanged, because the same request will fail the same way every time.

DeepL API request size and quota limits

Two ceilings sit on each request: a cap on total body size and a cap on how many texts you may send at once.

Exceed either and you get 413 or 400, so a flow that works on ten rows can fail on a full sheet.

Separate from the request limits, the quota is counted in characters and resets monthly. A flow can be perfectly sized and still hit 456 midway through the month. Check your usage figure in the account page before you schedule a large backlog.

  1. Confirm the key belongs to the plan you're paying for and points at that plan's endpoint.
  2. Check remaining characters against the week's expected volume.
  3. Split any batch near the body or text-count caps.
  4. Add retries with delays for 429 and 503 only.
  5. Alert on 456 and 403, since neither fixes itself.

Frequently asked questions

You just checked the usage figure, and it is also the quickest answer to the first question people ask.

Is DeepL automation free? Yes, up to a cap. The Free API plan lets you build and test a workflow without paying, but it stops at a monthly character allowance.

A backlog bigger than that allowance will halt mid-run with a quota error, not slow down. Keep Free for prototypes, and move to a paid API plan before anything runs unattended.

Can I use a Translator Pro login for the API? No. A Translator Pro subscription covers the web and app translator. API access is a separate plan with its own authentication key.

Your password won't work in a connector, and a Pro subscription doesn't give you API credits. Create the key from the API plan's account page and paste that.

Does DeepL store text sent through the API?

It depends on the plan. DeepL's paid API plans are documented as not retaining submitted text for training. The Free plan has different terms, and its text can be used to improve the service.

If the content is confidential, read the data terms for your plan before you send anything, and choose the paid plan if the terms for Free don't fit.

Which languages can the API translate?

Fewer than the web translator lists in some cases, and the set changes. The API has a languages endpoint that returns what your key can use as source and target. Query it instead of hard-coding a list.

The formality setting, which switches between formal and informal address, only works for some target languages. Where it's unsupported, the request can fail instead of being ignored, so check the response before you rely on it.

Can I automate DeepL Write too? Yes, there is a separate Write API for rewriting and improving text in the same language.

It's a different endpoint from translation, and its language coverage is narrower. Treat it as its own integration: confirm your plan includes it, then test with a short sample before wiring it into a pipeline.

Share

Build it

Set this up in minutes.

No code required. Connect your accounts, and Activepieces runs it from there.

Start free Talk to sales