Your agent.
Your brand’s voice.

This illustrative prompt works with a connected workspace. Use a client such as Claude Desktop, Claude Code, Cursor or Windsurf, or another compatible MCP client.

Need to choose between file uploads, plugins and an agent? Start with the capabilities and file-workflow reference.

Before you connect

1. Create or sign in to your Nativ workspace.
2. Configure target languages and add your brand guidance, glossary and translation memory where relevant.
3. For full MCP and JSON tools, create a key in Settings → API Keys. The focused OAuth connection signs in to your account instead. Localisation operations use your account’s credits and limits.

Run the local server

Add this entry to your client’s MCP configuration and replace the placeholder with your own API key. The local server uses stdio and can work with local file paths.

{
  "mcpServers": {
    "nativ": {
      "command": "npx",
      "args": [
        "-y",
        "nativ-mcp"
      ],
      "env": {
        "NATIV_API_KEY": "nativ_your_api_key_here"
      }
    }
  }
}

Prefer Python tooling? Use uvx as the command and ["nativ-mcp"] as its arguments. Use the repository’s client-specific instructions for configuration-file locations and runtime requirements.

Connect to hosted MCP

Use this configuration in a client that supports a remote Streamable HTTP URL and custom headers. The client sends your Nativ key in X-API-Key. Manually configured bearer credentials are also supported; supply one credential header.

{
  "mcpServers": {
    "nativ": {
      "url": "https://mcp.usenativ.com/mcp",
      "headers": {
        "X-API-Key": "nativ_your_api_key_here"
      }
    }
  }
}

This full-server connection uses API-key authentication. For the separate focused OAuth endpoint, see ChatGPT connections. Switching the URL changes the tool catalogue as well as authentication.

Hosted media tools accept public HTTPS URLs, including valid signed URLs. They return generated artifacts through expiring download links. Use the local server for local file paths.

Which connection works with ChatGPT?

Choose the entry point for your workflow. These do not all expose the same tools:

• Published ChatGPT plugin: Nativ for ChatGPT connects the focused seven-tool service through account sign-in, with a review and export interface. Install it from the public directory.
• Full MCP: https://mcp.usenativ.com/mcp exposes 51 tools and accepts a Nativ API key. It fits clients that support custom headers or a manually configured bearer credential.
• Focused OAuth MCP: https://mcp.usenativ.com/chatgpt/mcp exposes seven tools for workspace context, campaign copy, memory search/approved saving, image-text extraction and image localisation. It uses account sign-in through OAuth, not a manually pasted Nativ API key. It does not expose the full server’s audio, subtitle, voice-cloning, delete or settings-administration tools.
• Public custom GPT: Nativ AI Localization is the existing conversational text experience. It is distinct from the MCP connection and the public plugin directory.

For a compatible custom ChatGPT MCP connection, use the focused URL above and OAuth. Its public client ID is nativ-chatgpt-plugin, with no client secret; it uses S256 PKCE and scope nativ:localize. The current connection requires an eligible Nativ admin or maintainer account. Workspace policy, callback compatibility and account access can affect setup.

Follow OpenAI’s current custom-MCP instructions for the ChatGPT controls. Nativ version 1.0.0 was published in the public plugin directory on 6 November 2026. The custom-MCP instructions describe a separate manual setup path. Never send a password or API key in a chat message.

What your agent can work with

The public capability guide lists exact tools and complete audio and subtitle workflows. Keep review and approval explicit when an agent updates shared workspace knowledge.

What can the 51-tool server actually complete?

Use the exact tool sequence for the task. Names below refer to the full server and JSON adapter; the focused OAuth connection uses its own smaller catalogue.

• Prepare copy: inspect get_languages, get_brand_voice and get_style_guides; search with search_translation_memory; generate with translate or translate_batch. Save approved pairs separately with add_translation_memory_entry.
• Translate lettering in an image: use extract_image_text, review source/target wording, then localize_image with replacement pairs. The output is an image, not recovered editable text layers.
• Dub speech: inspect get_audio_capabilities, obtain segments with transcribe_audio_detailed, translate related turns with translate_dialogue, then review and call synthesize_audio_advanced with suitable voices and source timing. Preserve returned media IDs when the workflow requires them. Dubbing or remuxing audio does not automatically translate the visible picture.
• Review saved subtitles: select the saved target file, read QC rows with get_subtitle_review, save edits with update_subtitle_review and regenerate the export. See the exact handoff below.

Cloning a voice requires ownership or speaker permission and provider-specific verification or consent. Do not create a clone merely because a source recording is available. Check current audio limits and voice coverage before generation; configured text languages are not a voice-availability matrix.

Local files, HTTPS URLs and generated downloads

The stdio server reads files on the machine where it runs. Hosted MCP and the JSON adapter need accessible HTTPS media URLs, including unexpired signed URLs. They do not read your computer’s /Users/… paths, private-network URLs or private chat attachments automatically. You do not need to make an asset permanently public: use a suitable signed URL and share it only with the intended service.

Hosted media downloads are limited to 100 MiB and 120 seconds, with up to five checked redirects. JSON request bodies are limited to 1 MiB, so send media URLs rather than base64 data. These transport limits are separate from backend/account processing limits. Hosted artifact URLs expire after one hour; save approved files to your intended destination. They are download access links, not permanent public asset URLs.

Building a JSON-only connector?

Import the JSON tools schema and configure the same X-API-Key header. Call /tools/{tool_name} with JSON bodies and HTTPS media URLs. The hosted guide documents formats, artifact links and connection details.

The JSON adapter returns an envelope containing tool, text, data and artifacts. A tool’s data can be null, and its structured fields vary; inspect the actual response rather than assuming every tool returns the text-translation fields. Generated artifacts include a temporary url, filename, mime_type and expiry.

Translate one phrase with explicit context

Save this illustrative request as nativ-text-request.json. It uses the full server’s translate schema and inline CSV glossary. The request can use workspace credits; it is not an example of measured translation output.

{
  "text": "Make room for something new.",
  "target_language": "French",
  "target_language_code": "fr",
  "context": "A short homeware campaign headline. Keep Field Notes as the product name.",
  "glossary": "Field Notes,Field Notes\nworkspace,espace de travail",
  "backtranslate": true
}

# Run on your server after setting NATIV_API_KEY.
# Save the JSON example below as nativ-text-request.json.
curl --fail-with-body https://mcp.usenativ.com/tools/translate \
  -H "X-API-Key: $NATIV_API_KEY" \
  -H "Content-Type: application/json" \
  --data-binary @nativ-text-request.json

translate_batch takes a list of strings for one target language and supports shared context and formality, but does not expose glossary, max_characters or backtranslate arguments. Do not copy parameters between the two tools.

Use reviewed replacement pairs for an image

Replace the example URL with an accessible asset you have permission to process. Send this JSON body to POST /tools/localize_image. For a direct MCP call, the older replacements argument is a JSON-encoded string; the JSON adapter shown here accepts a native array.

{
  "image_path": "https://your-storage.example.com/banner.png",
  "target_language_code": "fr",
  "replacements": [
    {
      "original": "Hello",
      "translated": "Bonjour"
    }
  ]
}

How do saved subtitle edits reach the export?

1. Use upload_subtitle for a saved source. Its auto-localisation path supports SRT/ITT. The separate localize_subtitle_file path handles saved ITT sources; for SRT use upload with auto-localisation or the in-memory localize_subtitles workflow.
2. Use list_subtitles and select the intended target-language file. Its storage_path is an account storage key, not a media URL or local path.
3. Read get_subtitle_review, then send update_subtitle_review an updates array using returned row_index values and the fields you intend to change, such as translation, approved and rationale. Do not guess row indices.
4. Call export_subtitle with regenerate: true to apply saved edits. Match the output extension to the saved subtitle format. Use qc: true and an .xlsx filename when you need the QC workbook instead.

This example assumes you selected a saved French SRT. Replace the storage-key marker with the value returned for that file before sending it to POST /tools/export_subtitle. Review playback, cue coverage and timing in the final downloaded file; exporting a QC workbook is not the same as delivering subtitles.

{
  "storage_path": "<target-language storage_path from list_subtitles>",
  "output_path": "reviewed-fr.srt",
  "regenerate": true,
  "source_language": "en"
}

Check the failure before retrying

• No tools or a connection failure: check the transport and client runtime, then restart/reconnect. A public health response proves reachability, not workspace authentication.
• Unauthorised: check the endpoint/authentication pair, key validity or OAuth grant. Do not put a full-server API key into the focused OAuth flow.
• Empty languages: check workspace language configuration. An empty result is different from an unreachable server.
• Media download failure: check public HTTPS reachability, URL expiry, supported input type and transport limits. A local path only works with local stdio.
• Credits, duration or unavailable voices: inspect the account’s current limits and get_audio_capabilities/list_voices. Do not infer voice coverage from text support.
• Failed or incomplete generation: retain errors and any completed artifacts. A batch can have completed work before a later failure. Check usage before repeating it; do not invent missing translations or assume a retry is unbilled.

The connection diagnostic includes a secret-free configuration and public preflight. For help, share the tool name, approximate time, sanitised error and file type through Support. Exclude credentials and private source content.

Test a small first request

1. Restart or reconnect your MCP client.
2. Ask it to list the languages configured in your Nativ workspace.
3. Ask it to search translation memory for a short phrase.
4. Prepare a translation and inspect the result before applying it or saving new approved memory.

Source on GitHub ↗ · Published package ↗ · Build with the API →