Image translation API: send an image, get a translated image back

The TranslateMyImage API translates the text inside an image and returns a new image, not a list of strings. You send one image and one target language to a single endpoint; the JSON response contains a URL to the translated image, generated to keep the original layout. This page shows what the API does, request examples in curl, Python and Node.js, how to handle errors, and when building your own OCR pipeline makes more sense. The full reference is in the API documentation.

Request fields

The body is multipart/form-data, which your HTTP client sets for you.

Response

A successful call returns this shape (example from the reference):

{
  "success": true,
  "translation": {
    "id": "clxb1234567890",
    "originalUrl": "https://storage.com/original.jpg",
    "translatedUrl": "https://storage.com/translated.jpg",
    "sourceLang": "fr",
    "targetLang": "en",
    "status": "completed",
    "createdAt": "2026-09-21T15:27:39.000Z",
    "metadata": { "quality": "basic", "model": "muse-image" }
  }
}

sourceLang is null when you omit source_lang or send auto. Errors return JSON with success: false, an error message and, once the key is accepted, a stable code such as insufficient_credits.

Quick start

Create a key on the dashboard's API Keys page. It is shown only once, so store it in an environment variable or a secret manager right away.

curl

curl -X POST https://translatemyimage.com/api/translate \
  -H "X-API-Key: $TMI_API_KEY" \
  -F "[email protected]" \
  -F "target_lang=es" \
  -F "source_lang=auto" \
  -F "business_type=marketing"

Python (requests), with a retry when the image service is rate limited:

import os
import time

import requests

API_URL = "https://translatemyimage.com/api/translate"
API_KEY = os.environ["TMI_API_KEY"]


def translate_image(path, target_lang, business_type="default", max_attempts=5):
    for attempt in range(max_attempts):
        with open(path, "rb") as image:
            response = requests.post(
                API_URL,
                headers={"X-API-Key": API_KEY},
                files={"file": image},
                data={
                    "target_lang": target_lang,
                    "source_lang": "auto",
                    "business_type": business_type,
                },
                timeout=900,  # generation can take minutes: keep this generous
            )
        if response.status_code == 429:
            time.sleep(2 ** attempt)  # exponential backoff, then retry
            continue
        payload = response.json()
        if response.status_code != 200 or not payload.get("success"):
            raise RuntimeError(f"{response.status_code}: {payload.get('error')}")
        return payload["translation"]
    raise RuntimeError(f"Still rate limited after {max_attempts} attempts")


for lang in ["es", "fr", "de"]:
    result = translate_image("product-front.jpg", lang, "marketing")
    print(lang, result["translatedUrl"])

Node.js (18 or later, as an ES module, with the built-in fetch and FormData):

import { readFile } from "node:fs/promises";

const form = new FormData();
const image = new Blob([await readFile("product-front.jpg")], { type: "image/jpeg" });
form.append("file", image, "product-front.jpg");
form.append("target_lang", "ja");

const response = await fetch("https://translatemyimage.com/api/translate", {
  method: "POST",
  headers: { "X-API-Key": process.env.TMI_API_KEY },
  body: form,
});
const payload = await response.json();
if (!response.ok) throw new Error(`${response.status}: ${payload.error}`);
console.log(payload.translation.translatedUrl);

One target_lang per request: to translate an image into five languages, send five requests.

Handle every status code

The reference documents these six statuses. The endpoint can also return others, for example 422 when no image could be generated (code: generation_failed) or 503 when the image service is unavailable (service_unavailable), so branch on code rather than on the status alone.

Build it yourself or call an image-to-image API?

Instead of an image-to-image API, you can assemble a pipeline: an OCR service to find the text (Google Cloud Vision, for example, returns the extracted text with the bounding box of each word, per its OCR documentation), a text translation API, then code that erases the original text and typesets the translation in the same boxes with a matching font.

Build it yourself when you need the translated text as data (alt text, search), strict terminology enforcement, editable layers, more languages, or pixels outside the text that must stay identical. Call the API when you want finished visuals in a few languages and can review them before use.

A production workflow

1. Validate locally before sending: file type, 10 MB, 25 megapixels, a supported target_lang.
2. Queue one job per image and language, and back off on 429.
3. Copy the result to your own storage or DAM with the source ID, target language, translation.id and createdAt. Neither the reference nor the privacy policy promises how long translatedUrl stays available, so do not rely on it as permanent hosting. It is an unsigned storage link: treat it as public.
4. Mark every output "to review". A person who reads the target language checks prices, specifications and legal text first, then headlines. The batch translation page has a review-by-risk table you can reuse.
5. Publish only reviewed images, for example to your Amazon listing images.

Before writing code, run a few representative images through the web uploader with the mode you plan to use. For occasional jobs without code, batch translation in the dashboard is simpler: up to 10 images and 50 translated outputs per batch.

Plans and credits

API access is included from the Pro plan up: Pro comes with 100 credits a month and Premium with 300 (pricing). Each completed translation consumes one credit. Pay-as-you-go packs add 1 credit for $2, 30 for $10 or 100 for $20; they do not unlock API access on their own. Every plan with API access also includes Ultra quality and custom_prompt.