JSON Translate#

JsonTranslate is a multilingual JSON translation tool designed for developers and content creators. It supports Google Translate, Azure, and DeepL(X) translation APIs to help with project internationalization and localization. Whether you are developing a multilingual website, app, or managing multilingual datasets, JsonTranslate offers a simple solution to easily translate JSON file content into multiple target languages.

Translation Modes#

Global Translation#

Global translation recursively traverses the entire JSON structure, translating all string values while preserving the original hierarchy and structure of the JSON.

Suitable for:

• Translating all text in an entire JSON file
• One-click translation without complex configurations

Specific Node#

Using a JSONPath expression, you can precisely target one or more nodes and translate only the string content within those nodes. Multiple paths can be specified, separated by commas.

Suitable for:

• JSON data with a clear hierarchy where only specific parts need translation
• Reducing the translation scope for large JSON files to improve efficiency

Specific Key Names#

In this mode, you can specify particular key names to translate. Two input methods are supported:

• Simple Mode: Enter the key names to be translated directly in the input box, separated by commas (in either English or Chinese), and the program will translate the content of those keys.
• Advanced Mode: Set the mapping between input and output keys using the key mapping component. The translation result will be written to a new field while keeping the original field unchanged.

Suitable for:

• Translating only specific fields, such as title or description
• Outputting translation results to different fields to avoid overwriting the original data

Notes:

• Key names are case-sensitive
• If the JSON contains arrays, avoid using pure numbers as key names to prevent them from being interpreted as indices
• The number of input and output keys must match

Selective Translation#

This mode is suitable for flat JSON structures. You can specify a starting node and the field names to be translated. The system will search from the specified node for target fields in all objects and translate them.

Configuration Options:

• Starting Key (optional): Specify the key from which to begin the search, suitable for scenarios where key order matters
• Fields to Translate: The specific field names to translate, separated by commas if there are multiple

Suitable for:

• Translating only specific fields in a flat structure, such as the "message" field in logs or error messages
• JSON files with simple structures where fields appear repeatedly but only need selective translation

i18n Mode#

i18n mode is designed for multilingual scenarios, allowing the aggregation of multiple language fields within the original JSON structure. It is ideal for building translation files for multilingual websites or apps, or managing multilingual configurations under a unified structure.

How It Works#

• Uses the selected source language as the source field. For example, if the source language is zh, the source field is zh. If the source language is set to auto, the default source field is en.
• Traverses all objects in the JSON that contain the source language field and adds a target language field (at the same level as the source field) for each object.
• If the target language field already exists, translation is skipped to avoid overwriting existing content.
• When both i18n mode and multilingual mode are enabled, the system generates a unified JSON structure that includes the source language and all target languages. This is especially useful for internationalization projects.

Example#

{
  "title": {
    "en": "Settings"
  }
}

If the target languages are set to zh and fr, the translation result is:

{
  "title": {
    "en": "Settings",
    "zh": "设置",
    "fr": "Paramètres"
  }
}

Translation APIs#

This toolkit integrates 5 translation APIs and 6 mainstream Large Language Model (LLM) interfaces, allowing users to choose the most suitable translation method based on their needs:

Translation API Comparison#

• DeepL: Best for long-form text with natural and fluent output. Does not support web-based API; must be used via local or server-side proxy.
• Google Translate: Offers stable quality, suitable for short phrases and UI content. Supports web-based calls.
• Azure Translate: Supports the most languages, ideal for multilingual translation needs.
• GTX API/Web: Free options suitable for lightweight use. However, they have limited stability and rate caps. For instance, when mrfragger attempted to translate a ~2MB subtitle file (~2 million characters), the GTX API hit its limit after just two translation attempts.

If you require higher speed or quality, you can apply for an API Key here: Google Translate, Azure Translate, DeepL Translate. Refer to the corresponding API Application Guide for instructions.

LLM Translation (AI Language Models)#

In addition to traditional APIs, this tool also supports intelligent translation via various LLMs, including: DeepSeek, OpenAI, Azure OpenAI, Siliconflow, Groq, and customizable Custom LLM options.

• Use Cases: Ideal for content requiring deeper language understanding, such as literary works, technical documents, or multilingual material.
• Highly Customizable: Supports configuration of system and user prompts, allowing for control over translation style, terminology preferences, and more.
• LLM Models: Typically requires specifying the model name provided by the selected service; for Azure OpenAI, enter the deployment name instead.
• Temperature Parameter: Controls creativity vs. stability of the translation output. Higher values yield more diverse and creative results but may reduce accuracy. Lower values ensure stable, consistent output—suitable for formal or technical content.

Local Model Integration Guide#

For users deploying LLMs locally (e.g., via Ollama or LM Studio), the following setup instructions apply. For optimal translation quality, we recommend using models such as qwen2.5-14b-instruct or higher-performance alternatives in your custom configuration.

Sample Default Endpoint URLs#

• Ollama:

http://127.0.0.1:11434/v1/chat/completions

• LM Studio:

http://localhost:61234/v1/chat/completions

CORS Configuration (Cross-Origin Resource Sharing)#

If you're encountering connection failures when accessing your local model from a browser, it may be due to cross-origin policy restrictions. Here’s how to fix it:

• Ollama: Start the service with the following command to allow all origins:

OLLAMA_ORIGINS="*" ollama serve

• LM Studio:

  1. Open the left-hand menu in the app and click the Developer icon.
  2. Go to the local server settings page and click Settings at the top.
  3. Check the Enable CORS box.

  

Once configured, this tool will be able to access your local LLM models successfully. (Special thanks to mrfragger for sharing this setup guide.)

Language Support#

This tool supports translation between over 50 languages, encompassing a broad range of European, Asian, and some African languages. It is suitable for various multilingual content processing scenarios. Supported languages include: English, Chinese, Traditional Chinese, Portuguese, Italian, German, Russian, Spanish, French, Japanese, Korean, Arabic, Turkish, Polish, Ukrainian, Dutch, Greek, Hungarian, Swedish, Danish, Finnish, Czech, Slovak, Bulgarian, Slovenian, Lithuanian, Latvian, Romanian, Estonian, Indonesian, Malay, Hindi, Bengali, Vietnamese, Norwegian, Hebrew, Thai, Filipino (Tagalog), Uzbek, Kyrgyz, Turkmen, Kazakh, Bhojpuri, Kannada, Amharic, Gujarati, Javanese, Persian, Tamil, Swahili, Hausa, Telugu, and Marathi.

For detailed information on supported languages, refer to the official documentation of each service:

• Languages supported by DeepL

• Languages supported by Google Translate

• Languages supported by Azure Translator

Feature Description#

Mapped Translation#

When using the specified key name mode, you can switch between the single key mode and the mapped translation mode using the toggle button in the result area. In single key mode, the same node is used for both translation input and output. In mapped translation mode, however, translations involve different nodes—for example, the value of node A is translated to node B, and the value of node C is translated to node D.

Translation Cache#

This tool introduces an optional local translation cache to improve translation efficiency and reduce resource consumption:

• Cache rules: Each translation result is stored with a unique key formatted as source text_target language_source language_translation API_model settings.
• Cache hit condition: The local cache result is used only when the parameters match exactly, ensuring accuracy.
• Cache purpose: Avoid repeated translations, reduce API calls, and improve translation speed.

To disable the use of translation cache, you can uncheck "Use translation cache" or click "Clear translation cache" in the API settings.

Multilingual Translation#

Supports translating the same file into multiple languages at once, which is especially suitable for international video content:

• For example: Translate an English file simultaneously into Chinese, Japanese, German, and French for the convenience of global users.
• Supports 50 major languages, with more to be added continually.

FAQ#

Why is the translation result empty or showing as null?#

This issue may be caused by one of the following reasons:

• The API Key or related settings are incorrect;
• Your account has run out of available credits/tokens;
• The translation rate is set too high, or the API service is temporarily unstable.

You can press F12 to open the browser's Developer Tools, switch to the "Network" tab, and check the specific error message in the API response.

If only part of the content failed to translate, try clicking the “Translate” button again. When translation caching is enabled, the system will skip already translated content to avoid duplicate charges or requests.

Why use a third-party interface to access DeepL?#

DeepL's official service does not allow direct access via web pages, so we use an intermediate gateway to send your request.

This relay interface only transmits data and does not collect any personal information, so you can use it with confidence. If you require greater stability, you may set up your own gateway.

Will my API Key be saved?#

No! Your API Key and other settings are stored only in your own browser. We do not upload or record any of your information.

Why isn’t the GTX Web interface enabled?#

GTX Web puts significant load on the server, so it is disabled by default.

If you're using this tool on your own computer, you can enable it manually. Please avoid using it under a global proxy network, as this may cause translation issues.

JSON Key Names and Their Limitations#

JSON data is stored as key-value pairs, where a "key" (also known as a "name") is a string that uniquely identifies a specific item or element in the data record, forming the basis for data retrieval and manipulation. JsonTranslate leverages the identifying function of JSON key names to achieve precise translation.

Below is an explanation of several key names in the example:

• downvote.message: This is a nested key name. downvote is the key of the outer object, and message is a key within the downvote object.
• 提示词.message: Here, 提示词 is a key that contains an object, which in turn has a key named message.
• share.owner: This key contains a dot (.) and is treated as a single key rather than indicating a nested relationship. In this case, if you want to access the name within the share.owner object, you cannot use share.owner.name because it would be mistakenly interpreted as looking for a name key within an owner object. In reality, share.owner is a complete key name.

{
  "downvote": {
    "message": "Downvote"
  },
  "提示词": {
    "message": "prompt"
  },
  "share.owner": {
    "name": "rabbit"
  },
  "data": {
    "title": {
      "id": "001",
      "name": "cabbages"
    }
  },
  "content": [
    {
      "id": "001",
      "value": "Hello, cabbage."
    },
    {
      "id": "002",
      "value": "Hello, Radish."
    }
  ]
}

Currently, JsonTranslate cannot process JSON key names that contain a dot (.). This is because the dot in JSONPath is used to distinguish nested object keys, which can lead to keys with dots being misinterpreted as multiple levels of nested objects. To avoid this issue, it is recommended to use key names without dots.