Free models for translation
Some free models are trained for many languages or for one language region. The table shows the multilingual and translation models in today's free catalog.
| Model | Free on | Context | Free limits (best offer) | Tools | Vision |
|---|---|---|---|---|---|
| Typhoon 2.5 30B A3B Instruct | Typhoon | 131K | Ongoing free research API (shared rate limits) | Yes | No |
| Qwen SEA-LION v4.5 27B | SEA-LION | 33K | 10 req/min 10 RPM | No | No |
| Nemotron 3 Super 120B | SEA-LION | - | 10 req/min 10 RPM | Yes | No |
| Qwen SEA-LION v4 32B | SEA-LION | 33K | 10 req/min 10 RPM | No | No |
| Llama SEA-LION v3 70B | SEA-LION | 131K | 10 req/min 10 RPM | No | No |
| Gemma SEA-LION v4 27B | Cloudflare Workers AI, SEA-LION | 131K | 10 req/min 10 RPM | No | No |
| Command A Translate | Cohere | 256K | 20 req/min 33 req/day ~1-2M | Yes | No |
| Tiny Aya Global | Cohere | 8K | 20 req/min 33 req/day 1K calls/mo shared | No | No |
| North Small Translate | Cohere | 33K | 20 req/min 33 req/day ~1-2M | No | No |
| Tiny Aya Earth | Cohere | 8K | 20 req/min 33 req/day 1K calls/mo shared | No | No |
| Tiny Aya Fire | Cohere | 8K | 20 req/min 33 req/day 1K calls/mo shared | No | No |
| Tiny Aya Water | Cohere | 8K | 20 req/min 33 req/day 1K calls/mo shared | No | No |
Showing 12 of 16 matching free models. See all models.
Live data from the FreeLLMAPI catalog (version 2026.11.19, checked 19 November 2026). Free limits change often. The catalog is checked every day.
| Model family | Made for | Source |
|---|---|---|
| Command A Translate (Cohere) | Translation in 23 languages, including Arabic, Chinese, Hindi, Japanese, Persian and Ukrainian | Cohere changelog, 28 August 2025 |
| Aya Expanse (Cohere) | Multilingual chat in 23 languages | Cohere docs |
| SEA-LION (AI Singapore) | Southeast Asian languages, 11 or more | sea-lion.ai |
| Typhoon | Thai | opentyphoon.ai |
General models also translate well, mainly between large languages. The strongest free general models today are:
| Model | Free on | Context | Free limits (best offer) | Tools | 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 | Yes | No |
| GLM 5.3 Flash | APINex, BlazeAPI, NVIDIA NIM +1 more | 1M | 40 req/min 40 RPM | Yes | Yes |
| 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 | Yes | Yes |
| Qwen3.8 Flash Next | AMD Radeon Cloud, BlazeAPI, ElectronHub | 262K | Recurring daily account allowance | Yes | No |
| Qwen3.8 Flash | ElectronHub | 1M | $0.25/week shared recurring credit | Yes | Yes |
| 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 | No | No |
| Gemini 3.7 Flash | Google AI Studio | 1M | 10 req/min 20 req/day 250,000 tokens/min ~3M | Yes | Yes |
| GPT-5.6 Luna | ElectronHub | 1M | $0.25/week shared recurring credit | Yes | Yes |
Showing 8 of 184 matching free models. See all models.
Live data from the FreeLLMAPI catalog (version 2026.11.19, checked 19 November 2026). Free limits change often. The catalog is checked every day.
Test each model with your own texts and language pairs. Quality changes a lot between pairs. A model that is good for English to Spanish can be weak for Thai to Vietnamese.
Set up the gateway
Install FreeLLMAPI, add your free provider keys on the dashboard Keys page and copy the unified key. For the translation models above, add a Cohere key, a SEA-LION key or an NVIDIA key. Add Google, Groq or Mistral keys for general models.
Install and test one translation
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."}
]
}'A fixed model ID gives the same translation style every time. When that model reaches its free limit, the request fails, unless the same model is free on another provider. To continue on other models, make a fallback chain profile, for example translate, with your selected models in order. Then use auto:translate as the model.
Translate in batches with Python
One request per string uses your request limits fast. Send 20 to 50 short strings in one request as a JSON list. The code checks that the answer has the same number of items and the same placeholders. If the check fails, it translates the strings one at a time.
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"))Use temperature=0 for translation. The output is then more stable between runs. Save the translations in a file or database, and translate only new or changed strings.
Glossaries, tone and long documents
- Glossary: list product names and fixed terms in the system message. Tell the model which words it must not translate.
- Tone: state the register, for example formal "Sie" in German or informal "tu" in French.
- Context: add one line about where the text appears, for example "button labels in a banking app". Short strings are often ambiguous without it.
- Long documents: split at paragraph boundaries. Send each part with the previous paragraph as context, and translate only the new part.
- Same model for one document: send an
X-Session-Idheader with the document ID. FreeLLMAPI keeps a session on one model for 30 minutes, so the terms stay the same.
FreeLLMAPI has an opt-in response cache for identical requests. A cache hit uses no provider quota. You can turn it on or off for one request with the X-FreeLLM-Cache header. With temperature=0, the same string and the same instructions give the same request, so repeated strings come from the cache.
Check the quality automatically
Simple checks find most bad translations before a person reads them. Run them after each batch and send only the failed strings to a review list.
- Placeholders: the translation must have the same placeholders and tags as the source. The code above already checks this.
- Length: a translation that is less than one third or more than three times the source length is often wrong.
- Untranslated text: if the output is the same as the input, the model did not translate it.
- Back-translation: for important text, translate the result back into the source language with a different model. Compare the meaning, not the words.
Find strings for review
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)]For back-translation, pin a fixed model ID that is not in your translation profile. A different model is less likely to repeat the errors of the first model.
Limits and honest trade-offs
Free tiers are good for app strings, support replies, internal documents and tests. Plan for these limits:
| Limit | Effect on translation | What to do |
|---|---|---|
| Requests per minute and per day | A large file can use a full daily quota | Batch 20 to 50 strings per request. Add keys from more providers. |
| Low daily limits on specialist models | Some translation models allow few requests per day | Put them first in a profile, with general models after them |
| Different models after failover | Style and terms can change between batches | Use a glossary and an X-Session-Id header |
| No SLA | Latency changes during the day | Do not use free tiers for real-time translation that must answer in a fixed time |
| Data terms | Some free tiers can use prompts to train models | Do not send confidential text to those providers |
Machine translation can be wrong. Have a native speaker review legal, medical and marketing text before you publish it. When every key in the chain is at its limit, the gateway returns 429 with a Retry-After header. The code above waits and tries again.
Frequently asked questions
Is there a free translation API based on LLMs?
Yes. Several providers give multilingual LLMs free, including translation models such as Cohere Command A Translate. FreeLLMAPI serves them through one OpenAI-compatible key.
Which free LLM is best for translation?
It depends on the language pair. Command A Translate covers 23 languages, SEA-LION is made for Southeast Asian languages and Typhoon for Thai. Test with your own texts.
How do I translate many strings without hitting rate limits?
Send 20 to 50 strings in one request as a JSON list, use temperature 0, cache the results and add keys from more providers.
How do I keep placeholders and HTML tags in LLM translations?
Tell the model to keep them exactly, then check each translation. If the placeholders do not match, translate that string again or alone.
Is a free LLM translation good enough for production?
For app strings and internal text, often yes, with a glossary and checks. Have a native speaker review legal, medical and marketing text.
Related guides
- Free LLM API in Python
- Do free LLM APIs train on your data?
- Free LLM API rate limits
- Free OpenAI-compatible API base URLs
- Free LLM API for commercial use
Sources
- Cohere changelog: Command A Translate (23 languages) (checked 20 November 2026)
- Cohere docs: Aya (Aya Expanse, 23 languages) (checked 20 November 2026)
- AI Singapore: SEA-LION (checked 20 November 2026)
- Typhoon: Thai language models (checked 20 November 2026)
- FreeLLMAPI docs: REST API (routing profiles, response cache header) (checked 20 November 2026)