DeepL MCP for AI. Ensure Consistent Brand Voice Across 30+ Languages
Works with every AI agent you already use
…and any MCP-compatible client








Connect to your AI in seconds.
DeepL provides neural machine translation for over 30 languages. It goes beyond basic word swapping, capturing nuance and tone—whether your text needs to sound formal or casual.
You can also build custom brand glossaries to guarantee consistent terminology across all translations, making it perfect for global marketing content.
What your AI can do
Create glossary
Sets up a new glossary containing specific word pairs for consistent terminology.
Delete glossary
Removes an existing glossary when the branded term list changes or is no longer needed.
Get document status
Checks if a large document translation job has finished processing.
Translates raw text while allowing you to specify if the tone should be formal, informal, or neutral.
Applies custom glossaries to translations, guaranteeing specific company terms are translated the exact same way every time.
Lists all supported languages and checks which language pairs can use a glossary for maximum flexibility.
Checks your current usage quota, showing how many characters you've consumed and when the billing period resets.
Tracks the progress of larger document translations submitted through the system.
Ask an AI about this
Waiting for input…
DeepL: 14 Tools for Localization
These tools allow you to manage every aspect of multilingual translation, from creating brand glossaries to monitoring API usage and translating documents.
Make your AI actually useful.
Add this MCP to Claude, Cursor, or Windsurf and your AI stops guessing. It gets real tools to look things up, take action, and handle the stuff you keep doing by hand.
Start using DeepL on VinkiusCreate Glossary
Sets up a new glossary containing specific word pairs for consistent terminology.
Delete Glossary
Removes an existing glossary when the branded term list changes or is no longer...
Get Document Status
Checks if a large document translation job has finished processing.
Get Glossary Entries
Lists all the specific terms and their translations stored within a glossary.
Get Glossary
Retrieves the details of an existing glossary, including its name and source...
Get Usage
Provides detailed metrics on how many characters you've translated this billing cycle.
List Glossaries
Shows a list of all the glossaries currently set up and available for use.
List Glossary Language Pairs
Lists which language pairs are supported for using custom glossaries.
List Source Languages
Provides a list of all languages that can be used as the source text.
List Target Languages
Lists all possible destination languages for your translation output.
Translate Formal
Translates text specifically using a highly formal, professional tone.
Translate Informal
Translates text with an approachable, casual, and conversational tone.
Translate Text
Performs standard translation of text without specific controls for tone or glossary adherence.
Translate With Glossary
Translates text while strictly following the custom rules and terminology defined in...
Security and governance baked right in.
Pick your AI client below to get set up. Just create a Vinkius account, subscribe, and you're instantly up and running. We handle the entire backend infrastructure, delivering out-of-the-box support for HTTPS Streamable, SSE, and OAuth2—zero messy routing required.
Choose How to Get Started
Build a custom MCP for your own tools, or connect a ready-made integration from our catalog.
Build Your Own
Turn any API into an MCP. Import a spec, define Agent Skills, or deploy with MCPFusion.
- Import from OpenAPI, Swagger, or YAML specs
- Create Agent Skills with progressive disclosure
- Deploy to edge with MCPFusion framework
- Built in DLP, auth, and compliance on every call
- Real time usage dashboard and cost metering
- Publish to catalog or keep private
Make Your AI Do More
Start with DeepL, then connect any of our 5,100+ other servers whenever your AI needs more. One click, no limits.
- Use this MCP plus 5,100+ others, all in one place
- Add new capabilities to your AI anytime you want
- Every connection is secured and compliant automatically
- Track usage and costs across all your servers
- Works with Claude, ChatGPT, Cursor, and more
- New servers added to the catalog every week
Independent Platform Disclaimer: Vinkius is an independent platform and is not affiliated with, endorsed by, sponsored by, verified by, or otherwise authorized by DeepL. All third-party trademarks, logos, and brand names are the property of their respective owners. Their use on this website is strictly for informational purposes to identify service compatibility and interoperability.
VINKIUS INFRASTRUCTURE
Cloud Hosted
Managed infra
V8 Isolated
Sandboxed per request
Zero-Trust Proxy
No stored credentials
DLP Enforced
Policy on every call
GDPR Compliant
EU data residency
Token Compression
~60% cost reduction
Works with Claude, ChatGPT, Cursor, and more
The Model Context Protocol standardizes how applications expose capabilities to LLMs. Instead of operating in isolation, your AI gains direct access to external platforms, live data, and real-world actions through secure, standardized connections.
This connection provides 14 powerful capabilities that interface natively with Claude, ChatGPT, Cursor, and other compatible AI platforms. No middleware. No custom integration required.
Translating content usually means copy-pasting into a web form.
Today, if you need to translate a single blog post for five different markets, it’s a painful process. You have to open the DeepL website, switch languages, select the right tone (formal or informal), and then manually copy-paste every section into the corresponding form. If your brand has specific product names, you spend time cross-referencing those terms in a spreadsheet just to make sure they don't get mangled.
With this MCP, that entire sequence of manual steps disappears. Your agent handles the workflow: it checks for glossary needs first, then sends the text through `translate_with_glossary`, and returns clean output ready for your application's database—no copy-pasting needed.
Managing Brand Voice with Glossary Tools
Without this MCP, ensuring consistency is a manual audit. You might translate 'Platform' as 'plateforme' in one document and 'Plateau' in another, because you didn't enforce the correct term pairing for your industry.
Now, by managing glossaries through `create_glossary`, you define that term pair once—say, 'Platform' always equals 'Plateforme'—and every single translation request adheres to it. It’s reliable, repeatable, and takes the guesswork out of global content.
What your AI can actually do with this
If you're building an application that requires multilingual support, the quality of translation matters more than anything else. This MCP connects your AI agent directly to DeepL’s translation engine. You stop worrying about whether a phrase sounds natural or if your brand terminology gets lost in translation. Instead, your agent handles it automatically.
This tool lets you translate standard text into dozens of languages while also controlling the formality—you can tell it to use a formal tone for corporate documentation and an informal tone for social media posts. The real power comes from managing custom glossaries; you define your brand terms once, and the system applies them everywhere, ensuring consistency across thousands of words.
You'll manage everything, from creating those term lists to checking how much API quota you've used, all through Vinkius.
Ultimately, it lets developers integrate high-quality localization directly into their code or agent workflows without needing to build a massive translation layer themselves.
019dd0de-6e94-7309-a218-3bbb817b6984 Here's how it actually works
The bottom line is that it gives your AI client access to high-quality, context-aware translation without complex setup or manual API calls.
First, you connect your DeepL API key to the MCP and initialize any necessary glossaries using tools like create_glossary or list_glossaries.
Next, your agent calls one of the translation methods—like translate_with_glossary for branded content, or translate_formal if you need professional copy—passing the text and target language details.
The system returns the translated text, which is accurate to the requested tone and adheres to any glossary rules you set up.
Who is this actually for?
Localization Managers and Content Developers who struggle with inconsistent brand voice across different language markets. If you're tired of manually checking if 'Dashboard' is translated correctly in German versus Japanese, this MCP saves hours.
Needs to translate complex product documentation into multiple languages while making sure industry-specific terms stay consistent.
Manages marketing copy across global regions, needing to switch between formal and casual tones depending on the target market's culture.
Integrates multilingual text into a web application build, requiring reliable translation that works seamlessly with developer workflows.
What Changes When You Connect
Stop worrying about tone. You can use translate_formal for official legal documents or translate_informal for social media posts, letting your agent pick the right register automatically.
Never lose a brand term again. By setting up glossaries and using translate_with_glossary, you force consistency on key terminology, which is crucial for product names and jargon.
It saves you time tracking API limits. The get_usage tool tells you exactly how many characters you've consumed versus your quota, so you never hit an unexpected billing wall.
You can manage the entire process from one spot. Using tools like list_glossaries and get_glossary_entries means all your brand terms are organized and immediately ready for translation.
Handles more than just text. If you submit a large file, the MCP monitors its progress via get_document_status, letting you know when the full document is ready.
See it in action
Launching a new product line in Germany.
The marketing team needs to translate website copy into German. They use create_glossary first, inputting core terms like 'platform' and 'user dashboard'. Then, they call translate_with_glossary, ensuring the translations maintain the correct formal Sie address throughout the entire site.
Updating social media copy for Brazil.
A content creator needs to take a blog post and adapt it for Instagram in Brazilian Portuguese. They bypass standard translation by calling translate_informal, guaranteeing the output sounds genuinely conversational, not robotic.
Processing large technical manuals.
The documentation team submits an entire PDF manual. Instead of copy-pasting sections, they use the MCP to monitor the job status via get_document_status, and when complete, retrieve the full translated output.
The honest tradeoffs
Treating all text as standard translation.
Just calling translate_text for a legal contract. The result is often grammatically correct but fails to capture the required professional, formal tone needed for compliance documents.
Always check your requirements first. If formality matters, use translate_formal. If brand consistency is key, always pre-load and use create_glossary before calling any translation function.
Forgetting to manage vocabulary.
Translating a product name repeatedly without defining it. The AI might translate 'Cloud Services' differently every time you run the job, leading to confusion in the final product.
Use list_glossaries to see if a glossary exists for that language pair. If not, build one using create_glossary immediately.
When It Fits, When It Doesn't
Use this MCP when consistency and tone are as important as the translation itself. You need it if you're dealing with brand-specific jargon, legal documents requiring formal address, or content that must sound natural for a specific culture (e.g., casual chat vs. academic paper). Don't use it if your only goal is a quick, basic understanding of what a phrase means—then standard dictionary tools work fine.
However, don't rely on this just because you need translations; always check your quota first using get_usage. If you only need to know what languages are supported before starting a project, use list_target_languages and list_source_languages to map out your options.
Questions you might have
Can I control the formality of translations (formal vs. informal)? +
Yes! Use translate_formal for professional communications (e.g., contracts, official correspondence) or translate_informal for casual content (e.g., social media, chat). The standard translate_text tool also accepts an optional formality parameter ('more', 'less', or 'default'). Note: formality control is available for select target languages including DE, FR, ES, PT-BR, and others.
Can I create custom glossaries to ensure consistent terminology? +
Yes. Use create_glossary with a name, source language, target language, and TSV entries (tab-separated source→target pairs). Then use translate_with_glossary to apply the glossary during translation. Use list_glossaries to see all glossaries, get_glossary_entries to inspect term pairs, and list_glossary_language_pairs for supported combinations.
How does DeepL authentication differ from standard Bearer tokens? +
DeepL uses a custom Authorization header format: DeepL-Auth-Key YOUR_KEY (not Bearer). Your API key is generated from the DeepL account dashboard. Free accounts use api-free.deepl.com, while Pro accounts use api.deepl.com. Use get_usage to check your current character consumption and plan limits.
How can I check my API usage limits using the `get_usage` tool? +
You use get_usage to track your character count, remaining quota, and the billing period reset date. This feature keeps you informed about consumption so you don't hit rate limits unexpectedly.
What if I send a large file? Can `get_document_status` help me monitor it? +
Yes, use get_document_status to track progress on submitted document translations. This tool provides updates until your job is complete and the translated files are ready for you.
How do I confirm which languages are supported by listing them with `list_source_languages`? +
Calling list_source_languages or list_target_languages gives you a complete list of all supported language codes. The MCP provides quick access to 30+ options for your translation needs.
How do I view existing custom terminology using the `get_glossary_entries` tool? +
You use get_glossary_entries and list_glossaries to view all saved terminologies. This lets you inspect exactly what was mapped before running a translation job.
I just need basic text translated without formal or informal tone; should I use `translate_text`? +
Yep, translate_text is for standard translations that don't require specific tone settings. It handles basic text input across all supported language pairs smoothly and efficiently.
We've already built the connector for DeepL. Just plug in your AI agents and start using Vinkius.
No hosting. No infrastructure. No complex setup.
All 14 tools are live and waiting.
You're up and running in seconds.
Vinkius gives your AI agents access to the full catalog of app connectors, all fully managed, secure, and enterprise-ready. One subscription, every tool you need.
Built, hosted, and secured by Vinkius. You just connect and go.