> ## Documentation Index
> Fetch the complete documentation index at: https://developers.deepl.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Translate Text

> API reference for translating text with the DeepL API.

The text-translation API currently consists of a single endpoint, `translate`, which is described below.

For highest translation quality, we recommend using our next-gen models. For details, please see [here](/api-reference/translate#about-the-model_type-parameter).

To learn more about context in DeepL API translations, see our [context parameter guide](/docs/learning-how-tos/examples-and-guides/how-to-use-context-parameter).

For more detail about request body parameters, see the [Request Body Descriptions](/api-reference/translate#request-body-descriptions) section further down on the page.

See [Translation memories](/docs/learning-how-tos/examples-and-guides/how-to-use-translation-memories) for a guide on using translation memories in your translations.

We also provide a spec that is auto-generated from DeepL's OpenAPI file. [You can find it here](/api-reference/translate/request-translation).

<Info>
  The total request body size for text translation requests must not exceed 128 KiB (128 · 1024 bytes). Please split up your text into multiple calls if it exceeds this limit.
</Info>

<Tabs>
  <Tab title="cURL">
    The examples below use our API Pro endpoint `https://api.deepl.com`. If you're an API Free user, remember to update your requests to use `https://api-free.deepl.com` instead.

    ```sh Example request: text translation (without glossary) theme={null}
    curl -X POST 'https://api.deepl.com/v2/translate' \
    --header 'Authorization: DeepL-Auth-Key [yourAuthKey]' \
    --header 'Content-Type: application/json' \
    --data '{
      "text": [
        "Hello, world!"
      ],
      "target_lang": "DE"
    }'
    ```

    ```sh Example request: text translation (with glossary) theme={null}
    curl -X POST 'https://api.deepl.com/v2/translate' \
    --header 'Authorization: DeepL-Auth-Key [yourAuthKey]' \
    --header 'Content-Type: application/json' \
    --data '{
      "text": [
        "Hello, world!"
      ],
      "target_lang": "DE",
      "source_lang": "EN",
      "glossary_id": "[yourGlossaryId]"
    }'
    ```

    ```json Example response theme={null}
    {
      "translations": [
        {
          "detected_source_language": "EN",
          "text": "Hallo, Welt!"
        }
      ]
    }
    ```
  </Tab>

  <Tab title="HTTP Request">
    The examples below use our API Pro endpoint `https://api.deepl.com`. If you're an API Free user, remember to update your requests to use `https://api-free.deepl.com` instead.

    ```http Example request: text translation (without glossary) theme={null}
    POST /v2/translate HTTP/2
    Host: api.deepl.com
    Authorization: DeepL-Auth-Key [yourAuthKey]
    User-Agent: YourApp/1.2.3
    Content-Length: 45
    Content-Type: application/json

    {"text":["Hello, world!"],"target_lang":"DE"}
    ```

    ```http Example request: text translation (with glossary) theme={null}
    POST /v2/translate HTTP/2
    Host: api.deepl.com
    Authorization: DeepL-Auth-Key [yourAuthKey]
    User-Agent: YourApp/1.2.3
    Content-Length: 97
    Content-Type: application/json

    {"text":["Hello, world!"],"target_lang":"DE","source_lang":"EN","glossary_id":"[yourGlossaryId]"}
    ```

    ```json Example response theme={null}
    {
      "translations": [
        {
          "detected_source_language": "EN",
          "text": "Hallo, Welt!"
        }
      ]
    }
    ```
  </Tab>

  <Tab title="Python">
    ```py Example request: text translation (without glossary) theme={null}
    import deepl

    auth_key = "f63c02c5-f056-..."  # Replace with your key
    deepl_client = deepl.DeepLClient(auth_key)

    result = deepl_client.translate_text("Hello, world!", target_lang="FR")
    print(result.text)  # "Bonjour, le monde !"
    ```
  </Tab>

  <Tab title="PHP">
    ```php Example request: text translation (without glossary) theme={null}
    $authKey = "f63c02c5-f056-..."; // Replace with your key
    $deeplClient = new DeepL\DeepLClient($authKey);

    $result = $deeplClient->translateText('Hello, world!', null, 'fr');
    echo $result->text; // Bonjour, le monde!
    ```
  </Tab>

  <Tab title="C#">
    ```cs Example request: text translation (without glossary) theme={null}
    var authKey = "f63c02c5-f056-..."; // Replace with your key
    var deeplClient = new DeepLClient(authKey);

    // Translate text into a target language, in this case, French:
    var translatedText = await deeplClient.TranslateTextAsync(
          "Hello, world!",
          LanguageCode.English,
          LanguageCode.French);
    Console.WriteLine(translatedText); // "Bonjour, le monde !"
    // Note: printing or converting the result to a string uses the output text.
    ```
  </Tab>

  <Tab title="Node.js">
    ```javascript Example request: text translation (without glossary) theme={null}
    import * as deepl from 'deepl-node';

    const authKey = "f63c02c5-f056-..."; // Replace with your key
    const deeplClient = new deepl.DeepLClient(authKey);

    (async () => {
        const result = await deeplClient.translateText('Hello, world!', null, 'fr');
        console.log(result.text); // Bonjour, le monde !
    })();
    ```
  </Tab>

  <Tab title="Java">
    ```java Example request: text translation (without glossary) theme={null}
    import com.deepl.api.*;

    class Example {
        DeepLClient deeplClient;

        public Example() throws Exception {
            String authKey = "f63c02c5-f056-...";  // Replace with your key
            deeplClient = new DeepLClient(authKey);
            TextResult result =
                    deeplClient.translateText("Hello, world!", null, "fr");
            System.out.println(result.getText()); // "Bonjour, le monde !"
        }
    }
    ```
  </Tab>
</Tabs>

These examples are for demonstration purposes only. In production code, the authentication key should not be hard-coded but instead fetched from a configuration file or environment variable.

Note that we do not include examples for our client libraries in every single section of this reference, but our client libraries *do* support all use cases shown on this page.

<Info>
  Please note that the Translate API is intended to be used for translation between different languages, but requests with the same source and target language are still counted toward billing.

  If trying to convert between variants of the same language (e.g. `EN-US` to `EN-GB`), please refer to [this guide](/docs/learning-how-tos/examples-and-guides/translating-between-variants). Translating between variants of the same language will result in no change to the text.
</Info>

### Request Body Descriptions

<ParamField body="text" type="array[string]" required>
  Text to be translated. Only UTF-8-encoded plain text is supported. The parameter may be specified multiple times and translations are returned in the same order as they are requested. Each of the parameter values may contain multiple sentences. Up to 50 texts can be sent for translation in one request.

  <Warning>
    Each text in the array is translated independently — texts do not share context with each other. If one text provides context that would help translate another (e.g. a headline and its article body), either combine them into a single text or use the <a href="#request-body-descriptions"><code>context</code></a> parameter to provide shared context.
  </Warning>
</ParamField>

<ParamField body="source_lang" type="string">
  Language of the text to be translated. If omitted, the API will attempt to detect the language of the text and translate it. You can find supported source languages <a href="/docs/getting-started/supported-languages">here</a>.
</ParamField>

<ParamField body="target_lang" type="string" required>
  The language into which the text should be translated. You can find supported target languages <a href="/docs/getting-started/supported-languages">here</a>.
</ParamField>

<ParamField body="context" type="string">
  The <code>context</code> parameter makes it possible to include additional context that can influence a translation but is not translated itself. This additional context can potentially improve translation quality when translating short, low-context source texts such as product names on an e-commerce website, article headlines on a news website, or UI elements.

  <p>For example:</p>

  <ul>
    <li>When translating a product name, you might pass the product description as context.</li>
    <li>When translating a news article headline, you might pass the first few sentences or a summary of the article as context.</li>
  </ul>

  <p>For best results, we recommend sending a few complete sentences of context <strong>in the same language as the source text</strong>. There is no size limit for the <code>context</code> parameter itself, but the request body size limit of 128 KiB still applies to all text translation requests.</p>

  <p>If you send a request with multiple <code>text</code> parameters, the <code>context</code> parameter will be applied to each one.</p>

  <p>Characters included in the <code>context</code> parameter will not be counted toward billing (i.e., there is no additional cost for using the <code>context</code> parameter, and only characters sent in the <code>text</code> parameter(s) will be counted toward billing for text translation even when the <code>context</code> parameter is included in a request).</p>

  <p>See <a href="/docs/learning-how-tos/examples-and-guides/how-to-use-context-parameter">How to Use the Context Parameter Effectively</a> for examples and best practices.</p>
</ParamField>

<ParamField body="model_type" type="enum">
  Specifies which DeepL model should be used for translation.

  Possible values:

  * `latency_optimized`: Uses the lowest latency translation models available (usually classic models; default parameter value)
  * `quality_optimized`: Uses the highest quality translation models available (currently next-gen models)
  * `prefer_quality_optimized`: Same as `quality_optimized`, with fallback to classic models if no next-gen model is present (as of December 2025, all languages have next-gen models)

  When the `model_type` parameter is set, the response includes a `model_type_used` field indicating which model was used.

  <Warning>
    To ensure accurate automatic language detection, the API uses next-gen models for all requests that omit `source_lang`, regardless of `model_type`. If your source language is known, you can specify `source_lang` to allow classic models to be used where available for your language pair. See [supported languages](/docs/getting-started/supported-languages) for language-specific model availability.
  </Warning>

  <Info>
    [Tag handling v2](/docs/xml-and-html-handling/tag-handling-v2) is compatible only with next-gen models and implicitly sets
    `model_type` to `quality_optimized`. Setting both `model_type=latency_optimized` and `tag_handling_version=v2` will return an
    error.
  </Info>

  See [About the model\_type parameter](#about-the-model_type-parameter) for more details.
</ParamField>

<ParamField body="split_sentences" type="string">
  Sets whether the translation engine should first split the input into sentences. For text translations where <code>tag\_handling</code> is not set to <code>html</code>, the default value is <code>1</code>, meaning the engine splits on punctuation and on newlines.

  <p>For text translations where <code>tag\_handling=html</code>, the default value is <code>nonewlines</code>, meaning the engine splits on punctuation only, ignoring newlines.</p>

  <p>The use of <code>nonewlines</code> as the default value for text translations where <code>tag\_handling=html</code> is new behavior that was implemented in November 2022, when HTML handling was moved out of beta.</p>

  <p>Possible values are:</p>

  <ul>
    <li><code>0</code> - no splitting at all; whole input is treated as one sentence</li>
    <li><code>1</code> (default when <code>tag\_handling</code> is not set to <code>html</code>) - splits on punctuation and on newlines</li>
    <li><code>nonewlines</code> (default when <code>tag\_handling=html</code>) - splits on punctuation only, ignoring newlines</li>
  </ul>

  <p>For applications that send one sentence per text parameter, we recommend setting <code>split\_sentences</code> to <code>0</code>, in order to prevent the engine from splitting the sentence unintentionally.</p>

  <p>Please note that newlines will split sentences when <code>split\_sentences=1</code>. We recommend cleaning files so they don't contain breaking sentences or setting the parameter <code>split\_sentences</code> to <code>nonewlines</code>.</p>

  <p>Please note that this value will be ignored when using next-gen models (<code>model\_type\_used=quality\_optimized</code>) and a value of:</p>

  <ul>
    <li><code>0</code> will be used if <code>tag\_handling</code> is not enabled</li>
    <li><code>nonewlines</code> will be used if <code>tag\_handling</code> is enabled</li>
  </ul>

  <p>...as these settings yield the best quality.</p>
</ParamField>

<ParamField body="preserve_formatting" type="boolean">
  Sets whether the translation engine should respect the original formatting, even if it would usually correct some aspects.
  <p>The formatting aspects affected by this setting include:</p>

  <ul>
    <li>Punctuation at the beginning and end of the sentence</li>
    <li>Upper/lower case at the beginning of the sentence</li>
  </ul>

  <Info>
    Note: for requests sent as URL-encoded forms, boolean values should be specified as "1" or "0".
  </Info>
</ParamField>

<ParamField body="formality" type="string">
  Sets whether the translated text should lean towards formal or informal language. This feature currently only works for target languages <code>DE</code> (German), <code>FR</code> (French), <code>IT</code> (Italian), <code>ES</code> (Spanish), <code>ES-419</code> (Latin American Spanish), <code>NL</code> (Dutch), <code>PL</code> (Polish), <code>PT-BR</code> and <code>PT-PT</code> (Portuguese), <code>JA</code> (Japanese), and <code>RU</code> (Russian). Learn more about the <a href="https://support.deepl.com/hc/en-us/articles/6306700061852-About-formality-plain-and-polite-tones-in-Japanese">plain/polite feature for Japanese ↗️</a>. To check formality support dynamically, call <a href="/api-reference/languages/retrieve-supported-languages-by-resource"><code>GET /v3/languages?resource=translate\_text</code></a> and look for the <code>formality</code> feature key on the target language.

  <p>Setting this parameter with a target language that does not support formality will fail, unless one of the <code>prefer\_...</code> options are used. Possible options are:</p>

  <ul>
    <li><code>default</code> (default)</li>
    <li><code>more</code> - for a more formal language</li>
    <li><code>less</code> - for a more informal language</li>
    <li><code>prefer\_more</code> - for a more formal language if available, otherwise fallback to default formality</li>
    <li><code>prefer\_less</code> - for a more informal language if available, otherwise fallback to default formality</li>
  </ul>
</ParamField>

<ParamField body="glossary_id" type="string">
  Specify the glossary to use for the translation.

  <Note>
    <strong>Important:</strong> This requires the <code>source\_lang</code> parameter to be set and the language pair of the glossary has to match the language pair of the request.
  </Note>

  To check glossary support for a language pair, call <a href="/api-reference/languages/retrieve-supported-languages-by-resource"><code>GET /v3/languages?resource=translate\_text</code></a> and verify the <code>glossary</code> feature key is present on both the source and target language.
</ParamField>

<ParamField body="style_id" type="string">
  Specify the style rule list to use for the translation which can be used to customize translations according to the selected formatting and style conventions.

  <Info>
    The target language has to match the language of the style rule list.

    Additionally, any request with the `style_id` parameter enabled will default to use the `quality_optimized` model type. Requests combining `style_id` and `model_type: latency_optimized` will be rejected.
  </Info>
</ParamField>

<ParamField body="custom_instructions" type="array[string]">
  Specify a list of instructions to customize the translation behavior. Up to 10 custom instructions can be specified, each with a maximum of 300 characters.

  <Info>
    The target language must be `de`, `en`, `es`, `fr`, `it`, `ja`, `ko`, `zh` or any variants of these languages.

    Any request with the `custom_instructions` parameter enabled will default to use the `quality_optimized` model type. Requests combining `custom_instructions` and `model_type: latency_optimized` will be rejected. You can find best practices on how to write custom instructions [here](/docs/best-practices/custom-instructions).
  </Info>

  To check language support dynamically, call <a href="/api-reference/languages/retrieve-supported-languages-by-resource"><code>GET /v3/languages?resource=translate\_text</code></a> and check for the <code>style\_rules</code> feature key on the target language.
</ParamField>

<ParamField body="translation_memory_id" type="string">
  The [translation memory](/api-reference/translation-memory/list-translation-memories) to use for the translation. The value should be the UUID of a translation memory associated with your account.

  <Info>
    Requests with the `translation_memory_id` parameter must use the `quality_optimized` model type. Requests combining `translation_memory_id` and `model_type: latency_optimized` will be rejected.
  </Info>
</ParamField>

<ParamField body="translation_memory_threshold" type="integer">
  The minimum matching percentage required for a translation memory segment to be applied (recommended to be 75% or higher). Accepts values from 0 to 100. Default: `75`.
</ParamField>

<ParamField body="show_billed_characters" type="boolean">
  When <code>true</code>, the response will include an additional key-value pair with the key <code>billed\_characters</code> and a value that is an integer showing the number of characters from the request that will be counted by DeepL for billing purposes.

  <p>For example: <code>"billed\_characters": 42</code></p>

  <Info>
    At some point in the future, we intend to include <code>billed\_characters</code> in the API response by default, at which point it will be necessary to set <code>show\_billed\_characters</code> to <code>false</code> in order for an API response not to include <code>billed\_characters</code>. We will notify users in advance of making this change.

    For requests sent as URL-encoded forms, boolean values should be specified as "1" or "0".
  </Info>
</ParamField>

<ParamField body="tag_handling" type="string">
  Sets which kind of tags should be handled. Options currently available:

  <ul>
    <li><code>xml</code>: Enable XML tag handling; see <a href="/docs/xml-and-html-handling/xml">XML handling</a>.</li>
    <li><code>html</code>: Enable HTML tag handling; see <a href="/docs/xml-and-html-handling/html">HTML handling</a>.</li>
  </ul>

  To check tag handling support for a language pair, call <a href="/api-reference/languages/retrieve-supported-languages-by-resource"><code>GET /v3/languages?resource=translate\_text</code></a> and check the <code>tag\_handling</code> feature key is present on both the source and target language.
</ParamField>

<ParamField body="tag_handling_version" type="string">
  Select which version of the tag handling algorithm should be used. See <a href="/docs/xml-and-html-handling/tag-handling-v2">tag handling v2</a>.

  <ul>
    <li><code>v2</code>: Use the improved v2 algorithm.</li>
    <li><code>v1</code>: Use the previous v1 algorithm.</li>
  </ul>
</ParamField>

<ParamField body="outline_detection" type="boolean">
  The automatic detection of the XML structure won't yield best results in all XML files. You can disable this automatic mechanism altogether by setting the <code>outline\_detection</code> parameter to <code>false</code> and selecting the tags that should be considered structure tags. This will split sentences using the <code>splitting\_tags</code> parameter.

  <p>In the example below, we achieve the same results as the automatic engine by disabling automatic detection with <code>outline\_detection=false</code> and setting the parameters manually to <code>tag\_handling=xml</code>, <code>split\_sentences=nonewlines</code>, and <code>splitting\_tags=par,title</code>.</p>

  ```markup Example request theme={null}
    <document>
      <meta>
        <title>A document's title</title>
      </meta>
      <content>
        <par>This is the first sentence. Followed by a second one.</par>
        <par>This is the third sentence.</par>
      </content>
    </document>
  ```

  ```markup Example response theme={null}
    <document>
      <meta>
        <title>Der Titel eines Dokuments</title>
      </meta>
      <content>
        <par>Das ist der erste Satz. Gefolgt von einem zweiten.</par>
        <par>Dies ist der dritte Satz.</par>
      </content>
    </document>
  ```

  <p>While this approach is slightly more complicated, it allows for greater control over the structure of the translation output.</p>

  <Info>
    Note: For requests sent as URL-encoded forms, boolean values should be specified as "1" or "0".
  </Info>
</ParamField>

<ParamField body="non_splitting_tags" type="array[string]">
  Comma-separated list of XML tags which never split sentences. <a href="/docs/xml-and-html-handling/structured-content">Learn more</a>
</ParamField>

<ParamField body="splitting_tags" type="array[string]">
  Comma-separated list of XML tags which always cause splits. <a href="/docs/xml-and-html-handling/customized-xml-outline-detection">Learn more</a>
</ParamField>

<ParamField body="ignore_tags" type="array[string]">
  Comma-separated list of XML tags that indicate text not to be translated. <a href="/docs/xml-and-html-handling/xml">Learn more</a>
</ParamField>

### About the model\_type parameter

The `model_type` parameter lets a user specify if they would like to optimize for speed until a request is served (latency) or translation quality. This is done on a best-effort basis by DeepL, not every language pair and feature must behave differently depending on this parameter.
Currently, the DeepL translation API defaults to the classic models if no `model_type` is included in the requests, except for certain languages (e.g. Thai, which is next-gen only) or certain features (e.g. tag handling v2, which only allows `quality_optimized`).
Note that the API intentionally does not allow the user to specify a model, but rather their goal, so that the DeepL backend can choose the most suitable model for the user (this avoids users constantly having to update their code with new model versions and learning many different models name and their specifics).

As of December 2025, all source and target languages are supported by next-gen models. Please note that DeepL reserves the right to quietly change which model serves e.g. a `model_type=quality_optimized` request, as long as we think it is a net benefit to the user (e.g. no significant latency increase, but a quality increase, or a significant latency reduction with no or only very slight decrease in quality).

The `/languages` endpoint has not yet been updated to include information about `model_type` support, but we expect to make such a change in the future.

### Multiple Sentences

The translation function will (by default) try to split the text into sentences before translating. Splitting normally works on punctuation marks (e.g. "." or ";"), though you should not assume that every period will be handled as a sentence separator. This means that you can send multiple sentences as a value of the *text* parameter. The translation function will separate the sentences and return the whole translated paragraph.

In some cases, the sentence splitting functionality may cause issues by splitting sentences where there is actually only one sentence. This is especially the case if you're using special/uncommon character sequences which contain punctuation. In this case, you can disable sentence splitting altogether by setting the parameter *split\_sentences* to *0*. Please note that this will cause overlong sentences to be cut off, as the DeepL API cannot translate overly long sentences. In this case, you should split the sentences manually before submitting them for translation.

<Tabs>
  <Tab title="cURL">
    The example below uses our API Pro endpoint `https://api.deepl.com`. If you're an API Free user, remember to update your requests to use `https://api-free.deepl.com` instead.

    ```sh Example request: multiple sentences theme={null}
    curl -X POST 'https://api.deepl.com/v2/translate' \
    --header 'Authorization: DeepL-Auth-Key [yourAuthKey]' \
    --header 'Content-Type: application/json' \
    --data '{
      "text": [
        "The table is green. The chair is black."
      ],
      "target_lang": "DE"
    }'
    ```

    ```json Example response theme={null}
    {
      "translations": [
        {
          "detected_source_language": "EN",
          "text": "Der Tisch ist grün. Der Stuhl ist schwarz."
        }
      ]
    }
    ```
  </Tab>

  <Tab title="HTTP Request">
    The example below uses our API Pro endpoint `https://api.deepl.com`. If you're an API Free user, remember to update your requests to use `https://api-free.deepl.com` instead.

    ```http Example request: multiple sentences theme={null}
    POST /v2/translate HTTP/2
    Host: api.deepl.com
    Authorization: DeepL-Auth-Key [yourAuthKey]
    User-Agent: YourApp/1.2.3
    Content-Length: 71
    Content-Type: application/json

    {"text": ["The table is green. The chair is black."],"target_lang":"DE"}
    ```

    ```json Example response theme={null}
    {
      "translations": [
        {
          "detected_source_language": "EN",
          "text": "Der Tisch ist grün. Der Stuhl ist schwarz."
        }
      ]
    }
    ```
  </Tab>
</Tabs>

### Translating Large Volumes of Text

There are a few methods to translate larger volumes of text:

* If your text is contiguous, you can submit whole paragraphs to be translated in one request and with one text parameter. Prior to translation, your text will be split into sentences and translated accordingly.
* The translate function can take several text parameters and will return translations of each such parameter separately in the same order as they are requested (see example below). Each of the parameter values may contain multiple sentences. Up to 50 texts can be sent for translation per request.
* You can make parallel requests by calling the translate function from several threads/processes.

<Tabs>
  <Tab title="cURL">
    The example below uses our API Pro endpoint `https://api.deepl.com`. If you're an API Free user, remember to update your requests to use `https://api-free.deepl.com` instead.

    ```sh Example request: large volumes of text theme={null}
    curl -X POST 'https://api.deepl.com/v2/translate' \
    --header 'Authorization: DeepL-Auth-Key [yourAuthKey]' \
    --header 'Content-Type: application/json' \
    --data '{
      "text": [
        "This is the first sentence.",
        "This is the second sentence.",
        "This is the third sentence."
      ],
      "target_lang": "DE"
    }'
    ```

    ```json Example response theme={null}
    {
      "translations": [
        {
          "detected_source_language": "EN",
          "text": "Das ist der erste Satz."
        },
        {
          "detected_source_language": "EN",
          "text": "Das ist der zweite Satz."
        },
        {
          "detected_source_language": "EN",
          "text": "Dies ist der dritte Satz."
        }
      ]
    }
    ```
  </Tab>

  <Tab title="HTTP Request">
    The example below uses our API Pro endpoint `https://api.deepl.com`. If you're an API Free user, remember to update your requests to use `https://api-free.deepl.com` instead.

    ```http Example request: large volumes of text theme={null}
    POST /v2/translate HTTP/2
    Host: api.deepl.com
    Authorization: DeepL-Auth-Key [yourAuthKey]
    User-Agent: YourApp/1.2.3
    Content-Length: 120
    Content-Type: application/json

    {"text":["This is the first sentence.","This is the second sentence.","This is the third sentence."],"target_lang":"DE"}
    ```

    ```json Example response theme={null}
    {
      "translations": [
        {
          "detected_source_language": "EN",
          "text": "Das ist der erste Satz."
        },
        {
          "detected_source_language": "EN",
          "text": "Das ist der zweite Satz."
        },
        {
          "detected_source_language": "EN",
          "text": "Dies ist der dritte Satz."
        }
      ]
    }
    ```
  </Tab>
</Tabs>

### In-Text Markup

You should take precaution with uncommon characters you may have embedded in your texts. Uncommon character sequences, which may be recognized markers within your system, might get translated or removed, resulting in a corrupted structure. In this case, it is advisable to either split the text so that there is no need to send markers, or to convert your markers to XML tags and enable [XML handling](/docs/xml-and-html-handling/xml) or [HTML handling](/docs/xml-and-html-handling/html).