Accueil / Guides / API de traduction gratuite avec LLM

API de traduction gratuite avec LLM

Les grands modèles de langage traduisent bien entre de nombreuses langues, et plusieurs fournisseurs les proposent gratuitement. Certains modèles gratuits sont conçus pour la traduction, par exemple Cohere Command A Translate. Ce guide présente les modèles gratuits pour la traduction, un code Python qui traduit par lots et les limites à prévoir. Toutes les requêtes passent par FreeLLMAPI, qui regroupe les offres gratuites de 45 fournisseurs derrière une seule clé compatible OpenAI.

Le code, les noms de modèles et les libellés du catalogue en direct sont affichés en anglais.

Modèles gratuits pour la traduction

Certains modèles gratuits sont entraînés pour de nombreuses langues ou pour une région linguistique. Le tableau présente les modèles multilingues et de traduction du catalogue gratuit actuel.

Modèles gratuits de traduction et multilingues
ModèleGratuit surContexteLimites gratuites (meilleure offre)OutilsVision
Typhoon 2.5 30B A3B InstructTyphoon131KOngoing free research API (shared rate limits)OuiNon
Qwen SEA-LION v4.5 27BSEA-LION33K10 req/min
10 RPM
NonNon
Nemotron 3 Super 120BSEA-LION-10 req/min
10 RPM
OuiNon
Qwen SEA-LION v4 32BSEA-LION33K10 req/min
10 RPM
NonNon
Llama SEA-LION v3 70BSEA-LION131K10 req/min
10 RPM
NonNon
Gemma SEA-LION v4 27BCloudflare Workers AI, SEA-LION131K10 req/min
10 RPM
NonNon
Command A TranslateCohere256K20 req/min
33 req/jour
~1-2M
OuiNon
Tiny Aya GlobalCohere8K20 req/min
33 req/jour
1K calls/mo shared
NonNon
North Small TranslateCohere33K20 req/min
33 req/jour
~1-2M
NonNon
Tiny Aya EarthCohere8K20 req/min
33 req/jour
1K calls/mo shared
NonNon
Tiny Aya FireCohere8K20 req/min
33 req/jour
1K calls/mo shared
NonNon
Tiny Aya WaterCohere8K20 req/min
33 req/jour
1K calls/mo shared
NonNon

Affichage de 12 modèles gratuits sur 16 correspondants. Voir tous les modèles.

Données en direct du catalogue FreeLLMAPI (version 2026.11.19, vérifié le 2026-11-19). Les limites gratuites changent souvent. Le catalogue est vérifié chaque jour.

Famille de modèlesConçu pourSource
Command A Translate (Cohere)Traduction en 23 langues, dont l'arabe, le chinois, l'hindi, le japonais, le persan et l'ukrainienJournal des modifications de Cohere, 28 août 2025
Aya Expanse (Cohere)Chat multilingue en 23 languesDocumentation de Cohere
SEA-LION (AI Singapore)Langues d'Asie du Sud-Est, 11 ou plussea-lion.ai
TyphoonThaïopentyphoon.ai

Les modèles généraux traduisent aussi bien, surtout entre les grandes langues. Les modèles généraux gratuits les plus performants sont aujourd'hui :

Modèles généraux gratuits performants avec un contexte de 128K+
ModèleGratuit surContexteLimites gratuites (meilleure offre)OutilsVision
GLM 5.3APINex, UnoRouter1M5 req/min
10M weighted tokens/day shared across APINex free routes; 4x token multiplier; 5 requests/minute/account
OuiNon
GLM 5.3 FlashAPINex, BlazeAPI, NVIDIA NIM +1 de plus1M40 req/min
40 RPM
OuiOui
Gemini 3.8 FlashAPINex, Google AI Studio1M5 req/min
10M weighted tokens/day shared across APINex free routes; 3x token multiplier; 5 requests/minute/account
OuiOui
Qwen3.8 Flash NextAMD Radeon Cloud, BlazeAPI, ElectronHub262KRecurring daily account allowanceOuiNon
Qwen3.8 FlashElectronHub1M$0.25/week shared recurring creditOuiOui
Deepseek V4.1 FlashAPINex1M5 req/min
10M weighted tokens/day shared across APINex free routes; 3x token multiplier; 5 requests/minute/account
NonNon
Gemini 3.7 FlashGoogle AI Studio1M10 req/min
20 req/jour
250,000 jetons/min
~3M
OuiOui
GPT-5.6 LunaElectronHub1M$0.25/week shared recurring creditOuiOui

Affichage de 8 modèles gratuits sur 184 correspondants. Voir tous les modèles.

Données en direct du catalogue FreeLLMAPI (version 2026.11.19, vérifié le 2026-11-19). Les limites gratuites changent souvent. Le catalogue est vérifié chaque jour.

Testez chaque modèle avec vos propres textes et vos paires de langues. La qualité varie beaucoup selon les paires. Un modèle efficace de l'anglais vers l'espagnol peut être faible du thaï vers le vietnamien.

Configurer la passerelle

Installez FreeLLMAPI, ajoutez vos clés de fournisseurs gratuits sur la page Keys du tableau de bord et copiez la clé unifiée. Pour les modèles de traduction ci-dessus, ajoutez une clé Cohere, une clé SEA-LION ou une clé NVIDIA. Ajoutez des clés Google, Groq ou Mistral pour les modèles généraux.

Installer et tester une traduction

curl -fsSL https://freellmapi.co/install.sh | bash

curl http://localhost:3001/v1/chat/completions \
  -H "Authorization: Bearer <unified-key>" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "command-a-translate-08-2025",
    "temperature": 0,
    "messages": [
      {"role": "system", "content": "Translate the user text into German. Return only the translation."},
      {"role": "user", "content": "Your order has shipped."}
    ]
  }'

Un ID de modèle fixe donne le même style de traduction à chaque fois. Lorsque ce modèle atteint sa limite gratuite, la requête échoue, sauf si le même modèle est gratuit chez un autre fournisseur. Pour continuer avec d'autres modèles, créez un profil de chaîne de repli, par exemple translate, avec vos modèles choisis dans l'ordre. Utilisez ensuite auto:translate comme modèle.

Traduire par lots avec Python

Une requête par chaîne consomme vite vos limites de requêtes. Envoyez 20 à 50 chaînes courtes dans une seule requête, sous forme de liste JSON. Le code vérifie que la réponse contient le même nombre d'éléments et les mêmes espaces réservés. Si cette vérification échoue, il traduit les chaînes une à une.

translate.py

import json
import os
import re
import time

import openai
from openai import OpenAI

client = OpenAI(
    base_url="http://localhost:3001/v1",
    api_key=os.environ["FREELLMAPI_API_KEY"],
    max_retries=3,
    timeout=90,
)
MODEL = "auto:translate"  # a profile with your translation models
PLACEHOLDER = re.compile(r"\{[^}]+\}|%\w|<[^>]+>")  # {name}, %s, <b>

SYSTEM = (
    "You are a professional translator. Translate each string into {lang}. "
    "Keep placeholders such as {{name}}, %s and HTML tags exactly as they are. "
    "Use this glossary: {glossary}. "
    "Return only a JSON array of strings, in the same order and with the same length."
)

def chat(messages):
    for attempt in range(6):
        try:
            resp = client.chat.completions.create(model=MODEL, messages=messages, temperature=0)
            return resp.choices[0].message.content or ""
        except openai.RateLimitError as err:
            header = err.response.headers.get("retry-after", "")
            time.sleep(min(int(header) if header.isdigit() else 2 ** attempt, 120))
    raise RuntimeError("Rate limited on every provider")

def same_placeholders(src: str, dst: str) -> bool:
    return sorted(PLACEHOLDER.findall(src)) == sorted(PLACEHOLDER.findall(dst))

def parse_list(text: str):
    text = text.strip().removeprefix("```json").removeprefix("```").removesuffix("```")
    return json.loads(text)

def translate_batch(strings, lang, glossary="none"):
    system = SYSTEM.format(lang=lang, glossary=glossary)
    try:
        out = parse_list(chat([
            {"role": "system", "content": system},
            {"role": "user", "content": json.dumps(strings, ensure_ascii=False)},
        ]))
        if len(out) == len(strings) and all(same_placeholders(s, d) for s, d in zip(strings, out)):
            return out
    except (json.JSONDecodeError, TypeError):
        pass
    # Fallback: one string per request
    return [translate_one(s, system) for s in strings]

def translate_one(s, system):
    text = chat([
        {"role": "system", "content": system},
        {"role": "user", "content": json.dumps([s], ensure_ascii=False)},
    ])
    try:
        return str(parse_list(text)[0])
    except (json.JSONDecodeError, TypeError, IndexError, KeyError):
        return text.strip()  # keep the raw answer; review it later

def translate_all(strings, lang, size=30, glossary="none"):
    result = []
    for i in range(0, len(strings), size):
        result.extend(translate_batch(strings[i:i + size], lang, glossary))
    return result

if __name__ == "__main__":
    ui = ["Welcome back, {name}!", "You have %s new messages.", "<b>Save</b> your changes"]
    print(translate_all(ui, "French", glossary="messages = messages; Save = Enregistrer"))

Utilisez temperature=0 pour la traduction. Les résultats sont alors plus stables d'une exécution à l'autre. Enregistrez les traductions dans un fichier ou une base de données, et ne traduisez que les chaînes nouvelles ou modifiées.

Glossaires, ton et longs documents

  • Glossaire : listez les noms de produits et les termes fixes dans le message système. Indiquez au modèle les mots qu'il ne doit pas traduire.
  • Ton : indiquez le registre, par exemple le « Sie » formel en allemand ou le « tu » informel en français.
  • Contexte : ajoutez une ligne sur l'endroit où le texte apparaît, par exemple « libellés de boutons dans une application bancaire ». Sans cela, les chaînes courtes sont souvent ambiguës.
  • Longs documents : découpez aux limites des paragraphes. Envoyez chaque partie avec le paragraphe précédent comme contexte, et ne traduisez que la nouvelle partie.
  • Même modèle pour un document : envoyez un en-tête X-Session-Id avec l'ID du document. FreeLLMAPI garde une session sur un même modèle pendant 30 minutes, afin que les termes restent identiques.

FreeLLMAPI dispose d'un cache de réponses facultatif pour les requêtes identiques. Un résultat trouvé dans le cache n'utilise aucun quota de fournisseur. Vous pouvez l'activer ou le désactiver pour une requête avec l'en-tête X-FreeLLM-Cache. Avec temperature=0, la même chaîne et les mêmes instructions donnent la même requête, donc les chaînes répétées viennent du cache.

Vérifier la qualité automatiquement

Des contrôles simples repèrent la plupart des mauvaises traductions avant qu'une personne les lise. Exécutez-les après chaque lot et n'envoyez à une liste de relecture que les chaînes en échec.

  • Espaces réservés : la traduction doit avoir les mêmes espaces réservés et balises que la source. Le code ci-dessus effectue déjà ce contrôle.
  • Longueur : une traduction plus courte que le tiers ou plus longue que trois fois la source est souvent fausse.
  • Texte non traduit : si la sortie est identique à l'entrée, le modèle ne l'a pas traduite.
  • Traduction inverse : pour les textes importants, traduisez le résultat dans la langue source avec un autre modèle. Comparez le sens, et non les mots.

Trouver les chaînes à relire

def needs_review(src: str, dst: str) -> bool:
    ratio = len(dst) / max(len(src), 1)
    return (
        not same_placeholders(src, dst)
        or dst.strip() == src.strip()
        or ratio < 0.33
        or ratio > 3.0
    )

review = [(s, d) for s, d in zip(ui, translated) if needs_review(s, d)]

Pour la traduction inverse, fixez un ID de modèle qui ne figure pas dans votre profil de traduction. Un autre modèle a moins de risques de reproduire les erreurs du premier.

Limites et compromis réalistes

Les offres gratuites conviennent aux chaînes d'applications, aux réponses du support, aux documents internes et aux tests. Prévoyez ces limites :

LimiteEffet sur la traductionAction à mener
Requêtes par minute et par jourUn gros fichier peut utiliser tout le quota quotidienRegroupez 20 à 50 chaînes par requête. Ajoutez des clés d'autres fournisseurs.
Faibles limites quotidiennes sur les modèles spécialisésCertains modèles de traduction n'autorisent que peu de requêtes par jourPlacez-les en premier dans un profil, suivis des modèles généraux
Modèles différents après un basculementLe style et les termes peuvent changer d'un lot à l'autreUtilisez un glossaire et un en-tête X-Session-Id
Pas de SLALa latence varie au cours de la journéeN'utilisez pas les offres gratuites pour une traduction en temps réel qui doit répondre dans un délai fixe
Conditions sur les donnéesCertaines offres gratuites peuvent utiliser les prompts pour entraîner leurs modèlesN'envoyez pas de texte confidentiel à ces fournisseurs

La traduction automatique peut être fausse. Faites relire les textes juridiques, médicaux et marketing par un locuteur natif avant publication. Lorsque toutes les clés de la chaîne ont atteint leur limite, la passerelle renvoie 429 avec un en-tête Retry-After. Le code ci-dessus attend, puis réessaie.

Utilisez chacun de ces modèles avec une seule clé. FreeLLMAPI est un routeur open source auto-hébergé. Il place toutes ces offres gratuites derrière un seul point de terminaison compatible OpenAI, et bascule vers une autre offre lorsqu'une limite de débit est atteinte. Parcourir le catalogue ou passer en production.

Questions fréquentes

Existe-t-il une API de traduction gratuite basée sur des LLM ?

Oui. Plusieurs fournisseurs proposent gratuitement des LLM multilingues, y compris des modèles de traduction comme Cohere Command A Translate. FreeLLMAPI les sert avec une seule clé compatible OpenAI.

Quel LLM gratuit est le meilleur pour la traduction ?

Cela dépend de la paire de langues. Command A Translate couvre 23 langues, SEA-LION est conçu pour les langues d'Asie du Sud-Est et Typhoon pour le thaï. Testez avec vos propres textes.

Comment traduire de nombreuses chaînes sans atteindre les limites de débit ?

Envoyez 20 à 50 chaînes dans une seule requête sous forme de liste JSON, utilisez temperature 0, mettez les résultats en cache et ajoutez des clés d'autres fournisseurs.

Comment conserver les espaces réservés et les balises HTML dans les traductions par LLM ?

Demandez au modèle de les conserver exactement, puis vérifiez chaque traduction. Si les espaces réservés ne correspondent pas, traduisez de nouveau cette chaîne, seule.

Une traduction par LLM gratuit est-elle suffisante pour la production ?

Pour les chaînes d'applications et les textes internes, souvent oui, avec un glossaire et des contrôles. Faites relire les textes juridiques, médicaux et marketing par un locuteur natif.

Guides associés

Sources

Tous les guides · Parcourir tous les modèles gratuits