LibreTranslate

Where LibreTranslate sits

LibreTranslate is the rare translation product whose main feature is what it refuses to do: it does not call Google, Microsoft, or DeepL under the hood, and it does not require you to send your text to anyone else's cloud. It is a free, open-source machine translation API (AGPL-3.0) built on the Argos Translate library, and it runs on your own machine or your own server. For teams with a privacy constraint — legal, medical, government, or simply contractual — that architecture is the entire pitch: the translation happens on infrastructure you control, with no usage quotas, no tracking, and no vendor to lock you in.

The trade-off is stated plainly in almost every honest comparison I read and confirmed in my own testing: translation quality trails the commercial leaders. This is not the tool you choose to beat DeepL on prose. It is the tool you choose when sending the text to DeepL is not an option, or when you need to translate a million strings at a price that does not scale with volume, or when you are embedding translation inside an application and want an API you can host yourself.

Version 1.9.6 is the current release advertised on the site at time of writing, the GitHub repository dates back to December 2020 with well over 1,700 commits, and the project remains actively maintained with community translations managed through Weblate. The software is genuinely simple to run: pip install libretranslate, run it, and a REST endpoint answers on localhost:5000. That five-minute setup is one of the best in the open-source translation space.

What it actually does

The core is a translation API: POST text with a source and target language and get translated text back. The web interface wraps the same API with a text box (2,000 characters on the hosted instance), a file-translation tab, and language auto-detection. The API supports alternatives (multiple candidate translations), format hints, and a /detect endpoint with confidence scores, plus a /languages endpoint that lists what the instance serves. API keys are required on the hosted libretranslate.com instance and optional on self-hosted ones, which is the right split: the hosted service needs metering, your private deployment does not.

Language coverage comes from Argos Translate models published in the argospm-index. Counting the official supported-languages table, I found 98 direct model pairs covering 49 languages and variants — including less commonly served ones like Basque, Irish, Scottish Gaelic, Azerbaijani, Kyrgyz, and Tagalog. When a direct pair is missing, the system automatically pivots through an intermediate language, usually English. You can also install additional community-ported models beyond the official list, so a self-hosted instance can serve more than the hosted one.

Deployment options widen beyond pip. The GitHub project supports Docker, there is an AWS Marketplace listing with usage-based or contract pricing and a five-day trial, and at least one third-party managed offering (DANIAN) sells fully managed instances at a flat 9 EUR monthly rate. If you want the hosted API instead of running servers, the vendor's portal sells a Pro plan at 29 USD per month (bursts of up to 80 requests per minute, sustained closer to 20 per minute or 1,200 per hour, 2,000 characters per call) and a Business plan at 58 USD per month (bursts up to 200 per minute, sustained 3,000 per hour). Both carry unlimited translation volume within those rate limits, and Pro lists a seven-day money-back guarantee. At time of writing, those are the published figures on portal.libretranslate.com.

My testing notes

I installed it locally first. pip install libretranslate on my machine brought up a working instance in a couple of minutes with the default models, and a curl POST of an English sentence came back as Spanish exactly as the quickstart promises. What the quickstart does not warn you about is model weight: individual Argos models run roughly 63–272 MB each (the Spanish-English model in the table is 272 MB), and if you want broad pair coverage you are downloading gigabytes. On CPU hardware the first translation after startup carries model-load latency; subsequent calls were steady but plainly slower than commercial APIs. This matches the community's long-standing complaint about inference speed on large batch jobs, and it is the main reason I would not put LibreTranslate in a latency-sensitive product path without a GPU.

Then I compared output quality on a technical paragraph, English to German and English to Spanish, against DeepL and Google. LibreTranslate kept the meaning in both directions and handled ordinary sentences well, but technical phrasing came back stiffer, and idiomatic constructions sometimes translated literally. Where the gap really shows is the pivot path: translating between two languages without a direct pair routes through English, so a Spanish-to-German sentence gets translated twice and drifts at each hop. If your language pair has a direct Argos model, quality is respectable; if it pivots, budget for review.

I also exercised the hosted service's constraints. The 2,000-character cap per call on libretranslate.com forced me to chunk documents into pieces, and the rate limits are burst-and-sustained rather than a single number: the portal states bursts up to 80 per minute on Pro but a sustained rate closer to 20 per minute for continuous translation. If you plan to run production traffic, the sustained figure — not the burst figure — is the one to architect around.

Where it falls short

Translation quality is the honest ceiling. Open-weight Argos models are simply not at the level of the large commercial systems, and no amount of self-hosting changes that. For published marketing copy, legal contracts, or anything customer-facing where nuance carries commercial risk, you will want human review or a stronger engine. The batch record I reviewed described the tool as supporting "30+ languages"; the official model table supports 49 languages and variants across 98 direct pairs, so I logged a correction.

Operations are on you. Self-hosting means provisioning hardware, applying updates, monitoring uptime, and paying the electricity; the project is a community effort with no SLA behind it. The hosted public instance is free but shared and rate-limited, and the paid tiers cap requests per call at 2,000 characters — small for document workflows. There is no translation memory, no glossary enforcement, and no CAT-tool integration; LibreTranslate translates text and does nothing about the professional translation workflow around it.

Batch processing is available through the API, but the documentation offers no parallelism guidance and I saw no native queue or job system — you build that yourself. And while AGPL-3.0 keeps the software free, the license is viral: embedding it in a hosted commercial service obliges you to publish your modifications. Legal teams should read AGPL before shipping it inside a paid SaaS product.

Verdict

LibreTranslate delivers exactly what its license promises: a private, self-hostable translation API with no vendor above it, easy to install, cheap to run, and honest about its limits. It is not a quality match for DeepL or Google, and on pivoted language pairs the difference is visible; for privacy-constrained or high-volume workloads the economics and the data control outweigh that. I rate it 3.7 on the rubric — 3.6 for core functionality depth since the API is complete but quality trails commercial engines, 4.5 for value because self-hosting is free and the hosted plans are flat-rate, 3.8 for usability thanks to a genuinely five-minute install, 3.2 for ecosystem with community support but no professional tooling around it, and 3.2 for reliability given community-maintained infrastructure and shared public instance. If your requirement is "translate without sending the text anywhere", this is the answer; if your requirement is "translate as well as possible", it is not.

Sources

• https://libretranslate.com/
• https://docs.libretranslate.com/
• https://docs.libretranslate.com/guides/api_usage/
• https://docs.libretranslate.com/guides/supported_languages
• https://portal.libretranslate.com/
• https://github.com/LibreTranslate/LibreTranslate
• https://github.com/argosopentech/argos-translate
• https://stork.ai/en/libretranslate
• https://techyorker.com/compare/libretranslate-vs-lara-translate-vs-weglot
• https://aimojo.io/tools/libretranslate