Menu
Mattering Automations connector

A DeepL MCP for translation that runs inside your workflows

Connect one API key and DeepL becomes a workflow step: translate text and HTML with glossaries and formality control, rephrase and correct with DeepL Write, translate whole documents, and manage multilingual glossaries. Free and Pro keys both work, the connector reads the key and routes to the right DeepL server automatically, and results land next to your tasks and databases instead of in a browser tab.

18 ready-made nodes One credential to connect Works with Claude, ChatGPT, and Matter

What the DeepL MCP connector does

The DeepL connector for Mattering Automations is 18 nodes across the DeepL API: text translation with context, formality, model selection, and glossary support, a tag-handling variant that translates HTML and XML without breaking the markup, DeepL Write for rephrasing and grammar correction, asynchronous document translation for docx, pptx, xlsx, pdf, html, txt, xliff, srt, and more, v3 multilingual glossaries, the language rosters that drive every language picker, and a usage gauge for the account's character quota. One API key authenticates all of it: DeepL Free keys end in :fx and belong to api-free.deepl.com, Pro keys belong to api.deepl.com, and the connector reads the key and picks the right server per request, so you never configure a host.

Every node speaks MCP, the open protocol for connecting AI assistants to tools, so Claude, ChatGPT, and any MCP-capable assistant can use them, alongside Matter, the AI assistant built into the platform. An agent can list your glossaries, translate a customer message with the right terminology locked in, read the detected source language, and file the result, without anyone pasting text into a translator.

DeepL publishes its own official MCP server, deepl-mcp-server, documented on developers.deepl.com, and it is good at what it is for: giving an assistant a direct line to DeepL. This connector is for the other half of the job, where translation is one step among many. On the Mattering canvas the same nodes sit next to every other connector and the platform itself, so a CMS webhook can translate a page and open a review task, a support workflow can translate inbound messages and route them, and translated documents can land in a Mattering database next to the rest of the work. Use whichever fits, or both.

The safety modeling is stated plainly. Of the 18 nodes, ten read and eight act, and exactly one is flagged destructive: DeepL: Delete Glossary, which permanently removes a glossary and breaks translations that reference its id. Two more honesty notes are carried on the nodes themselves: every translation, Write, and document call bills characters against the account quota, so workflows treat those calls as spend rather than free reads, and the document download is single use, because DeepL deletes the finished document from its servers after one successful download. DeepL's admin-only analytics API is deliberately not shipped.

One connection, three surfaces

  • Visual automations. Drag DeepL nodes onto the canvas and wire them to triggers, conditions, and other apps.
  • AI agents, yours or ours. These nodes speak MCP, the open protocol, so Claude, ChatGPT, and any MCP-capable assistant can use them, and Matter, the agent built into the platform, uses them natively.
  • The whole platform. Combine with native tasks, projects, and other connectors, no middleware in between.

Every DeepL node, ready to drop on the canvas

18 nodes, generated from the connector itself so this list always matches what ships. Expand a category to browse.

Read and query nodes 10

DeepL: Download Translated Document

Download the translated document as base64 (data.file_base64, up to about 5 MB). SINGLE-USE: DeepL deletes the document from its servers after one successful download and the document_id 404s afterwards - store the result downstream in the same run. Wait for status done first; downloading earlier returns 503. Re-uploading the source document repeats the process if the result is lost.

DeepL: Get Document Status

Poll a document translation: status is queued, translating (with seconds_remaining), done (with billed_characters), or error (with a message). A pure status read - the POST method only carries the document_key.

DeepL: Get Glossary

Fetch one glossary's metadata: name, its dictionaries (language pairs with entry counts), and creation time. Entries themselves come from DeepL: Get Glossary Entries.

DeepL: Get Glossary Entries

Read one dictionary's entries from a glossary as tab-separated text (data.dictionaries[0].entries). The natural backup step before Edit or Delete Glossary.

DeepL: Get Usage

Read the account's usage for the CURRENT billing period: characters translated so far and the character limit (near-real-time). Pro keys additionally report per-key counters, per-product breakdowns, and the period's start and end times. Works with every valid key, so this is the credential health check to run first in any DeepL automation. A snapshot gauge, not a windowed report.

DeepL: List Glossaries

List the account's glossaries with their IDs, names, and per-language-pair dictionaries (entry counts included). The glossary_id from here feeds the translate, document, and glossary nodes.

DeepL: List Glossary Language Pairs

List the source/target language pairs glossaries support. Feeds the glossary nodes' language pickers. (DeepL marks this v2 path deprecated in favor of /v3/languages?resource=glossary, but only this one returns explicit PAIRS.)

DeepL: List Languages by Resource

The current (v3) language roster for a specific DeepL capability: translate_text, translate_document, glossary, write, and others. Each row carries usable_as_source / usable_as_target flags, stability status, and per-feature support (formality, tag handling, glossary). Returns a bare array (data[].lang / data[].name).

DeepL: List Source Languages

List the languages DeepL can translate FROM, as code plus English name. Returns a bare array, so rows sit at data[].language / data[].name. Feeds the source_lang pickers across the translate and document nodes.

DeepL: List Target Languages

List the languages DeepL can translate INTO, each with whether it supports the formality option. Returns a bare array (data[].language / data[].name / data[].supports_formality). Feeds the target_lang pickers.

Action nodes 8

DeepL: Correct Text

Fix spelling and grammar with DeepL Write, changing as little as possible - no rephrasing, no style changes (use DeepL: Rephrase Text for those). DeepL docs state Write is not yet available on API Free plans and requires a DeepL API Pro subscription, so free (:fx) keys get a permission error here. Bills characters against the account quota.

DeepL: Create Glossary

Create a glossary with one dictionary (a source/target language pair plus its entries). DeepL v3 glossaries are multilingual: add further language pairs later with DeepL: Edit Glossary, or via Extra body fields. Reversible with DeepL: Delete Glossary. Glossaries cap at 10 MiB.

DeepL: Delete Glossary

DESTRUCTIVE: delete a glossary and every dictionary in it, permanently. Translations referencing its glossary_id start failing. Export the entries first with DeepL: Get Glossary Entries if there is any doubt.

DeepL: Edit Glossary

Rename a glossary and/or REPLACE one dictionary: providing source_lang, target_lang, and entries overwrites that language pair's entire entry set (or adds the pair if new). Fill only the name to rename without touching entries. Fetch the current entries first with DeepL: Get Glossary Entries if you need to merge rather than replace.

DeepL: Rephrase Text

Improve text WITHIN its own language with DeepL Write: rephrase for clarity, apply a writing style, or adjust the tone. Bills characters against the account quota. DeepL's docs state Write is not yet available on API Free plans and requires a DeepL API Pro subscription, so free (:fx) keys get a permission error here. Request body up to 10 KiB.

DeepL: Translate Tagged Text

Translate HTML or XML content while keeping the markup intact: same /v2/translate endpoint as DeepL: Translate Text, with the tag-handling controls exposed. Bills characters against the account quota. The classic use is translating CMS page fragments or product HTML without breaking the tags.

DeepL: Translate Text

Translate text into a target language, with optional context, formality, glossary, and model selection. A stateless call that creates nothing server-side but bills characters against the account quota. Plain UTF-8 text up to 128 KiB per request; for HTML or XML content use DeepL: Translate Tagged Text instead.

DeepL: Upload Document

Upload a document for translation: the runner downloads the file from the URL you provide and sends the bytes to DeepL. Supported formats include docx, pptx, xlsx, pdf, html, txt, xliff, srt, and more. Asynchronous: the response returns a document_id and document_key - poll DeepL: Get Document Status, then fetch DeepL: Download Translated Document. Bills the document's characters against the account quota once translation starts.

Connecting DeepL takes one credential

DeepL authenticates every request with an API key sent in an Authorization header using DeepL's own DeepL-Auth-Key scheme rather than a Bearer token; the connector formats the header for you. Keys live on the API keys page of your DeepL account at deepl.com/your-account/keys and come with either API plan: DeepL API Free keys always end in :fx and are served by api-free.deepl.com, while API Pro keys are served by api.deepl.com. The connector reads the key's suffix and picks the correct server per request, so one credential works for both plans and there is nothing to configure. DeepL's API plans are separate from its translator app subscriptions, so an API key comes from an API Free or API Pro plan specifically.

1

Sign up for a DeepL API plan at deepl.com/pro-api if you do not have one. API Free covers everything here except the two DeepL Write nodes: DeepL documents Write as not yet available on API Free plans and requiring an API Pro subscription.

2

Sign in to your DeepL account, open the API keys page at deepl.com/your-account/keys, and copy a key, or create a new key for the automation so it can be rotated independently.

3

In Mattering Automations, open Connectors, click Add Connector, choose DeepL, and create a credential with the API key.

4

Click Test Connection. Mattering calls DeepL's usage endpoint on the server your key belongs to: success returns the current billing period's character counters and proves the credential, an error means the key is mistyped or deactivated.

5

All 18 DeepL nodes appear in the canvas palette. Run DeepL: List Source Languages and DeepL: List Target Languages first; they return the language rosters that populate the pickers on every translate and document node.

Common uses for the DeepL MCP

Translate CMS content without breaking the markup

DeepL: Translate Tagged Text takes HTML or XML and returns it translated with the tags intact, which is the classic localization automation: a publish webhook carries the page fragment in, the node translates it with tag_handling set to html, and the workflow writes the result back or files it for review. For XML there are finer controls: splitting_tags and non_splitting_tags steer sentence splitting, and ignore_tags leaves content like code samples untranslated.

An AI agent that translates with your terminology locked in

DeepL: List Glossaries shows an agent the account's glossaries with their ids and language pairs, and passing a glossary_id into DeepL: Translate Text keeps product names and house terms consistent across every translation. One rule the nodes state up front: using a glossary requires source_lang to be set on the request, so the agent picks the source language instead of relying on auto-detect. The formality field adds another control, with prefer_more and prefer_less falling back gracefully for languages without formality support.

Whole-document translation as a pipeline

DeepL: Upload Document takes a file URL, downloads it (up to 20 MB), and sends the bytes to DeepL; supported formats include docx, pptx, xlsx, pdf, html, txt, xliff, and srt. Translation is asynchronous: the workflow polls DeepL: Get Document Status until it reports done, then fetches DeepL: Download Translated Document. The download is single use, DeepL deletes the document from its servers after one successful fetch, so the workflow stores the base64 result downstream in the same run.

Grammar and style passes with DeepL Write

DeepL: Correct Text fixes spelling and grammar while changing as little as possible, which suits outbound emails and support replies that should stay in the author's voice. DeepL: Rephrase Text goes further, rewriting for clarity or applying a writing style or tone such as business or friendly. DeepL documents Write as not yet available on API Free plans and requiring an API Pro subscription, so plan both Write nodes around a Pro key. Both stay within the text's own language: Write improves, it does not translate.

Multilingual support and comms flows

An inbound message in any language becomes readable in one step: DeepL: Translate Text auto-detects the source language when source_lang is blank and reports what it detected, so the workflow can translate the reply back into the same language afterwards. The context field passes surrounding text that shapes the translation without being translated itself, which is exactly what a support thread provides.

Glossary maintenance as a governed workflow

Terminology can live in a Mattering database and flow into DeepL on a schedule: DeepL: Create Glossary builds a glossary from tab-separated term pairs, and DeepL: Edit Glossary replaces a language pair's entries or adds a new pair, since v3 glossaries are multilingual. The safe habit is built in as nodes: DeepL: Get Glossary Entries exports a dictionary's entries before an edit overwrites them, and DeepL: Delete Glossary is flagged destructive because deletion is permanent and translations referencing the id start failing.

Example: A page publishes: check quota, translate the HTML with your glossary, file it for review

Built on the Automations canvas in a few minutes, or described in plain language to Matter and built for you.

1

Trigger: an inbound webhook from your CMS fires when a page publishes, carrying the page HTML, its path, and the target language.

2

DeepL: Get Usage reads the billing period's character_count and character_limit, so the workflow can stop early and alert instead of failing mid-run when the quota is nearly spent.

3

DeepL: List Glossaries finds the brand glossary's glossary_id by name.

4

DeepL: Translate Tagged Text translates the HTML with tag_handling set to html, the glossary applied, and source_lang set, returning the translated markup with every tag intact.

5

The workflow writes the translated HTML into a Mattering database keyed by page path and language.

6

A review task opens in Mattering Productivity with the translation and its detected source language attached, so a person signs off before the page goes live.

DeepL MCP questions, answered

What DeepL operations are supported?

18 nodes: 10 query nodes and 8 action nodes covering text translation (a plain node and a tag-handling variant for HTML and XML, both on DeepL's /v2/translate endpoint), DeepL Write rephrasing and grammar correction, document translation (upload, status polling, single-use download), v3 multilingual glossaries (list, get, create, edit, delete, and entries export), the language listers that drive the pickers, and account usage. Deliberately not shipped: DeepL's admin-only analytics API, and the older v2 glossary endpoints that DeepL's docs supersede with v3. There are no trigger nodes because the DeepL API does not push events; document translation is polled instead.

Does this work with Claude, ChatGPT, or other AI assistants?

Yes. Mattering exposes these nodes over MCP, an open protocol for connecting AI assistants to tools, so any MCP-capable assistant, including Claude and ChatGPT, can connect to your workspace and use them. Matter, the assistant built into the platform, uses the same nodes natively.

DeepL publishes an official MCP server. Why use this connector?

DeepL does maintain deepl-mcp-server, documented on developers.deepl.com, and if all you want is an assistant talking to DeepL alone, it is a genuine option. This connector earns its place when translation is one step in a larger workflow: the same canvas holds your other connectors and the Mattering platform itself, so a publish webhook can translate a page and then open a review task, a translated document can land in a Mattering database, and a glossary edit can wait behind a backup step. Credentials live in one place with the rest of your connector secrets, and the same nodes serve visual automations and AI agents alike. Use whichever fits, or both.

Do DeepL API Free keys work?

Yes. Free keys, which always end in :fx, are fully supported: the connector detects the suffix and sends their requests to api-free.deepl.com, DeepL's server for Free keys, while Pro keys go to api.deepl.com. The exception is DeepL Write: DeepL's docs state Write is not yet available on API Free plans and requires an API Pro subscription, so a Free key gets a permission error on DeepL: Rephrase Text and DeepL: Correct Text. Every other node works on a Free key.

How is usage billed against my account?

DeepL meters the API in characters against your plan's quota, and every translation, Write, and document call is billed that way; the nodes say so in their descriptions instead of presenting translation as a free read. DeepL: Get Usage reports the live counters for the current billing period, characters used and the limit, so workflows can check headroom before a large run. Two details worth knowing: the context field on text translation influences the result without being billed, and setting show_billed_characters on DeepL: Translate Text returns the billed count per translation in the response.

Can an automation translate whole documents?

Yes, asynchronously. DeepL: Upload Document takes a file URL, downloads it (up to 20 MB), and submits it; supported formats include docx, pptx, xlsx, pdf, html, txt, xliff, and srt. The upload returns a document_id and a document_key, and both are needed downstream: DeepL: Get Document Status polls until translation is done, then DeepL: Download Translated Document fetches the result as base64, up to about 5 MB. The download is single use because DeepL deletes the document from its servers after one successful fetch, so store the result in the same run; if it is lost, re-uploading the source repeats the process.

How do glossaries work?

The connector builds on DeepL's v3 glossaries, the current surface DeepL's docs recommend over the older v2 endpoints. A v3 glossary is multilingual: it holds one or more dictionaries, each a source and target language pair with its own entries, provided as tab-separated or CSV term pairs, with the whole glossary capped at 10 MiB. DeepL: Create Glossary starts with one dictionary, DeepL: Edit Glossary adds a pair or replaces an existing pair's entries entirely, and DeepL: Get Glossary Entries exports a dictionary as text, the natural backup before an edit or delete. Applying a glossary to a translation requires source_lang to be set on the request, and DeepL: Delete Glossary is permanent, so it is flagged destructive.

What are DeepL's rate limits and quotas?

DeepL's primary meter is characters against your plan's quota rather than a published request-per-minute number, and DeepL: Get Usage reports where the account stands. When the quota is exhausted DeepL returns HTTP 456, its own status code for quota exceeded, and when requests arrive too quickly it returns 429 and expects the client to wait and resend. The nodes report these errors on their output rather than silently retrying, so add wait steps between bursts and prefer batching, text translation accepts up to 50 texts in one call, over many single-text requests.

18 nodes waiting on the canvas

Put DeepL to work inside your workspace

Connect once, then use every node in visual automations and AI agent workflows across the Mattering platform.

All product names, logos, and brands are property of their respective owners and are used for identification purposes only. Use of these names, logos, and brands does not imply endorsement or affiliation. DeepL is a product of its respective owner; Mattering is an independent platform.

Start Free Explore our Products