Guide

Free translation API with LLMs

Large language models translate well between many languages, and several providers give them free. Some free models are made for translation, for example Cohere Command A Translate. This guide shows the free models for translation, Python code that translates in batches, and the limits to plan for. All requests go through FreeLLMAPI, which pools 45 free provider tiers behind one OpenAI-compatible key.

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.

Free translation and multilingual models
ModelFree onContextFree limits (best offer)ToolsVision
Typhoon 2.5 30B A3B InstructTyphoon131KOngoing free research API (shared rate limits)YesNo
Qwen SEA-LION v4.5 27BSEA-LION33K10 req/min
10 RPM
NoNo
Nemotron 3 Super 120BSEA-LION-10 req/min
10 RPM
YesNo
Qwen SEA-LION v4 32BSEA-LION33K10 req/min
10 RPM
NoNo
Llama SEA-LION v3 70BSEA-LION131K10 req/min
10 RPM
NoNo
Gemma SEA-LION v4 27BCloudflare Workers AI, SEA-LION131K10 req/min
10 RPM
NoNo
Command A TranslateCohere256K20 req/min
33 req/day
~1-2M
YesNo
Tiny Aya GlobalCohere8K20 req/min
33 req/day
1K calls/mo shared
NoNo
North Small TranslateCohere33K20 req/min
33 req/day
~1-2M
NoNo
Tiny Aya EarthCohere8K20 req/min
33 req/day
1K calls/mo shared
NoNo
Tiny Aya FireCohere8K20 req/min
33 req/day
1K calls/mo shared
NoNo
Tiny Aya WaterCohere8K20 req/min
33 req/day
1K calls/mo shared
NoNo

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 familyMade forSource
Command A Translate (Cohere)Translation in 23 languages, including Arabic, Chinese, Hindi, Japanese, Persian and UkrainianCohere changelog, 28 August 2025
Aya Expanse (Cohere)Multilingual chat in 23 languagesCohere docs
SEA-LION (AI Singapore)Southeast Asian languages, 11 or moresea-lion.ai
TyphoonThaiopentyphoon.ai

General models also translate well, mainly between large languages. The strongest free general models today are:

Strong free general models with 128K+ context
ModelFree onContextFree limits (best offer)ToolsVision
GLM 5.3APINex, UnoRouter1M5 req/min
10M weighted tokens/day shared across APINex free routes; 4x token multiplier; 5 requests/minute/account
YesNo
GLM 5.3 FlashAPINex, BlazeAPI, NVIDIA NIM +1 more1M40 req/min
40 RPM
YesYes
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
YesYes
Qwen3.8 Flash NextAMD Radeon Cloud, BlazeAPI, ElectronHub262KRecurring daily account allowanceYesNo
Qwen3.8 FlashElectronHub1M$0.25/week shared recurring creditYesYes
Deepseek V4.1 FlashAPINex1M5 req/min
10M weighted tokens/day shared across APINex free routes; 3x token multiplier; 5 requests/minute/account
NoNo
Gemini 3.7 FlashGoogle AI Studio1M10 req/min
20 req/day
250,000 tokens/min
~3M
YesYes
GPT-5.6 LunaElectronHub1M$0.25/week shared recurring creditYesYes

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-Id header 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:

LimitEffect on translationWhat to do
Requests per minute and per dayA large file can use a full daily quotaBatch 20 to 50 strings per request. Add keys from more providers.
Low daily limits on specialist modelsSome translation models allow few requests per dayPut them first in a profile, with general models after them
Different models after failoverStyle and terms can change between batchesUse a glossary and an X-Session-Id header
No SLALatency changes during the dayDo not use free tiers for real-time translation that must answer in a fixed time
Data termsSome free tiers can use prompts to train modelsDo 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.

Use every one of these through one key. FreeLLMAPI is an open-source, self-hosted router that puts all these free tiers behind a single OpenAI-compatible endpoint and fails over when one is rate-limited. Browse the catalog or go live.

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.

Sources

All guides · Browse all free models

Keep reading

All posts →
Guide

Best free LLM APIs 2026

Ten genuinely free LLM APIs worth using — ranked, with real limits.

Guide

Unlimited free AI tokens?

No free AI API is unlimited. The closest real thing: 10.1 billion free tokens a month behind one key.

Guide

How to get a free LLM API key

Get a working key in minutes — no credit card required.