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èle | Gratuit sur | Contexte | Limites gratuites (meilleure offre) | Outils | Vision |
|---|---|---|---|---|---|
| Typhoon 2.5 30B A3B Instruct | Typhoon | 131K | Ongoing free research API (shared rate limits) | Oui | Non |
| Qwen SEA-LION v4.5 27B | SEA-LION | 33K | 10 req/min 10 RPM | Non | Non |
| Nemotron 3 Super 120B | SEA-LION | - | 10 req/min 10 RPM | Oui | Non |
| Qwen SEA-LION v4 32B | SEA-LION | 33K | 10 req/min 10 RPM | Non | Non |
| Llama SEA-LION v3 70B | SEA-LION | 131K | 10 req/min 10 RPM | Non | Non |
| Gemma SEA-LION v4 27B | Cloudflare Workers AI, SEA-LION | 131K | 10 req/min 10 RPM | Non | Non |
| Command A Translate | Cohere | 256K | 20 req/min 33 req/jour ~1-2M | Oui | Non |
| Tiny Aya Global | Cohere | 8K | 20 req/min 33 req/jour 1K calls/mo shared | Non | Non |
| North Small Translate | Cohere | 33K | 20 req/min 33 req/jour ~1-2M | Non | Non |
| Tiny Aya Earth | Cohere | 8K | 20 req/min 33 req/jour 1K calls/mo shared | Non | Non |
| Tiny Aya Fire | Cohere | 8K | 20 req/min 33 req/jour 1K calls/mo shared | Non | Non |
| Tiny Aya Water | Cohere | 8K | 20 req/min 33 req/jour 1K calls/mo shared | Non | Non |
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èles | Conçu pour | Source |
|---|---|---|
| Command A Translate (Cohere) | Traduction en 23 langues, dont l'arabe, le chinois, l'hindi, le japonais, le persan et l'ukrainien | Journal des modifications de Cohere, 28 août 2025 |
| Aya Expanse (Cohere) | Chat multilingue en 23 langues | Documentation de Cohere |
| SEA-LION (AI Singapore) | Langues d'Asie du Sud-Est, 11 ou plus | sea-lion.ai |
| Typhoon | Thaï | 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èle | Gratuit sur | Contexte | Limites gratuites (meilleure offre) | Outils | Vision |
|---|---|---|---|---|---|
| GLM 5.3 | APINex, UnoRouter | 1M | 5 req/min 10M weighted tokens/day shared across APINex free routes; 4x token multiplier; 5 requests/minute/account | Oui | Non |
| GLM 5.3 Flash | APINex, BlazeAPI, NVIDIA NIM +1 de plus | 1M | 40 req/min 40 RPM | Oui | Oui |
| Gemini 3.8 Flash | APINex, Google AI Studio | 1M | 5 req/min 10M weighted tokens/day shared across APINex free routes; 3x token multiplier; 5 requests/minute/account | Oui | Oui |
| Qwen3.8 Flash Next | AMD Radeon Cloud, BlazeAPI, ElectronHub | 262K | Recurring daily account allowance | Oui | Non |
| Qwen3.8 Flash | ElectronHub | 1M | $0.25/week shared recurring credit | Oui | Oui |
| Deepseek V4.1 Flash | APINex | 1M | 5 req/min 10M weighted tokens/day shared across APINex free routes; 3x token multiplier; 5 requests/minute/account | Non | Non |
| Gemini 3.7 Flash | Google AI Studio | 1M | 10 req/min 20 req/jour 250,000 jetons/min ~3M | Oui | Oui |
| GPT-5.6 Luna | ElectronHub | 1M | $0.25/week shared recurring credit | Oui | Oui |
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-Idavec 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 :
| Limite | Effet sur la traduction | Action à mener |
|---|---|---|
| Requêtes par minute et par jour | Un gros fichier peut utiliser tout le quota quotidien | Regroupez 20 à 50 chaînes par requête. Ajoutez des clés d'autres fournisseurs. |
| Faibles limites quotidiennes sur les modèles spécialisés | Certains modèles de traduction n'autorisent que peu de requêtes par jour | Placez-les en premier dans un profil, suivis des modèles généraux |
| Modèles différents après un basculement | Le style et les termes peuvent changer d'un lot à l'autre | Utilisez un glossaire et un en-tête X-Session-Id |
| Pas de SLA | La latence varie au cours de la journée | N'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ées | Certaines offres gratuites peuvent utiliser les prompts pour entraîner leurs modèles | N'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.
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
- API LLM gratuite en Python
- Les API LLM gratuites entraînent-elles sur vos données ?
- Limites de débit des API LLM gratuites
- URL de base des API gratuites compatibles OpenAI
- API LLM gratuite à usage commercial
Sources
- Cohere changelog: Command A Translate (23 languages) (vérifié le 20 November 2026)
- Cohere docs: Aya (Aya Expanse, 23 languages) (vérifié le 20 November 2026)
- AI Singapore: SEA-LION (vérifié le 20 November 2026)
- Typhoon: Thai language models (vérifié le 20 November 2026)
- FreeLLMAPI docs: REST API (routing profiles, response cache header) (vérifié le 20 November 2026)