# Weglot MCP

> Weglot MCP automates website translation and localization workflows directly through your AI agent. Check API status, get a list of supported languages, validate specific language pairs, and translate large arrays of text—all without leaving your chat interface.

## Overview
- **Category:** developer-tools
- **Price:** Free
- **Tags:** translation-api, localization-workflow, multilingual-web, language-support, automated-translation

## Description

This connector gives you direct access to Weglot’s powerful translation engine, making multilingual content management part of your daily workflow. Instead of hopping between the Weglot console and your local editor, you run translations right where you're prompting your AI agent. You can validate if a language pair is supported before running a full batch, or you can feed it an array of strings for high-volume translation. The real power comes when you start chaining this MCP with others in the Vinkius catalog; you could pass content from a CMS MCP to Weglot and then send confirmation messages via a messaging MCP—all through one automated flow. Since your API keys pass through a zero-trust proxy, you never have to worry about them sitting on disk. You just connect once from any MCP-compatible client and start moving global content.

## Tools

### check_language_support
Confirms if a specific source-to-target language pair is supported for translation.

### list_languages
Returns a full list of all language codes recognized by the platform.

### get_status
Checks the overall operational status of the Weglot API service.

### translate_text
Translates multiple sentences provided in an array format, requiring your API key.

## Prompt Examples

**Prompt:** 
```
List all languages supported by Weglot.
```

**Response:** 
```
I've retrieved the list of supported languages. Weglot currently supports over 100 languages, including English (en), French (fr), Spanish (es), German (de), and many more. Would you like to check a specific pair?
```

**Prompt:** 
```
Check if Weglot supports translation from English (en) to Japanese (ja).
```

**Response:** 
```
Checking support for en -> ja... Yes, this translation pair is fully supported by Weglot's engine. You can proceed with your translation tasks.
```

**Prompt:** 
```
Translate 'Welcome to our platform' from English to Spanish using Weglot.
```

**Response:** 
```
Translating... The Spanish translation for 'Welcome to our platform' is 'Bienvenido a nuestra plataforma'. This was processed using the `translate_text` tool.
```

## Capabilities

### Validate API Health
Checks if the Weglot translation service is currently operational before starting a large batch job.

### Discover Language Support
Retrieves a complete list of all language codes that the platform supports, helping you scope your project.

### Verify Pair Compatibility
Confirms whether a specific translation direction, like English to Japanese, is supported by Weglot.

### Bulk Translate Text Arrays
Translates large amounts of source text with full control over the output format and metadata.

## Use Cases

### Pre-flight Localization Check
Before running a major content migration, the agent first calls `get_status` and then uses `list_languages`. This confirms both service uptime and that all necessary language codes are available before any translation work starts.

### Documentation String Translation
A technical writer needs to translate 50 UI strings for a new feature. Instead of using an external tool, they prompt the agent to execute `translate_text` with all the strings in an array, getting instant results.

### Market Expansion Planning
A PM needs to know if their target market (e.g., Icelandic) is supported. They use the agent to call `check_language_support` for a known pairing, confirming feasibility before committing resources.

### Cross-Platform Content Sync
The user chains this MCP with a CMS MCP. The content gets pulled from the CMS, and then the agent automatically executes `translate_text`, pushing the finished, localized text back into the system.

## Benefits

- Stop guessing if a language pair works. Use `check_language_support` to confirm support before writing code, eliminating failed deployment builds.
- Need to know what languages you can target? Running the `list_languages` tool gives you the full roster of supported codes in one prompt.
- Manage high volumes easily. The `translate_text` action handles entire arrays of strings, letting you process UI text that used to take hours of copy-pasting.
- Know if the service is up? Use `get_status` first. This quick check prevents your workflow from failing midway through a major content dump.
- It's designed for automation. Because it runs on Vinkius, you can easily chain this MCP with another platform's MCP to build full localization pipelines.

## How It Works

The bottom line is you get instant, API-driven localization results without switching applications.

1. Subscribe to this MCP and provide your Weglot API key.
2. Use your AI client to check the platform status or list supported languages. This validates that everything is ready to go.
3. Execute the translation by providing the text array, source language, and target language.

## Frequently Asked Questions

**How do I check if Weglot supports English to German using the translate_text tool?**
You shouldn't use `translate_text` for checking compatibility. Instead, run `check_language_support` first. This confirms the pair works before you attempt the actual translation.

**Is `list_languages` limited to my current API key?**
`list_languages` pulls a comprehensive list of all languages supported by the platform generally, not just what's available in your specific account. It gives you the full scope.

**What is the best first step when I connect Weglot MCP?**
Always run `get_status` immediately. This simple check verifies that the API connection is live and operational, preventing unnecessary failures later on.

**Can I use translate_text for non-string content like images?**
No. The `translate_text` tool is designed only for translating arrays of text strings. It cannot process file types or other media.

**How do I use `get_status` to verify Weglot's API health before a large translation batch?**
It immediately checks the current operational status of the Weglot API. This prevents wasted calls and ensures your agent won't fail mid-job, giving you confidence for high-volume content deployment.

**What if I need to verify a specific translation pair, like French to Portuguese? How do I use `check_language_support`?**
You pass the two language codes into `check_language_support`. It gives a definitive yes or no answer on support. This saves you from running a full translation job only for it to fail later.

**Are there rate limits when I run many translations using `translate_text`?**
The MCP handles connection management, but you should batch your calls logically. If you hit an API limit, the tool returns a specific error code that tells you exactly how long to wait before trying again.

**How can I use `list_languages` to create a master list of all supported language codes?**
Calling `list_languages` generates an exhaustive roster of every locale Weglot supports. This is essential for planning your content scope and ensuring no target market gets overlooked during initial setup.

**How can I verify if the Weglot API is currently online?**
You can use the `get_status` tool. It performs a real-time health check to ensure the Weglot API is responsive and operational.

**Can I check if a specific translation pair like English to German is supported?**
Yes! Use the `check_language_support` tool by providing the source (`languageFrom`) and destination (`languageTo`) ISO codes.

**What format should I use to translate multiple sentences at once?**
The `translate_text` tool requires a `words_json` parameter. This should be a JSON array of objects, for example: `[{"t": 1, "w": "Hello world"}]`.