Query language support for a specific resource

The /v3/languages endpoint tells you which languages a given DeepL API resource supports and which optional features (formality, glossaries, tag handling, and more) are available per language. Calling it before you build language selectors or validate user input lets you stay current as DeepL adds languages, without maintaining a hardcoded list. This guide shows you how to query language support for a resource, read the response, and check whether a specific feature is available for a language pair.

The resource parameter is required. If you’re migrating from /v2/languages, see the migration guide — the v3 response structure is different.

Before you start

You need a DeepL API key. Find yours on the API Keys & Limits page. If you’re on the Free plan, use https://api-free.deepl.com instead of https://api.deepl.com in all requests below.

Step 1: Choose your resource

The resource parameter identifies which DeepL API product you’re querying language support for. Choose the value that matches what you’re building:

`resource` value	What it covers
`translate_text`	Text translation via `/v2/translate`
`translate_document`	Document translation via `/v2/document`
`glossary`	Glossary management via `/v2/` and `/v3/glossaries`
`voice`	Speech transcription and translation via `/v3/voice`
`write`	Text improvement via `/v2/write`
`style_rules`	Style rules via the style rules endpoints
`translation_memory`	Translation memory features

Step 2: Fetch supported languages

Call GET /v3/languages with your chosen resource value. This example queries languages for text translation:

curl -X GET 'https://api.deepl.com/v3/languages?resource=translate_text' \
  --header 'Authorization: DeepL-Auth-Key [yourAuthKey]'

The response is an array where each object represents one language:

[
  {
    "lang": "de",
    "name": "German",
    "status": "stable",
    "usable_as_source": true,
    "usable_as_target": true,
    "features": {
      "formality": { "status": "stable" },
      "glossary": { "status": "stable" },
      "tag_handling": { "status": "stable" }
    }
  },
  {
    "lang": "en",
    "name": "English",
    "status": "stable",
    "usable_as_source": true,
    "usable_as_target": false,
    "features": {
      "glossary": { "status": "stable" },
      "tag_handling": { "status": "stable" }
    }
  },
  {
    "lang": "en-US",
    "name": "English (American)",
    "status": "stable",
    "usable_as_source": false,
    "usable_as_target": true,
    "features": {
      "glossary": { "status": "stable" },
      "tag_handling": { "status": "stable" }
    }
  }
]

A few things to notice in this response:

en is source-only (usable_as_source: true, usable_as_target: false). For target languages, use a regional variant like en-US or en-GB.
Language codes follow BCP 47. Don’t assume codes are always two letters — treat them as opaque identifiers.
The features object lists optional capabilities available for that language with this resource. A feature’s absence means it isn’t supported.

Step 3: Filter source and target languages

Use usable_as_source and usable_as_target to build your language selectors:

import requests

def get_languages(resource, auth_key):
    response = requests.get(
        "https://api.deepl.com/v3/languages",
        params={"resource": resource},
        headers={"Authorization": f"DeepL-Auth-Key {auth_key}"},
    )
    response.raise_for_status()
    return response.json()

languages = get_languages("translate_text", auth_key="[yourAuthKey]")

source_languages = [lang for lang in languages if lang["usable_as_source"]]
target_languages = [lang for lang in languages if lang["usable_as_target"]]

print("Source languages:", [lang["lang"] for lang in source_languages])
print("Target languages:", [lang["lang"] for lang in target_languages])

Step 4: Check feature availability for a language pair

Some features, like formality, depend on both the source and target language supporting it. To know which language must support a feature for it to be available, call GET /v3/languages/resources:

curl -X GET 'https://api.deepl.com/v3/languages/resources' \
  --header 'Authorization: DeepL-Auth-Key [yourAuthKey]'

[
  {
    "name": "translate_text",
    "features": [
      { "name": "formality", "needs_target_support": true },
      { "name": "glossary", "needs_source_support": true, "needs_target_support": true },
      { "name": "tag_handling", "needs_source_support": true, "needs_target_support": true },
      { "name": "auto_detection", "needs_source_support": true }
    ]
  }
]

For formality, only needs_target_support is set. This means you only need to check whether the target language’s features object contains formality — the source language doesn’t matter. For glossary, both needs_source_support and needs_target_support are set. Both languages in the pair must support glossary for you to use a glossary on that translation. Here’s a helper that combines both calls to check whether a feature is available for a given pair:

def is_feature_available(feature_name, source_lang, target_lang, resource_name, languages, resources):
    # Find the feature's requirements from the resources list
    resource_info = next(r for r in resources if r["name"] == resource_name)
    feature_req = next(
        (f for f in resource_info["features"] if f["name"] == feature_name),
        None,
    )
    if feature_req is None:
        return False  # Feature not defined for this resource

    lang_map = {lang["lang"]: lang for lang in languages}

    if feature_req.get("needs_source_support"):
        source = lang_map.get(source_lang, {})
        if feature_name not in source.get("features", {}):
            return False

    if feature_req.get("needs_target_support"):
        target = lang_map.get(target_lang, {})
        if feature_name not in target.get("features", {}):
            return False

    return True

# Example: can we use a glossary for EN → DE?
available = is_feature_available("glossary", "en", "de", "translate_text", languages, resources)
print(f"Glossary available for EN→DE: {available}")  # True

Including beta languages

By default, the endpoint only returns stable languages. To include languages in beta, add include=beta to your request:

curl -X GET 'https://api.deepl.com/v3/languages?resource=translate_text&include=beta' \
  --header 'Authorization: DeepL-Auth-Key [yourAuthKey]'

Beta languages appear in the response with "status": "beta". Use the status field to decide whether to surface them to end users or restrict them to internal testing.

Don’t hardcode the list of languages returned by this endpoint. New languages are added regularly — call the endpoint at startup (or on a schedule) and cache the result rather than maintaining a static list. See the language release process for details on how DeepL introduces new languages.

Next steps

See the full API reference: Retrieve languages and Retrieve language resources
Browse all languages the API currently supports: Languages supported
If you’re coming from /v2/languages: Migrating from v2/languages

Getting Started

Languages

Going to Production

Cookbooks

Developer Tools

API Updates

Query language support for a specific resource

Before you start

Step 1: Choose your resource

Step 2: Fetch supported languages

Step 3: Filter source and target languages

Step 4: Check feature availability for a language pair

Including beta languages

Next steps

​Before you start

​Step 1: Choose your resource

​Step 2: Fetch supported languages

​Step 3: Filter source and target languages

​Step 4: Check feature availability for a language pair

​Including beta languages

​Next steps

Before you start

Step 1: Choose your resource

Step 2: Fetch supported languages

Step 3: Filter source and target languages

Step 4: Check feature availability for a language pair

Including beta languages

Next steps