DeepL MCP Server

Overview

What it does

DeepL MCP Server provides professional-grade neural machine translation powered by DeepL’s industry-leading AI. Translate text and documents across 30+ languages with superior quality and context awareness.Key Features:

Professional AI translation in 30+ languages
Automatic language detection
Document translation (PDF, DOCX, PPTX, XLSX, HTML, TXT)
Formality control (formal/informal tone)
Custom glossaries for consistent terminology
Context-aware translations
Real-time usage tracking
Superior quality to Google Translate

Use Cases

Business Scenarios:

Customer Support: Handle international inquiries in customers’ native languages
Content Localization: Adapt marketing materials for global markets
Document Translation: Translate contracts, reports, and business documents
Email Communication: Compose professional messages in any language
Real-Time Chat: Enable multilingual team collaboration
Product Launches: Localize product descriptions and marketing copy
Legal Documents: Maintain accuracy in legal terminology
Technical Documentation: Translate manuals and guides

Quick Start

Get Your API Key

500,000 characters per month
All 30+ language pairs
Document translation
No credit card required for trial

After signing up:

Verify your email address
Log in to your DeepL account
Navigate to Account Settings
Find your Authentication Key for DeepL API
Copy the key (it will look like abc123:fx for Free or abc123 for Pro)

DeepL offers both Free and Pro API tiers. The Free tier is perfect for getting started and handles most business use cases.

Add to NimbleBrain Studio

In NimbleBrain Studio:

Navigate to MCP Servers in the sidebar
Click Add Server
Search for “DeepL” in the server registry
Click Configure
Paste your API key in the DEEPL_API_KEY field
Click Save & Enable

The server will automatically connect and become available in your AI assistant within seconds. Studio automatically detects whether you’re using Free or Pro API based on your key format.

Test the Connection

In your Studio chat, try this prompt:

"Translate 'Hello, how are you?' to Spanish"

You should see the professional translation: “Hola, ¿cómo estás?”

Look for the 🔧 tool usage indicator in Studio to confirm the DeepL server is working correctly.

Available Tools

translate_text

Translate text between any supported language pair with professional quality and context awareness.Parameters:

Parameter	Type	Required	Description
text	string or list	Yes	Text to translate (single string or array for batch)
target_lang	string	Yes	Target language code (e.g., “DE”, “FR”, “ES”, “JA”)
source_lang	string	No	Source language code (auto-detected if not provided)
formality	string	No	Formality level: default, more, less, prefer_more, prefer_less
preserve_formatting	boolean	No	Preserve original formatting (default: false)
tag_handling	string	No	Tag handling mode: xml, html
split_sentences	string	No	Sentence splitting: 0 (none), 1 (default), nonewlines

Returns:

{
  "translations": [
    {
      "detected_source_language": "EN",
      "text": "Hola, ¿cómo estás?"
    }
  ]
}

Example Usage:

"Translate this marketing copy to German with formal tone: 'Welcome to our platform. We're excited to help you succeed.'"

Use formality control (“more” or “less”) for languages that support formal/informal distinctions like German, French, Spanish, Italian, Dutch, and Polish.

translate_with_glossary

Translate text using a custom glossary to ensure consistent terminology across translations.Parameters:

Parameter	Type	Required	Description
text	string or list	Yes	Text to translate
target_lang	string	Yes	Target language code
glossary_id	string	Yes	ID of the glossary to use
source_lang	string	No	Source language code (optional)
formality	string	No	Formality level

Returns:

{
  "translations": [
    {
      "detected_source_language": "EN",
      "text": "Translated text with glossary terms applied"
    }
  ]
}

Example Usage:

"Translate this product description using our technical glossary: 'Our smartphone features advanced AI processing.'"

Glossaries ensure brand names, technical terms, and product names are translated consistently. Create a glossary first using the create_glossary tool.

detect_language

Automatically detect the language of any text with high accuracy.Parameters:

Parameter	Type	Required	Description
text	string	Yes	Text to detect language for

Returns:

{
  "detected_language": "FR",
  "text": "Bonjour le monde"
}

Example Usage:

"What language is this: 'Guten Tag, wie geht es Ihnen?'"

Response: Detected language: German (DE)

Use language detection before translation when handling user-submitted content in unknown languages.

list_languages

Get a complete list of all supported source and target languages with their capabilities.Parameters:

Parameter	Type	Required	Description
language_type	string	No	Type of languages to list: “source” or “target” (default: “target”)

Returns:

{
  "languages": [
    {
      "language": "DE",
      "name": "German",
      "supports_formality": true
    },
    {
      "language": "FR",
      "name": "French",
      "supports_formality": true
    }
  ]
}

Example Usage:

"What languages does DeepL support for translation?"

DeepL supports 30+ languages including all major European languages (German, French, Spanish, Italian, etc.) and Asian languages (Japanese, Chinese, Korean).

get_usage

Monitor your API usage and character limits in real-time.Parameters: None required.Returns:

{
  "character_count": 125000,
  "character_limit": 500000,
  "document_count": 5,
  "document_limit": 20
}

Example Usage:

"How much of my DeepL character limit have I used this month?"

Check your usage regularly to avoid hitting character limits. Studio also displays usage metrics in the server settings.

list_glossaries

View all your custom glossaries for consistent terminology management.Parameters: None required.Returns:

{
  "glossaries": [
    {
      "glossary_id": "abc123",
      "name": "Product Terms EN-DE",
      "ready": true,
      "source_lang": "EN",
      "target_lang": "DE",
      "creation_time": "2024-01-15T10:30:00Z",
      "entry_count": 25
    }
  ]
}

Example Usage:

"Show me all my DeepL glossaries"

Glossaries are perfect for maintaining consistent translation of brand names, product terms, and technical vocabulary across all your content.

create_glossary

Create a custom glossary to ensure consistent translation of specific terms.Parameters:

Parameter	Type	Required	Description
name	string	Yes	Descriptive name for the glossary
source_lang	string	Yes	Source language code
target_lang	string	Yes	Target language code
entries	object	Yes	Dictionary of source:target term pairs
entries_format	string	No	Format: “tsv” or “csv” (default: “tsv”)

Returns:

{
  "glossary_id": "abc123",
  "name": "Product Terms EN-DE",
  "ready": true,
  "source_lang": "EN",
  "target_lang": "DE",
  "creation_time": "2024-01-15T10:30:00Z",
  "entry_count": 3
}

Example Usage:

"Create a glossary called 'Tech Terms' for English to Spanish with these terms:
- smartphone → smartphone (keep in English)
- app → aplicación
- cloud → nube"

Create separate glossaries for different language pairs and content types (marketing, technical, legal) for maximum flexibility.

get_glossary

Retrieve detailed information about a specific glossary.Parameters:

Parameter	Type	Required	Description
glossary_id	string	Yes	Unique glossary identifier

Returns:

{
  "glossary_id": "abc123",
  "name": "Product Terms EN-DE",
  "ready": true,
  "source_lang": "EN",
  "target_lang": "DE",
  "creation_time": "2024-01-15T10:30:00Z",
  "entry_count": 25
}

Example Usage:

"Show me the details of glossary abc123"

delete_glossary

Delete a glossary that’s no longer needed.Parameters:

Parameter	Type	Required	Description
glossary_id	string	Yes	ID of glossary to delete

Returns:

{
  "success": true
}

Example Usage:

"Delete the glossary with ID abc123"

Deleting a glossary is permanent. Make sure you don’t need it before deletion.

translate_document

Translate entire documents while preserving formatting (PDF, DOCX, PPTX, XLSX, HTML, TXT).Parameters:

Parameter	Type	Required	Description
document_path	string	Yes	Path or URL to the document
target_lang	string	Yes	Target language code
source_lang	string	No	Source language code (auto-detected if not provided)
formality	string	No	Formality level
filename	string	No	Original filename for format detection

Returns:

{
  "document_id": "doc123",
  "document_key": "key456",
  "note": "Use these IDs to check status and download"
}

Example Usage:

"Translate my quarterly report from English to German, maintaining the professional tone"

Document translation happens asynchronously. Use get_document_status to check progress and download_translated_document to get the result.

Supported Formats: PDF (text-based), DOCX, PPTX, XLSX, HTML, TXT. Scanned PDFs require OCR processing first.

get_document_status

Check the status of an ongoing document translation.Parameters:

Parameter	Type	Required	Description
document_id	string	Yes	Document ID from upload
document_key	string	Yes	Document key from upload

Returns:

{
  "document_id": "doc123",
  "status": "done",
  "seconds_remaining": 0,
  "billed_characters": 1500,
  "error_message": null
}

Status Values: queued, translating, done, errorExample Usage:

"Check the status of document doc123 with key key456"

download_translated_document

Download a completed document translation.Parameters:

Parameter	Type	Required	Description
document_id	string	Yes	Document ID
document_key	string	Yes	Document key

Returns:

{
  "success": true,
  "document_id": "doc123",
  "content_type": "application/pdf",
  "size": 245000,
  "note": "Document ready for download"
}

Example Usage:

"Download the translated document doc123 with key key456"

Only call this after confirming the document status is “done” to avoid errors.

Authentication

API Key Required: This server requires a DeepL API key to function.

Getting Your API Key

Visit deepl.com/pro-api
Click Sign Up or Log In
Choose your plan:
- Free API: 500,000 characters/month, no credit card required
- Pro API: Pay-as-you-go starting at $25 per 1M characters
Verify your email address
Go to Account Settings in your DeepL dashboard
Find Authentication Key for DeepL API
Copy your API key

API Key Format:

Free tier keys end with :fx (e.g., abc123def456:fx)
Pro keys don’t have the :fx suffix (e.g., abc123def456)
The server automatically detects the correct endpoint based on your key

Start with the Free API tier - it provides 500,000 characters per month, which is sufficient for most business use cases (approximately 100,000 words).

Rate Limits & Pricing

Plan	Characters/Month	Cost	Best For
Free API	500,000	$0	Testing, small projects, individual use
Pro API	Unlimited	$25 per 1M chars	Business use, high volume, teams

Character Counting:

Spaces and punctuation count toward your limit
HTML/XML tags are not counted
Source text is counted, not target text
Example: “Hello world” = 11 characters (including space)

Document Translation Limits:

Free API: Limited document uploads per month
Pro API: Higher document limits based on plan
File size limits apply (typically 30MB maximum)

Monitor your usage regularly. Studio displays your current usage in the server settings, or use the get_usage tool to check programmatically.

Managing Your API Key in Studio

Your API key is securely stored in NimbleBrain Studio. To update it:

Go to Settings → MCP Servers
Find “DeepL” in your server list
Click Edit Configuration
Update your DEEPL_API_KEY field
Click Save

Studio automatically manages server connections - no manual restarts required. Changes take effect immediately.

Example Workflows

Customer Support
Content Localization
Document Translation
Email Communication
Real-Time Chat
Glossary Usage
Language Detection
Bulk Translation

Scenario: Respond to international customer inquiries in their native languagePrompt:

"A customer sent this message in German: 'Ich habe ein Problem mit meiner Bestellung vom 15. Januar. Sie ist noch nicht angekommen.'

Please translate it to English, then help me draft a professional response. Once I approve, translate my response back to German."

What happens:

Translates customer message: “I have a problem with my order from January 15. It hasn’t arrived yet.”
You compose a response in English with the assistant’s help
Translates your response to German with professional formality
Maintains courteous, professional tone throughout

Time: ~2 seconds per translation API calls: 2 (incoming + outgoing)

DeepL automatically maintains appropriate formality levels for customer service contexts. For extra control, specify “formal” or “informal” tone based on your brand voice.

All examples work in NimbleBrain Studio’s natural language interface - no code required!

Troubleshooting

Character Limit Exceeded

Error Message:

403 Forbidden - Character limit exceeded

Cause: You’ve exceeded your monthly character limit (500,000 for Free API, or your Pro plan limit)Solutions:

Check your current usage:
- Use Studio’s server settings to view usage metrics
- Or ask: “How much of my DeepL quota have I used?”
Wait for limit reset:
- Free tier resets on the 1st of each month
- Pro tier depends on your billing cycle
Upgrade your plan:
- Visit deepl.com/pro-api
- Upgrade to Pro API ($25 per 1M characters)
Optimize usage:
- Use batch translations to reduce overhead
- Avoid translating the same text multiple times
- Cache common translations in your application
- Remove unnecessary formatting before translation

Set up usage alerts in Studio to notify you when approaching your limit. Monitor usage regularly with the get_usage tool.

Invalid API Key

Error Message:

401 Unauthorized - Invalid API key

Cause: API key is incorrect, expired, or improperly formattedSolutions:

Verify your API key:
- Log in to your DeepL account at deepl.com
- Go to Account Settings
- Copy your API key exactly (including :fx suffix for Free tier)
- Check for no extra spaces or characters
Update in Studio:
- Go to Settings → MCP Servers
- Find “DeepL” in the list
- Click Edit Configuration
- Paste the correct API key in DEEPL_API_KEY field
- Click Save
Verify API tier:
- Free API keys end with :fx
- Pro API keys don’t have the suffix
- Make sure you’re using the correct key for your plan
Check account status:
- Ensure your DeepL account is active
- Verify email address if newly registered
- Check for any account suspension notices

Free and Pro API keys use different endpoints. Studio automatically detects the correct endpoint based on your key format (:fx suffix = Free API).

Unsupported Language Pair

Error Message:

400 Bad Request - Language not supported

Cause: Requested language is not supported by DeepL, or language pair is invalidSolutions:

Check supported languages:
- Ask Studio: “What languages does DeepL support?”
- Visit deepl.com/docs-api
Verify language codes:
- Use standard language codes (e.g., “EN”, “DE”, “FR”)
- English variants: “EN-US” (American), “EN-GB” (British)
- Portuguese variants: “PT-PT” (European), “PT-BR” (Brazilian)
- Chinese: “ZH” (simplified)
Use bridge translation:
- If direct pair isn’t supported, translate through English
- Example: Language A → English → Language B

Supported Languages:European: Bulgarian (BG), Czech (CS), Danish (DA), German (DE), Greek (EL), English (EN), Spanish (ES), Estonian (ET), Finnish (FI), French (FR), Hungarian (HU), Indonesian (ID), Italian (IT), Lithuanian (LT), Latvian (LV), Dutch (NL), Polish (PL), Portuguese (PT), Romanian (RO), Russian (RU), Slovak (SK), Slovenian (SL), Swedish (SV), Turkish (TR), Ukrainian (UK)Asian: Chinese (ZH), Japanese (JA), Korean (KO)

When in doubt about language codes, use the list_languages tool to see all supported languages with their codes.

Translation Quality Issues

Issue: Translation doesn’t sound natural or misses contextNot an error, but here’s how to improve quality:

Provide more context:
- Include surrounding sentences
- Specify the domain (business, technical, casual)
- Mention the target audience
Use formality control:
- Specify formal or informal tone
- Languages with formality: German, French, Spanish, Italian, Dutch, Polish, Russian, Japanese
Create glossaries:
- Define how specific terms should be translated
- Maintain consistency across all content
- Especially important for brand names and technical terms
Better prompts: ❌ Poor: “Translate to French: bank” ✅ Better: “Translate to French (financial context, formal business tone): ‘Please check your bank account balance for the recent transaction.’”
Batch related content:
- Translate related sentences together
- DeepL uses context from surrounding text
- Better results than translating sentence by sentence

DeepL’s AI performs best with complete sentences and clear context. The more information you provide about the intended use and audience, the better the translation quality.

Server Not Responding

Error Message:

Connection timeout

Server not responding

Cause: Network connectivity issue or service temporarily unavailableSolutions:

Check your internet connection:
- Verify you can access other websites
- Check your network status
Verify server status in Studio:
- Go to Settings → MCP Servers
- Find “DeepL” in the list
- Check if status shows “Active” or “Inactive”
Try toggling the server:
- Click “DeepL” in your server list
- Toggle it Off, wait 5 seconds
- Toggle it On again
Check DeepL API status:
- Visit status.deepl.com (if available)
- Check DeepL’s Twitter/X for service announcements
Check Studio status:
- Verify NimbleBrain Studio is fully operational
- Check for any maintenance notifications

Studio manages all server infrastructure automatically - there’s no local setup or Docker containers to troubleshoot. If issues persist after toggling, contact support.

Document Translation Failed

Error Message:

Document translation failed

Unsupported file format

Cause: Unsupported format, file too large, or file is corruptedSolutions:

Verify file format:
- ✅ Supported: PDF (text-based), DOCX, PPTX, XLSX, HTML, TXT
- ❌ Not supported: Scanned PDFs (images), JPG, PNG, audio, video
Check file size:
- Maximum file size: typically 30MB
- For larger files, split into smaller sections
- Compress images in Office documents
Ensure file isn’t password-protected:
- Remove password protection before translation
- DeepL cannot access encrypted documents
For scanned PDFs:
- Use OCR software to convert to text-based PDF
- Try Adobe Acrobat, Abbyy FineReader, or online OCR tools
- Then translate the text-based version
Try alternative format:
- Convert PDF to DOCX
- Save PPTX as PDF
- Extract text and translate as plain text
Check document status:
- Use get_document_status to see detailed error
- Document may be queued or still processing

Document Translation Process:

Upload document → Get document_id and document_key
Check status periodically → Status: queued → translating → done
Download when status = done

Document translation is asynchronous. Large documents may take several minutes. Don’t attempt to download before status shows “done”.

Glossary Not Applied

Issue: Translations don’t use glossary terms as expectedCause: Glossary not ready, wrong language pair, or terms not matching exactlySolutions:

Verify glossary is ready:
- Use list_glossaries to check status
- Look for "ready": true in glossary details
- Newly created glossaries may take a few seconds to activate
Check language pair match:
- Glossary source/target must match translation request
- If glossary is EN→DE, must translate EN→DE
- Cannot use EN→DE glossary for EN→FR translation
Verify exact term matching:
- Glossary terms must match exactly (case-sensitive)
- “Smartphone” ≠ “smartphone”
- Include common variations if needed
Use translate_with_glossary tool:
- Don’t use regular translate_text with glossary ID
- Use the dedicated translate_with_glossary tool
- Provide correct glossary_id parameter
Check glossary entries:
- Use get_glossary to view details
- Verify your terms are in the glossary
- Ensure entry_count matches expected number

Create comprehensive glossaries with all variations of important terms. Include plural forms, capitalized versions, and common misspellings for best coverage.

Slow Response Times

Issue: Translations taking longer than expectedExpected Performance:

Short text (< 100 characters): < 1 second
Medium text (100-1000 characters): 1-2 seconds
Large text (1000+ characters): 2-5 seconds
Document translation: 1-10 minutes depending on size

If slower than expected:

Check text length:
- Very long texts take longer to process
- Consider breaking into smaller chunks
- Use batch translation for multiple items
Network latency:
- Check your internet speed
- DeepL API is hosted in Europe (faster for EU users)
- Studio optimizes routing automatically
API load:
- DeepL may be experiencing high traffic
- Pro API tier gets priority processing
- Free tier may have lower priority during peak times
Optimize requests:
- Batch related translations together
- Cache frequently translated content
- Avoid unnecessary re-translations

Studio automatically handles request optimization and retry logic. If you consistently experience slow responses, consider upgrading to Pro API for priority processing.

Best Practices

For Best Translation Quality

Provide full sentences with context
Specify formality level when appropriate
Use glossaries for consistent terminology
Batch related content together
Include target audience information
Specify industry or domain when relevant

For Cost Optimization

Monitor usage with get_usage tool
Use batch translations when possible
Cache common translations
Remove unnecessary formatting
Avoid re-translating unchanged content
Set up usage alerts in Studio

For Team Workflows

Create shared glossaries for brand terms
Document your language code standards
Establish formality guidelines per market
Share translated content templates
Set up approval workflows for translations
Track usage across team members

For Security & Compliance

Don’t translate confidential data without review
Check DeepL’s data processing terms
Use Pro tier for business-critical content
Implement human review for legal/medical
Keep API keys secure in Studio
Rotate keys regularly for security

Supported Languages

DeepL supports 30+ languages with professional quality: Full Support (Source & Target):

🇬🇧 English (EN-US, EN-GB)
🇩🇪 German (DE)
🇫🇷 French (FR)
🇪🇸 Spanish (ES)
🇮🇹 Italian (IT)
🇵🇹 Portuguese (PT-PT, PT-BR)
🇳🇱 Dutch (NL)
🇵🇱 Polish (PL)
🇷🇺 Russian (RU)
🇯🇵 Japanese (JA)
🇨🇳 Chinese Simplified (ZH)
🇰🇷 Korean (KO)

Additional Languages: Bulgarian (BG), Czech (CS), Danish (DA), Greek (EL), Estonian (ET), Finnish (FI), Hungarian (HU), Indonesian (ID), Lithuanian (LT), Latvian (LV), Romanian (RO), Slovak (SK), Slovenian (SL), Swedish (SV), Turkish (TR), Ukrainian (UK) Formality Support: German, French, Spanish, Italian, Dutch, Polish, Russian, Japanese support formal/informal tone control.

Use the list_languages tool to get the most up-to-date list of supported languages and their capabilities.

Links & Resources

GitHub Repository

View source code, report issues, and contribute

DeepL API Documentation

Official DeepL API reference and guides

Get API Key

NimbleBrain Studio

Access your Studio workspace

Report Issues

Found a bug? Submit an issue on GitHub

DeepL Account

Manage your API keys and usage

Gmail

Translate emails automatically

Slack

Real-time message translation

Google Docs

Translate documents in place

Google Translate

Alternative translation service

Azure Translator

Microsoft translation service

Notion

Translate Notion content

Need help? Join the NimbleBrain Discord or email [email protected]

Get Started

Core Features

Developer Tools

Overview

What it does

Use Cases

Quick Start

Available Tools

Authentication

Getting Your API Key

Rate Limits & Pricing

Managing Your API Key in Studio

Example Workflows

Troubleshooting

Best Practices

For Best Translation Quality

For Cost Optimization

For Team Workflows

For Security & Compliance

Supported Languages

Links & Resources

GitHub Repository

DeepL API Documentation

Get API Key

NimbleBrain Studio

Report Issues

DeepL Account

Gmail

Slack

Google Docs

Google Translate

Azure Translator

Notion

Get Started

Core Features

Developer Tools

​Overview

What it does

Use Cases

​Quick Start

​Available Tools

​Authentication

​Getting Your API Key

​Rate Limits & Pricing

​Managing Your API Key in Studio

​Example Workflows

​Troubleshooting

​Best Practices

For Best Translation Quality

For Cost Optimization

For Team Workflows

For Security & Compliance

​Supported Languages

​Links & Resources

GitHub Repository

DeepL API Documentation

Get API Key

NimbleBrain Studio

Report Issues

DeepL Account

​Related MCP Servers

Gmail

Slack

Google Docs

Google Translate

Azure Translator

Notion

Overview

Quick Start

Available Tools

Authentication

Getting Your API Key

Rate Limits & Pricing

Managing Your API Key in Studio

Example Workflows

Troubleshooting

Best Practices

Supported Languages

Links & Resources

Related MCP Servers