Translation API for E-commerce: Translate Product Listings in 195 Languages

#!/usr/bin/env python3
# translate_catalog.py — Bulk translate product catalog via SocketsIO API

import csv
import time
import requests

API_KEY = "your-socketsio-api-key"
API_URL = "https://api.socketsio.com/v1/translate"
TARGET_LANGUAGES = ["de", "fr", "es", "ja", "zh", "ar"]

def translate_batch(texts, target_lang):
    """Translate a list of strings in one API call."""
    response = requests.post(
        API_URL,
        headers={"X-API-Key": API_KEY, "Content-Type": "application/json"},
        json={"q": texts, "target": target_lang, "source": "en"},
        timeout=30
    )
    response.raise_for_status()
    translations = response.json()["data"]["translations"]
    return [t["translatedText"] for t in translations]

def translate_catalog(input_csv, output_prefix):
    with open(input_csv, newline="", encoding="utf-8") as f:
        products = list(csv.DictReader(f))

    for lang in TARGET_LANGUAGES:
        print(f"Translating to {lang}...")

        # Batch titles and descriptions separately for efficiency
        titles = [p["title"] for p in products]
        descriptions = [p["description"] for p in products]

        translated_titles = translate_batch(titles, lang)
        time.sleep(0.1)  # be polite to the API
        translated_descs = translate_batch(descriptions, lang)

        output_file = f"{output_prefix}_{lang}.csv"
        with open(output_file, "w", newline="", encoding="utf-8") as out:
            writer = csv.DictWriter(out, fieldnames=products[0].keys())
            writer.writeheader()
            for i, product in enumerate(products):
                row = product.copy()
                row["title"] = translated_titles[i]
                row["description"] = translated_descs[i]
                writer.writerow(row)

        print(f"  → Saved {output_file} ({len(products)} products)")

if __name__ == "__main__":
    translate_catalog("products.csv", "products_translated")

// shopify-translate-webhook.js
// Listens for product/create webhooks and auto-translates

const express = require('express');
const app = express();
app.use(express.json());

const SOCKETSIO_KEY = process.env.SOCKETSIO_API_KEY;
const SHOPIFY_TOKEN = process.env.SHOPIFY_ADMIN_TOKEN;
const SHOPIFY_STORE = process.env.SHOPIFY_STORE_DOMAIN; // e.g. mystore.myshopify.com
const TARGET_LANGS = ['de', 'fr', 'es', 'ja'];

async function translateText(texts, targetLang) {
  const res = await fetch('https://api.socketsio.com/v1/translate', {
    method: 'POST',
    headers: { 'Content-Type': 'application/json', 'X-API-Key': SOCKETSIO_KEY },
    body: JSON.stringify({ q: texts, target: targetLang, source: 'en' }),
  });
  const data = await res.json();
  return data.data.translations.map(t => t.translatedText);
}

app.post('/webhooks/product-created', async (req, res) => {
  res.sendStatus(200); // Acknowledge immediately

  const product = req.body;
  console.log(`Translating product: ${product.title}`);

  for (const lang of TARGET_LANGS) {
    const [title, bodyHtml] = await translateText(
      [product.title, product.body_html], lang
    );

    // Write translation to Shopify via Translations API
    await fetch(
      `https://${SHOPIFY_STORE}/admin/api/2024-01/products/${product.id}/translations.json`,
      {
        method: 'POST',
        headers: { 'X-Shopify-Access-Token': SHOPIFY_TOKEN, 'Content-Type': 'application/json' },
        body: JSON.stringify({
          translation: { locale: lang, title, body_html: bodyHtml }
        }),
      }
    );
    console.log(`  ✓ Translated to ${lang}`);
  }
});

app.listen(3000, () => console.log('Webhook server running on :3000'));

// functions.php — Auto-translate WooCommerce products

function socketsio_translate_product($post_id, $post) {
    if ($post->post_type !== 'product' || $post->post_status !== 'publish') return;
    if (get_post_meta($post_id, '_sio_translated', true)) return; // already done

    $api_key = 'your-socketsio-api-key';
    $target_langs = ['de', 'fr', 'es'];

    foreach ($target_langs as $lang) {
        $response = wp_remote_post('https://api.socketsio.com/v1/translate', [
            'headers' => ['Content-Type' => 'application/json', 'X-API-Key' => $api_key],
            'body' => json_encode([
                'q' => [$post->post_title, $post->post_content],
                'target' => $lang,
                'source' => 'en',
            ]),
        ]);

        $data = json_decode(wp_remote_retrieve_body($response), true);
        $translations = $data['data']['translations'];

        // Store translations as post meta (use with WPML/Polylang)
        update_post_meta($post_id, "_title_{$lang}", $translations[0]['translatedText']);
        update_post_meta($post_id, "_content_{$lang}", $translations[1]['translatedText']);
    }

    update_post_meta($post_id, '_sio_translated', true);
}
add_action('save_post', 'socketsio_translate_product', 10, 2);

// Translate reviews when language changes (JavaScript)
async function translateReviews(reviews, targetLang) {
  if (targetLang === 'en') return reviews; // No translation needed

  const reviewTexts = reviews.map(r => r.text);
  const res = await fetch('https://api.socketsio.com/v1/translate', {
    method: 'POST',
    headers: { 'Content-Type': 'application/json', 'X-API-Key': SOCKETSIO_KEY },
    body: JSON.stringify({ q: reviewTexts, target: targetLang }),
  });
  const data = await res.json();

  return reviews.map((review, i) => ({
    ...review,
    text: data.data.translations[i].translatedText,
    originalText: review.text,
    translatedFrom: 'en',
  }));
}

# Before (Google Translate)
API_URL = "https://translation.googleapis.com/language/translate/v2"

# After (SocketsIO — same format, 90% less cost)
API_URL = "https://api.socketsio.com/v1/translate"