Skip to main content
Glama

MCP Server for SimpleLocalize

SimpleLocalize is the developer-first translation management system.

This is a Model Context Protocol (MCP) server that provides tools for interacting with the SimpleLocalize API.

How to setup

Configure your mcp.json file and add 'simplelocalize':

{
  "mcpServers": {
    "simplelocalize": {
      "command": "npx",
      "args": [
        "-y",
        "@simplelocalize/simplelocalize-mcp",
        "--api-key=PROJECT_API_KEY"
      ]
    }
  }
}

Related MCP server: texterify-mcp

Features (Tools)

Translation keys

  • Get translation keys

  • Create translation key

  • Update translation key

  • Delete translation key

  • Upload translation key screenshot (base64 or file)

Translations

  • Get translations

  • Update translation (single and bulk)

Auto-translation

  • Auto-translate text

  • Create auto-translation jobs

  • Get auto-translation jobs

Tags, languages & customers

  • Get/create/update/delete tags

  • Get/create/update/delete languages

  • Get/create/update/delete customers

Hosting & publishing

  • Get/create hosting environments

  • Get hosting environment details

  • Publish translations to hosting

Import, export & activity

  • Import translations from a local file

  • Export translations to downloadable file(s)

  • Get supported file formats

  • Get project activity

Glossary

  • Get glossary entries

  • Create glossary entry

  • Delete glossary entry

Project

  • Get project details

Feel free to add more tools by making a pull request or creating a feature request.

Installation

To use the MCP server, you'll need an API key. You can create and manage API keys in SimpleLocalize > Settings > Credentials -> Project API Key:

To run the server in a client like Claude Desktop, Cursor or Windsurf, add the following to your MCP config:

{
  "servers": {
    "simplelocalize": {
      "type": "stdio",
      "command": "npx",
      "args": ["-y", "@simplelocalize/simplelocalize-mcp", "--api-key=SIMPLELOCALIZE_API_KEY"]
    }
  }
}

Replace SIMPLELOCALIZE_API_KEY with your API key

For detailed setup guides, see:

Development

  1. Install dependencies:

    pnpm install
  2. Build the server:

    pnpm build
  3. Update client to use the local build:

    {
      "servers": {
        "simplelocalize": {
          "command": "node",
          "args": ["path/to/simplelocalize-mcp-server/build/index.js"],
          "env": {
            "SIMPLELOCALIZE_API_KEY": "your_api_key"
          }
        }
      }
    }

Debugging

To debug the MCP server, you can use the MCP Inspector tool:

  1. Run the server with the inspector:

    pnpm inspector
  2. Open the provided URL in your browser to view and debug the MCP requests and responses.

  3. Include the --api-key argument.

Learn more

Available Tools

47 tools
auto_translate_textA

This tool will auto-translate a single piece of text synchronously without saving it to your project.

  • Provide 'sourceText', 'targetLanguage' (provider language key, e.g. en_US), and 'translationProvider' (GOOGLE_TRANSLATE, DEEPL, or OPEN_AI).

  • Optionally provide 'sourceLanguage', 'sourceProjectLanguage', 'targetProjectLanguage', 'deeplFormality', and 'description' (context to improve quality).

  • Use this to preview a translation or translate ad-hoc text. Use create_auto_translation_jobs to auto-translate and save translations in the project.

Inputs: sourceText (required), targetLanguage (required), translationProvider (required), description, +4 more.

create_auto_translation_jobsA

This tool will start asynchronous auto-translation jobs for one or more languages in your SimpleLocalize project, saving results directly to the project.

  • Optionally provide 'languageKeys' (project language keys to translate; if omitted, all languages are translated) and 'options'.

  • Uses the auto-translation provider/configuration from the last auto-translation job run in the Web App; it cannot be customized via this tool.

  • Returns job items; use get_auto_translation_job or get_auto_translation_jobs to check progress.

Inputs: options, languageKeys.

create_customerA

This tool will create a new customer in your SimpleLocalize project.

  • Provide 'key' (required, unique customer ID) and optionally 'description'.

Inputs: key (required), description.

create_environmentA

This tool will create a new Translation Hosting environment in your SimpleLocalize project.

  • Provide a unique 'key' (lowercase letters, digits, dashes), 'name', and 'color' (hex, no leading '#').

  • The key cannot be '_latest' or '_production' (reserved built-in environments).

  • The created environment can then be used with the publish tool.

Inputs: key (required), name (required), color (required).

create_glossary_entryA

This tool will create a glossary entry in your SimpleLocalize project.

  • Provide 'sourceText' (the term, max 128 characters), 'sourceLanguage', and a non-empty 'targets' array with 'targetLanguage' and 'targetText' for each translation.

  • 'sourceLanguage' and every 'targetLanguage' must be existing language keys in the project - use the 'get_languages' tool first if unsure.

  • If an entry with the same 'sourceText' already exists, its translations are updated instead of creating a duplicate.

  • Optionally set 'caseSensitive' to true for terms whose capitalization matters (product names); quality checks then require exact capitalization.

  • Optionally add 'forms' to a target: alternative forms of the translation (plural, grammatical cases) that quality checks accept as a correct use of the term. Omit 'forms' to keep the ones already stored.

  • Glossary is not available in the Community plan.

Inputs: targets (required), sourceText (required), sourceLanguage (required), caseSensitive.

create_languageA

This tool will create a new language in your SimpleLocalize project.

  • 'key' is required and must be a valid language key (e.g. en, pl_PL).

  • 'name' is optional and can be used to provide a display name for the language.

Inputs: key (required), name.

create_tagA

This tool will create a new tag in your SimpleLocalize project.

  • Provide a unique 'name' and a 'color' in hex format (e.g. 6e56ce).

  • Tags help organize and filter translation keys.

Inputs: name (required), color (required).

create_translation_keyA

This tool will create a single translation key in your SimpleLocalize project.

  • Provide 'key' (required) and optionally 'namespace', 'description', 'codeDescription', 'tags', and 'charactersLimit'.

  • Throws an error if the translation key already exists. Use create_translation_key_bulk to create multiple keys or to ignore existing ones.

Inputs: key (required), tags, namespace, description, +2 more.

create_translation_key_bulkA

This tool will create multiple translation keys in your SimpleLocalize project in bulk.

  • Provide an array of translation key objects (max 100).

  • Each object must include 'key' and can include 'namespace', 'description', 'codeDescription', 'tags', and 'charactersLimit'.

  • It doesn't throw an error if translation key already exists, but it returns a list of failures.

Inputs: translationKeys (required).

delete_customerA
Destructive

This tool will delete a customer from your SimpleLocalize project.

  • Provide 'customerKey' (required).

  • This also removes all customer-specific translation overrides for that customer. Use with caution.

Inputs: customerKey (required).

delete_glossary_entryA
Destructive

This tool will delete a glossary entry from your SimpleLocalize project.

  • Provide 'sourceText' (required) - the entry is removed with all its translations.

Inputs: sourceText (required).

delete_languageA
Destructive

This tool will delete a language from your SimpleLocalize project.

  • Provide 'languageKey' (required), e.g. en, pl_PL.

  • This also removes all translations for that language. Use with caution.

Inputs: languageKey (required).

delete_tagB
Destructive

This tool will delete a tag from your SimpleLocalize project.

  • Provide 'tagName' (required).

Inputs: tagName (required).

delete_translation_keyA
Destructive

This tool will delete a single translation key from your SimpleLocalize project.

  • Provide 'key' (required) and optionally 'namespace'.

  • Use delete_translation_keys_bulk to delete multiple keys at once.

Inputs: key (required), namespace.

delete_translation_keys_bulkA
Destructive

This tool will delete translation keys in bulk in your SimpleLocalize project.

  • Provide 'translationKeys' array (min 1, max 100) with 'key' and optional 'namespace'.

  • It doesn't throw an error if a key doesn't exist, but returns failures list (if any).

  • Use this to clean up unused keys efficiently.

Inputs: translationKeys (required).

export_translationsA
Read-onlyIdempotent

This tool will export translations from your SimpleLocalize project to downloadable file(s).

  • Optionally provide 'downloadFormat' (e.g. csv-translations, multi-language-json, po-pot, etc.), 'downloadOptions', 'languageKeys', 'tags', 'languageOrder', 'customerId', and 'sort'.

  • Returns a list of downloadable file URLs; it does not download the file content itself.

Inputs: sort, tags, customerId, languageKeys, +3 more.

get_activityA
Read-onlyIdempotent

This tool will list recent activity (imports, exports, publications, changes, etc.) for your SimpleLocalize project.

  • Supports pagination via 'page' (default 0) and 'size' (default 10, max 50). Up to 500 latest entries can be fetched.

Inputs: page, size.

get_activity_changesA
Read-onlyIdempotent

This tool will list all content changes for a given activity entry in your SimpleLocalize project.

  • Provide 'activityId' (required, from get_activity).

Inputs: activityId (required).

get_all_translation_keysA
Read-onlyIdempotent

This tool will return all translation keys (key and namespace only) in your SimpleLocalize project.

  • No parameters required.

  • Use this to quickly fetch all keys for reference or validation.

Inputs: no named parameters.

get_all_translation_keys_v2A
Read-onlyIdempotent

This tool will return all translation keys (id, key and namespace only, no metadata) in your SimpleLocalize project.

  • No pagination required, all keys are returned at once.

  • Optionally filter by 'id'.

  • Use this when you need translation key IDs (e.g. to use with update_translation_key_by_id).

Inputs: id.

get_auto_translation_jobA
Read-onlyIdempotent

This tool will return details and progress for a single auto-translation job.

  • Provide 'jobId' (required).

Inputs: jobId (required).

get_auto_translation_jobsA
Read-onlyIdempotent

This tool will list auto-translation jobs for your SimpleLocalize project.

  • Optionally filter by 'status'.

Inputs: status.

get_customerA
Read-onlyIdempotent

This tool will return details for a single customer in your SimpleLocalize project.

  • Provide 'customerKey' (required).

Inputs: customerKey (required).

get_customersA
Read-onlyIdempotent

This tool will list all customers configured in your SimpleLocalize project.

  • No parameters required.

  • Customers are used for customer-specific translation overrides (white-labeling).

Inputs: no named parameters.

get_environment_detailsA
Read-onlyIdempotent

This tool will retrieve hosting status/details for a specific environment in your SimpleLocalize project.

  • Provide 'environmentKey' (required), e.g. _latest, _production or your custom environment key.

  • Use this to verify whether a given environment is available and check its hosting status.

Inputs: environmentKey (required).

get_environmentsA
Read-onlyIdempotent

This tool will list all Translation Hosting environments available in your SimpleLocalize project.

  • No parameters required.

  • Returns environments including built-in ones like _latest and _production (if available) and any custom environments.

Inputs: no named parameters.

get_file_formatsA
Read-onlyIdempotent

This tool will list all file formats supported for import and export in SimpleLocalize.

  • No parameters required.

Inputs: no named parameters.

get_glossary_entriesA
Read-onlyIdempotent

This tool will list all glossary entries in your SimpleLocalize project.

  • No parameters required.

  • Each entry contains the source term with its source language, whether it is 'caseSensitive', and translations for all target languages, each with its alternative 'forms' (plural, grammatical cases) accepted by quality checks.

  • Use it to check how project-specific terms (product names, domain terms) should be translated before translating or reviewing texts.

Inputs: no named parameters.

get_languageA
Read-onlyIdempotent

This tool will return details for a single language in your SimpleLocalize project.

  • Provide 'languageKey' (required), e.g. en, pl_PL.

Inputs: languageKey (required).

get_languagesA
Read-onlyIdempotent

This tool will list all languages configured in your SimpleLocalize project.

  • No parameters required.

  • Use this to see available languages for translations.

Inputs: no named parameters.

get_project_detailsA
Read-onlyIdempotent

This tool will return full details (languages, customers, namespaces, environments, translation progress, etc.) for the project identified by the current Project API Key.

  • No parameters required.

Inputs: no named parameters.

get_tagsA
Read-onlyIdempotent

This tool will list all tags in your SimpleLocalize project.

  • No parameters required.

  • Use this to see available tags for categorizing translation keys.

Inputs: no named parameters.

get_translation_key_detailsA
Read-onlyIdempotent

This tool will return details for a specific translation key in your SimpleLocalize project.

  • Provide 'key' (required) and optionally 'namespace'.

  • Returns metadata such as description, codeDescription, tags, and charactersLimit.

Inputs: key (required), namespace.

get_translation_keysA
Read-onlyIdempotent

This tool will return translation keys with full metadata for your SimpleLocalize project, with pagination.

  • Optionally filter by 'key' and 'namespace' (exact match, case sensitive).

  • Optionally sort by 'sort' (last_seen_at, modified_at, created_at, deprecated_at).

  • Supports pagination via 'page' (default 0) and 'size' (default 100, max 2500).

  • Use this instead of get_all_translation_keys when you need metadata (descriptions, tags, limits, etc.) or pagination.

Inputs: key, page, size, sort, +1 more.

get_translationsB
Read-onlyIdempotent

This tool will list translations in your SimpleLocalize project.

  • You can filter by key, namespace, language, text, customerId, reviewStatus, and more.

  • Supports pagination with 'page' and 'size'.

  • Supports sort with 'sortBy' and 'sortOrder'.

  • Use 'text' to search for translations containing a specific value (min 3 characters).

Inputs: key, page, size, text, +8 more.

import_translationsA

This tool will import translations from a local file into your SimpleLocalize project.

  • Provide 'filePath' (required, absolute local path to the file) and 'uploadFormat' (required, e.g. csv-translations, multi-language-json, po-pot, etc.).

  • Optionally provide 'importOptions' (e.g. PUBLISH_AFTER_IMPORT, REPLACE_TRANSLATION_IF_FOUND), 'languageKey', 'customerId', 'namespace', and 'tags'.

Inputs: filePath (required), uploadFormat (required), tags, namespace, +3 more.

publish_translationsA
Destructive

This tool will publish translations to the specified environment in your SimpleLocalize project.

  • If no environment is specified by the user, then _latest environment should be used as 'environmentKey'.

  • Optionally provide 'labels' (array of strings). Labels can be specified only for the _latest environment.

  • Translations are always published in order that they were specified in the Translation Hosting environments list.

Inputs: environmentKey (required), labels.

update_customerB

This tool will update a customer in your SimpleLocalize project.

  • Provide the existing 'customerKey' to identify the customer, and optionally 'key' and/or 'description' to update.

Inputs: customerKey (required), key, description.

update_languageA

This tool will update a language in your SimpleLocalize project.

  • Provide the existing 'languageKey' to identify the language, and optionally 'key' and/or 'name' to update.

Inputs: languageKey (required), key, name.

update_tagA

This tool will update a tag in your SimpleLocalize project.

  • Provide the existing 'tagName' to identify the tag, and optionally 'name' and/or 'color' (hex, no leading '#') to update.

  • Throws an error if the tag does not exist.

Inputs: tagName (required), name, color.

update_translationA

This tool will update a single translation in your SimpleLocalize project.

  • Provide 'key', 'language' and 'text' (required), and optionally 'namespace', 'customerId', and 'reviewStatus'.

  • Throws an error if the translation key (with optional namespace), language key or customerId does not exist.

  • Use update_translations_bulk for efficient mass updates instead.

Inputs: key (required), text (required), language (required), namespace, +2 more.

update_translation_keyA

This tool will update a translation key (metadata and/or key/namespace) in your SimpleLocalize project.

  • Provide the existing 'key' and optionally 'namespace' to identify the translation key.

  • Provide optional fields to update: newKey, newNamespace, description, codeDescription, tags, charactersLimit, lock, deprecated.

  • Use this to rename keys, move keys between namespaces, or update key metadata.

Inputs: key (required), lock, tags, newKey, +6 more.

update_translation_key_by_idA

This tool will update a translation key (metadata and/or key/namespace) in your SimpleLocalize project by its ID.

  • Provide the existing 'id' to identify the translation key.

  • Provide optional fields to update: key, namespace, description, codeDescription, tags, charactersLimit, lock, deprecated.

  • Use this when you already know the translation key's ID (e.g. from get_all_translation_keys_v2).

Inputs: id (required), key, lock, tags, +5 more.

update_translations_bulkA

This tool will update multiple translations in bulk in your SimpleLocalize project.

  • Provide an array of translation objects (max 100).

  • Each object must include 'key', 'language', and 'text'.

  • Optionally include 'namespace', 'customerId', and 'reviewStatus'.

  • Use this for efficient mass updates.

Inputs: translations (required).

upload_translation_key_screenshotB

This tool will upload a screenshot for a translation key from a base64-encoded image.

  • Provide 'key' (required), optionally 'namespace', and 'base64' (required, PNG/JPG/JPEG, max 2MB).

  • Replaces the existing screenshot if one exists. Throws an error if the translation key does not exist.

Inputs: key (required), base64 (required), namespace.

upload_translation_key_screenshot_fileB

This tool will upload a screenshot for a translation key from a local file.

  • Provide 'key' (required), optionally 'namespace', and 'filePath' (required, absolute local path to a PNG/JPG/JPEG file, max 4MB).

  • Replaces the existing screenshot if one exists. Throws an error if the translation key does not exist.

Inputs: key (required), filePath (required), namespace.

upload_translation_key_screenshots_bulkA

This tool will upload a screenshot and attach it to multiple translation keys at once.

  • Provide 'base64' (required), 'name' (required, file name), optional 'ocr' text, and 'translationKeys' (required, min 1, max 1000 entries with 'key' and optional 'namespace').

Inputs: name (required), base64 (required), translationKeys (required), ocr.

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    TDQS

    A3.5/5.0

    Scored across 47 tools

    Disambiguation2/5

    Several tools retrieve translation keys with overlapping purposes (get_all_translation_keys, get_all_translation_keys_v2, get_translation_keys, get_translation_key_details), and update_translation_key vs update_translation_key_by_id requires knowing whether to use key or ID. The screenshot-upload trio and auto-translation variants add further boundary confusion, though descriptions do clarify some distinctions.

    Naming Consistency4/5

    Most tools follow the verb_noun snake_case pattern (create_language, delete_tag, get_customers), making the set generally predictable. The main inconsistencies are the v2 suffix and the proliferation of similarly named key/list/detail verbs, but the overall convention remains readable.

    Tool Count2/5

    47 tools is heavy for a single MCP server, even for a broad localization platform. Many could be consolidated (key retrieval variants, screenshot uploads, auto-translation job endpoints), so the count feels inflated rather than earned.

    Completeness4/5

    The tool surface covers the core localization lifecycle: keys, translations, languages, tags, environments, customers, glossary, auto-translation, import/export, and activity. Minor gaps exist—no environment update/delete, no explicit glossary update, no translation deletion separate from keys—but agents can work around most of these.

    Maintenance

    ActivityStale
    ResponsivenessNo recent community issues

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      A
      quality
      D
      maintenance
      An MCP server that provides LLM agents with full access to the Texterify translation management API. It enables users to search, create, update, and delete translation keys and their values directly through natural language within their development environment.
      14 npm
      1
      ISC
    • A
      license
      Not graded
      quality
      D
      maintenance
      AI-powered translation management built for AI agents. Automate localization with regional sensitivity and zero TMS overhead. Works with Claude Code, Cursor, VS Code via MCP protocol. Supports JSON, YAML, Markdown, PO and more.
      MIT
    • A
      license
      B
      quality
      D
      maintenance
      An MCP server that wraps the Tolgee localization platform API, enabling LLMs to manage translation projects, keys, translations, languages, and related workflows.
      27
      MIT