DeepL

Translate text between languages using DeepL

Overview

DeepL is a neural machine translation service known for high-quality translations. This tool translates text between languages using the DeepL API. It supports both the Pro and Free API plans (which use different base URLs), automatic source language detection, formality control, sentence splitting options, and formatting preservation. The tool processes one translation per input item and returns the translated text along with the detected source language.

Category: Utility
Tool Name: deepl
Version: 1

Appearance: Icon: si-deepl | Color: #0F2B46

Node Type

Action — processes input items and produces output

Input / Output

Direction	Port(s)
Input	Input
Output	Output, Error

Credentials

This tool requires DeepL API credentials. See the Credentials Guide for setup instructions.

Resources

Resource	Value
Language	language

Operations

Operation	Value	Description
Translate	translate	Translate text to another language

Parameters

Parameter	Type	Required	Default	Description
Text	string	Yes	—	Input text to translate. Supports expressions like {{ $json.body }}. (shown when Operation is translate)
Target Language	string	Yes	—	Target language code (e.g., “DE” for German, “FR” for French, “ES” for Spanish, “EN-GB” for British English, “EN-US” for American English, “JA” for Japanese, “ZH” for Chinese). See DeepL API docs for the full list of supported language codes. Supports expressions. (shown when Operation is translate)
Additional Fields	collection	No	{}	Optional settings that refine how DeepL translates. Supports expressions inside its fields. (shown when Operation is translate)
— Source Language	string	No	—	Source language code (e.g., “EN”, “DE”, “FR”). Leave empty for automatic detection. Note: “EN-GB” and “EN-US” are automatically normalized to “EN” for the source language.
— Split Sentences	options	No	1	How the translation engine should split sentences.
				Options: nonewlines (split on interpunction only, ignoring newlines), 0 (treat all text as a single sentence), 1 (split on interpunction and newlines)
— Preserve Formatting	options	No	0	Whether the translation engine should respect the original formatting, even if it would usually correct some aspects.
				Options: 0 (apply corrections — fix punctuation at the beginning and end of sentences and fix lower/upper casing at the beginning), 1 (do not correct — keep text as similar as possible to the original)
— Formality	options	No	default	How formal or informal the target text should be. May not be supported with all languages.
				Options: more (formal), less (informal), default (neutral)
Max Concurrency	number	No	10	Maximum number of items to process concurrently.

Output Data

One output item per input item. DeepL returns one translation per request, and that translation object is merged into the item JSON at the top level — the incoming fields stay addressable alongside it, and binary data is forwarded.

The merged object carries the translated text and the source language DeepL detected for it, so a downstream node reads the translation straight off the item rather than from a nested wrapper. Because the merge happens at the top level, an incoming field with the same name as one of DeepL’s response keys is overwritten; rename such fields upstream if you need to keep both.

Setting Formality to default sends no formality preference at all, which is why some languages accept it while rejecting more/less.

Usage Examples

• Translate English text to German
• Translate a document to French with formal tone
• Auto-detect source language and translate to Spanish
• Translate text preserving original formatting

Example Configuration

Translate a field into German and let DeepL detect the source language:

{
  "type": "deepl",
  "parameters": {
    "resource": "language",
    "operation": "translate",
    "text": "{{ $json.message }}",
    "translateTo": "DE"
  }
}

Translate customer correspondence formally, keeping the original formatting:

{
  "type": "deepl",
  "parameters": {
    "resource": "language",
    "operation": "translate",
    "text": "{{ $json.emailBody }}",
    "translateTo": "DE",
    "additionalFields": {
      "sourceLang": "EN",
      "preserveFormatting": "1",
      "formality": "more"
    }
  }
}

Translate casual copy into French with an informal register:

{
  "type": "deepl",
  "parameters": {
    "resource": "language",
    "operation": "translate",
    "text": "{{ $json.caption }}",
    "translateTo": "FR",
    "additionalFields": {
      "formality": "less",
      "splitSentences": "nonewlines"
    },
    "maxConcurrency": 5
  }
}

Error Handling

Mode	Behavior
stop	Halts workflow on first error
continue	Skips failed items, passes successful ones through
errorPort	Routes failed items to Error output port

Tips

Translate text between languages using the DeepL neural translation API, with options for formality, sentence splitting, and formatting preservation.

• Free and Pro plans use different endpoints. The plan recorded on the credential decides which one the node calls, so a key from the wrong plan fails to authenticate even when it is valid.
• Leave Source Language empty to auto-detect. Set it only when you already know the language and want to rule out a misdetection.
• Regional English is a target-only distinction. EN-GB and EN-US are valid targets, but as a source language both are normalized to EN.
• Additional Fields is a collection. Its fields nest under the additionalFields key rather than sitting at the top level of the parameters object.