How to Translate a Product Catalog Into 40+ Languages Without an API Key

How do I translate a large product catalog into 40+ languages without hiring a translation agency?

Run the catalog through a bulk AI translation actor instead of a per-language agency quote: you export your products as rows (CSV, XLSX or JSON), feed them in, and get every field translated back with the HTML and placeholders untouched. Bulk AI Translator does exactly this: no API key, no per-language vendor contract, and it works on websites, datasets, spreadsheet files and even SRT/VTT subtitle files, not just plain text fields. A 3,000-SKU catalog that would take a translation agency two to three weeks and a five-figure quote turns into a single Apify run you can kick off before lunch.

The practical shift is treating translation as a data pipeline step, not a one-off project. You are not asking a human translator to interpret tone across 3,000 product descriptions; you are running the same deterministic transform on every row and getting the same fields back, translated, so the output slots straight into whatever database or CMS already holds the English version.

How much does it cost to translate 10,000 product listings into five languages?

At $0.002 per result, translating 10,000 listings into five target languages is 50,000 results, which is about $100, and new Apify accounts start with $5 of free credit that covers the first 2,500 results at no cost. If that number feels high, remember it is a one-time or occasional cost per language, not a recurring translator retainer: once a description is translated and unchanged, you never pay for it again.

That last point matters more than the headline price. The actor tracks a changed-since-last-run flag per row, so a weekly re-run against the same catalog only charges for the SKUs whose title, description or price actually changed since the last translation pass. A store that adds 40 new products and edits 15 existing ones in a given week pays for 55 rows times the number of languages, not the full 10,000 again.

A rough cost table for planning

• 500 products, 1 language: 500 results, about $1, covered entirely by free credit.
• 2,000 products, 3 languages: 6,000 results, about $12.
• 10,000 products, 5 languages: 50,000 results, about $100 for the initial run, then only the delta on every re-run.

Will it break my HTML tags, price variables or brand names?

No, as long as you let the actor's built-in protections do their job rather than pasting raw stripped text. HTML tags and template placeholders (things like {{product_name}} or <strong> wrapping a spec value) are detected and preserved through the translation, so a description built from a template does not come back with the tags translated, reordered or dropped. This is the single most common way a DIY translation pipeline built on a raw LLM call breaks: the model "helpfully" rewrites a placeholder token because it looks like an English word, and the field renders broken on the storefront.

Brand names get the same treatment through explicit brand-term locking: you list the terms that must never be translated (your brand name, a model number, a proprietary material name), and every language pass leaves them exactly as typed. Skip this step and you will eventually get a German translation that has helpfully translated your own product line name into a German compound word that means nothing to a German shopper.

What data do I actually get back from a run?

Each result row comes back with the source text, the translated text, the source and target language codes, which brand terms were preserved, whether HTML tags and placeholders were kept intact, a reference back to the original file or row, the changed-since-last-run flag, and a character count for that row. That last field is what lets you reconcile the invoice against what actually got translated, row by row, instead of trusting a single run total.

Because the output is a flat dataset, it drops into a normal ETL step: pull the JSON or CSV export, match rows back to your product IDs on the reference field, and write the translated columns into your CMS or database table for that locale. There is no proprietary SDK to learn; it is the same Apify dataset shape every other actor on the platform uses.

How do I automate this so new products get translated on a schedule?

Point an Apify schedule at the actor and let it run against a live export URL, or trigger it from your own code with the Apify API client whenever a product is created or edited. A minimal Python trigger looks like this:

from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")

run_input = {
    "sourceUrl": "https://yourstore.com/exports/products.json",
    "sourceLanguage": "en",
    "targetLanguages": ["fr", "de", "es", "it", "nl"],
    "lockedTerms": ["YourBrandName", "ProModel-X200"],
}

run = client.actor("fayoussef/bulk-ai-translator").call(run_input=run_input)

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["sourceText"], "->", item["translatedText"], item["targetLanguage"])

Wire that into whatever fires on a product save (a webhook, a nightly cron job, an n8n or Make workflow) and new SKUs pick up translations automatically instead of shipping to five markets in English only, which is the default state of most catalogs that "meant to localize eventually." A nightly schedule is usually enough: run it once a day against the same export URL, and the changed-since-last-run flag means an idle day with no product edits costs nothing beyond the fixed schedule itself.

What actually goes wrong at scale, and how do you fix it?

The most common real-world failure is feeding the actor a raw database export where price, currency and number formatting live inside the same text field as the description, for example a description string that literally contains "$49.99" embedded mid-sentence. Locale-aware number and currency formatting differs (comma versus period decimal separators, currency symbol position), and a text-level translation pass will translate the surrounding words correctly but leave the number formatted the American way inside a French or German description, which looks wrong to a native shopper even though nothing is technically broken.

The fix is to keep price and currency in their own structured fields, not inside the free-text description, before you translate, and reformat them separately with your storefront's own locale logic after the translation comes back. Translate only the prose fields (title, description, bullet features, SEO text) and let your application layer handle numeric and currency formatting per locale. This is a five-minute schema check before the first run and it avoids a support ticket from a French customer confused by a $49.99 price sitting inside otherwise-French copy.

Can the same catalog data also be rewritten or classified in bulk, not just translated?

Yes, and it is worth doing in the same pipeline rather than a separate tool: Bulk LLM Runner sends a list of prompts to GPT, Claude, Gemini or Perplexity in one run with no API key, which covers the step before translation, generating or rewriting descriptions, classifying products into categories, or extracting structured attributes from messy supplier text. A typical flow is rewrite and normalize the English descriptions with Bulk LLM Runner first, then translate the cleaned version with Bulk AI Translator, so every language starts from the same clean source instead of five independent, slowly diverging edits.

Both actors sit in the same Bulk AI Tools category alongside a text-to-speech and image generation actor, all billed through the same Apify account with no separate API keys to manage, which is the actual advantage over stitching together OpenAI, Google Translate and a TTS provider yourself: one bill, one dashboard, one dataset shape.

Frequently asked questions