Open-source machine translation in 2026

The short version

• DeepL, Google, and Microsoft translation APIs bill per character, and your text passes through their servers.
• LibreTranslate runs the same kind of API on your own instance, so the text stays in-house.
• At 10 million characters a month, Google's API runs about $190 and DeepL about $250; a managed LibreTranslate instance is €9 flat.
• The honest catch is quality: for many language pairs, DeepL and Google read more naturally than LibreTranslate.
• Pick LibreTranslate for privacy, flat cost, and offline or batch work; pick the APIs when fluency on one pair matters more.

Why teams are moving translation off the big APIs in 2026

Three things push teams to look elsewhere. Per-character bills that grow with usage. Text that leaves your servers for a third party. Rate limits on the free tiers. Each one is small on its own. Together they make a managed open-source engine worth a look.

The meters are real, so check them yourself. DeepL's API Pro charges about $25 per million characters, on top of a small monthly base fee (deepl.com/pro-api). Google Cloud Translation charges $20 per million characters after the first 500,000 each month (cloud.google.com/translate/pricing). Microsoft Translator sits near $10 per million. A million characters is roughly 167,000 words.

The free tiers usually give you 500,000 characters a month. That covers testing and small jobs. Production volume passes it fast. And on some free tiers, the provider may keep your text to improve its own models. For sensitive content, that alone is a reason to stop.

The privacy point holds even on paid plans. Paid or free, the text is translated on the provider's servers. Some text cannot leave your walls at all: customer messages, contracts, source strings. For that text, the API model is the wrong fit at any price.

The per-character model is fine until it is not. It scales your bill with your success. It also ties a core function to a vendor's price list and data policy. Both can change without your input. A self-hosted engine takes that decision back.

What self-hosted translation actually means here

A self-hosted translation API runs the model on a server you control. LibreTranslate is the open-source tool most teams reach for. It gives you a REST API and a small web page for manual translations. The text you send is translated on your own instance, not sent to Google, DeepL, or Microsoft.

LibreTranslate is licensed under AGPL-3.0 and has over 15,000 GitHub stars (github.com/LibreTranslate). Its engine is the open-source Argos Translate library, trained with the OpenNMT system. It does not depend on any proprietary service to do the work.

The API is plain. You POST text with a source and target language to <code>/translate</code>. Other endpoints detect the language and list what is supported. You can issue API keys with per-key rate limits, run batch jobs, and read a metrics endpoint for monitoring. There are three ways to run it: a Python package, a Docker image, or a build from source.

There is a portability point worth naming. An open-source engine is not tied to one vendor's roadmap or region list. You can move the instance, change the region, or run it offline, and the API stays the same. That freedom is hard to price, but teams feel it the first time a vendor changes terms.

A quick look at the API

The call is simple. You send text with a source and target language, and get the translation back.

<code>POST /translate
{ "q": "Invoice overdue", "source": "en", "target": "de" }</code></pre>
<p>Two more endpoints round it out. One detects the language of a string. One lists the pairs your instance supports. Most client libraries wrap these for you, in almost any language.

For control, you issue API keys and set a per-key request limit. That lets you give one app a higher rate than another. Batch jobs use the same endpoint, so a nightly run and a live call share one setup.

Honesty first: it is not point-and-click. Running LibreTranslate means a server, dependencies, and ongoing upkeep. That gap is exactly why managed hosting exists, and we come back to it below.

So "alternative" splits three ways. Drop to a cheaper SaaS tier and keep the meter. Self-host the open-source tool and own the upkeep. Or pay for managed open-source and skip both problems. This post is about the last two.

The honest part: where the big APIs still win

Quality is the catch, and it deserves a straight answer. For many language pairs, DeepL and Google produce more natural output than LibreTranslate. DeepL is strong on German, French, Spanish, Italian, Dutch, and Polish. Google covers 249 languages. LibreTranslate's models are open source, and accuracy can fall short of both.

The weak spots are predictable. Idioms, marketing tone, and less-common pairs are where LibreTranslate trails most. It also supports a smaller language set than Google. When a direct pair is not trained, it pivots through English, so Polish to Japanese may route via English and lose nuance on the way.

The proprietary engines also keep improving. Google added a Gemini-based quality step in late 2025 for idioms and conversational text. If you are translating customer-facing copy where fluency sells the work, those engines often earn their per-character cost.

The reason to self-host is not the most natural output. It is three other things: your text stays private, the cost is flat, and you can run offline or in batch. Before you switch, run your own language pairs through both and compare. Quality varies a lot by pair, and yours is the only test that counts.

How to test it on your pairs

Testing takes an afternoon, not a project. Pull a few hundred real strings from your own content. Pick the messy ones: idioms, product terms, short fragments without context. Those break machine translation faster than clean prose.

Run the same set through your current API and through LibreTranslate. Put the two outputs in a sheet, side by side, and have a fluent reader score them. Score by pair, not in aggregate. One pair may pass while another fails.

Judge against your real bar, not perfection. A support reply needs to be understood, not elegant. A marketing headline needs to land. Set the bar per use, and let the scores decide which text you self-host.

Measure speed too, not just quality. Time a batch of realistic size, and watch the latency on single calls. If a live feature needs fast replies, that number sets your instance size. Better to learn it in testing than in production.

The cost math: per-character meter versus €9 flat

Per-character pricing is fine until volume climbs. Most production work passes a million characters quickly. Below is what three monthly volumes cost on each API, next to a flat managed LibreTranslate instance. The gap widens as you translate more, and the flat line never moves.

Per-character rates used: DeepL about $25 per million plus a small base fee; Google $20 per million after 500,000 free; Microsoft about $10 per million. Figures rounded for comparison.

Two API costs hide below the headline rate. DeepL's document endpoint bills a minimum of 50,000 characters per file. A one-line PDF still costs as if it were long. Detection and re-translation after edits add calls too, and none of that applies to a flat instance.

One honest qualifier on the flat line. Flat means no per-character bill. It does not mean infinite speed. Translation is compute-bound, so very heavy or real-time loads may need a larger instance. That is still a flat monthly figure, sized with us, not a meter that counts every character you send.

The other direction matters too. At low volume, the free tiers or a few dollars of usage can beat €9, and the output is often more fluent. If you translate a small amount and privacy is not a hard rule, the proprietary path is the cheaper, better pick. There is no shame in that. You can see flat €9/app pricing and run the numbers against your own usage.

Side by side

Three places this pays off

The trade-off lands differently by use. Three patterns come up most often. Each leans toward self-hosting for the same reason. The text is sensitive, the volume is high, or both.

A support desk translating tickets. Volume is high and steady, so the meter runs all day. The text is customer data you would rather not hand over. A machine draft is enough, since an agent edits before sending.

Docs and user content at scale. A help center or forum can run to tens of millions of characters. Per-character pricing turns that into a real line item. The content is not secret, but the bill is, and a flat instance fixes it.

A private batch corpus. A clinic with patient notes, a firm with client files, a bank with internal reports. This text cannot leave your walls. The API model is ruled out before cost even enters, so self-hosting is the only fit.

LibreTranslate and Weblate do two different jobs

People mix these up, so it helps to separate them. LibreTranslate is the engine. It turns text in one language into another over an API. Weblate is the workflow. It manages the human translation of software strings and content, with version control and review built in.

Weblate is an open-source continuous-localization platform, first released in 2012 and still actively maintained. It tracks strings straight from your git repository, gives translators a web editor, and plugs machine-translation backends in as suggestions. A self-hosted LibreTranslate is one of those backends.

That is the pairing worth knowing. Weblate calls LibreTranslate for a first machine draft, and your translators correct it in Weblate's editor. The machine draft stays private and flat-cost; the human layer adds the quality. Both run at €9/app on DANIAN.

The cost of the pair stays flat too. Weblate at €9 and LibreTranslate at €9 run as two instances you control. Neither has a per-string or per-character meter. A team drafts a big string base by machine, then fixes it by hand, on a flat monthly cost.

Pick by the job. Need to translate UI strings with a team and a review step? That is Weblate. Need to translate text programmatically without a third party? That is LibreTranslate.

How to pick: three questions

Three questions settle most decisions. The honest answers point you to the right tool faster than any feature list.

Does your text need to stay on your own servers? If a privacy rule or a client contract says outside services are off the table, self-hosted wins on the spot. The model runs in your container, and nothing leaves it.

How many characters a month? Past a few million, flat beats metered by a wide margin. Under a million, the free tiers may cost less, so do the arithmetic before you move.

How good must the output be? If fluency closes deals, test DeepL and Google on your pairs first. If a usable machine draft is enough, or humans review afterward, LibreTranslate fits.

What running it yourself involves

Self-hosting is not free in effort, only in licence. The software is open source, but a running service needs work. Knowing the work is the only way to judge whether to do it or buy it.

The list is short but real. You provision a server, install the engine, and update language models as they improve. You handle backups, watch uptime, and apply patches. None of it is exotic, but it is steady upkeep.

Performance: CPU, GPU, and speed

Translation is compute-bound, so hardware sets your speed. LibreTranslate runs on CPU, which is fine for batch jobs and modest live traffic. Heavy real-time volume runs faster on a GPU, at a higher cost. Size the box to your load, and test latency on a real workload before you commit.

Where DANIAN fits

Running LibreTranslate yourself means a server, updates, model management, backups, and monitoring. DANIAN runs that for you at €9 a month. You pick the region from 21 datacenter locations across six continents. We patch the instance, back it up daily off-site, and monitor it. You get the API and the web page; we keep them running.

Model updates are part of the deal. As LibreTranslate ships better language models, we roll them onto your instance. Your output improves with no migration on your side, on the same API and the same flat price.

What we do not do is oversell the engine. Translation quality is still LibreTranslate's, and we will not pretend our hosting makes the output more fluent than the model allows. If you need heavier throughput, we size the instance with you. There is no per-character meter and no surprise bill.

One promise in plain terms: we will not change your instance size or charge you more without your say-so. Card fails? We wait. We do not delete your data.

You also control logging and retention on the instance. If you want request logging off, we set it that way. The text you translate is yours, and where it goes is your call.

See managed LibreTranslate hosting

Common questions

Is LibreTranslate as accurate as DeepL or Google Translate?
For many language pairs, DeepL and Google produce more fluent output than LibreTranslate. LibreTranslate uses open-source models, and its quality can fall short on idioms and less-common pairs. Test your own language pairs before switching. The reason to self-host is privacy, flat cost, and offline use, not the most natural output.

How much can I save by self-hosting translation instead of using an API?
At higher volumes the savings are large, because per-character APIs scale with usage. At 10 million characters a month, Google's API runs about $190 and DeepL about $250. A managed LibreTranslate instance is €9 flat. At low volume the API free tiers can still be cheaper, so check your numbers.

Does my text stay private with self-hosted translation?
Yes, with a self-hosted instance the text is translated on your own server and never sent to Google, DeepL, or Microsoft. That matters when you cannot share customer data, source code, or contracts with a third party. The model runs in your container, so the text stays where you put it.

Can LibreTranslate run offline or in batch?
Yes, LibreTranslate can run fully offline once the language models are loaded. You can bundle the models into the container at build time for an air-gapped setup. It also handles batch translation, so large jobs run on a flat monthly cost instead of a per-character meter.

Which languages does LibreTranslate support?
LibreTranslate supports a few dozen languages, fewer than Google's 249. When a direct pair is not trained, it pivots through English, which can lose nuance. Coverage is widening over time, but check that your exact pairs are supported and good enough before you rely on them.

Do I need a developer to run LibreTranslate?
Running it yourself needs a server, updates, model management, backups, and monitoring. That is real work, and it is the reason many teams pay for managed hosting. DANIAN runs the instance for €9 a month so you get the API and the web page without the upkeep.

How is LibreTranslate different from Weblate?
LibreTranslate is the translation engine, and Weblate is the localization workflow. Weblate manages the human translation of software strings with version control and review. The two pair well: Weblate can call a self-hosted LibreTranslate for first-draft suggestions that translators then correct. Pick by the job you need done.

What happens to my translation costs as volume grows?
With a per-character API, the bill rises every time you translate more text. A flat managed instance holds at €9 a month regardless of character count. Very heavy or real-time loads may need a larger instance, sized with us, but it is still a flat figure, not a meter.

Is LibreTranslate free to use?
LibreTranslate is open source under the AGPL-3.0 license, so the software is free to use, modify, and self-host. Running it still costs server time, updates, and maintenance. A managed instance at DANIAN folds those into €9 per app each month, with no per-character fees.

Is self-hosting worth it if I only translate a little?
Probably not on cost alone. DeepL and Google both offer 500,000 free characters a month, so light users pay nothing through an API. Self-hosting wins when volume is steady, when text must stay private, or when you need offline and batch runs.

Can I self-host DeepL?
No. DeepL does not offer a self-hostable engine, so its translations always run on DeepL servers. If you want a translation API you can run yourself, LibreTranslate is the open-source option. It trails DeepL on some pairs but gives you full control over where text goes.

Is there a self-hosted alternative to Google Translate?
Yes. LibreTranslate is a self-hosted translation API you run on your own server, unlike Google Cloud Translation, which processes text on Google servers and bills $20 per million characters. LibreTranslate covers fewer languages than Google's 249, but it keeps your text in house.

Does LibreTranslate have an API?
Yes. LibreTranslate exposes a REST API. You POST text with a source and target language to /translate, detect a language at /detect, and list supported languages at /languages. You can issue API keys with per-key rate limits and run batch jobs through the same endpoints.

Can LibreTranslate translate whole documents, not just text?
LibreTranslate handles text through its API and can process files, so you are not limited to short strings. DeepL's document endpoint, by contrast, bills a minimum of 50,000 characters per file, which inflates the cost of small documents. A self-hosted instance has no such floor.

Can I improve or customize LibreTranslate's translations?
Yes. LibreTranslate runs on open language models you can update and swap as better ones ship. You can focus on the pairs you actually use and tune the instance for them. On a managed plan, model updates are handled for you, so quality improves without manual work.

What kind of server does LibreTranslate need?
Translation is compute-bound, so hardware sets your speed. LibreTranslate runs on CPU, which handles batch jobs and modest live traffic well. Heavy real-time volume runs faster on a GPU, at a higher cost. On a managed plan, the instance is sized to your load and the price stays flat.

Can I use LibreTranslate for real-time chat or support translation?
Yes, within limits. A CPU instance handles modest live traffic, such as a support inbox or a contact form. High-volume, low-latency chat translation runs better on a larger or GPU-backed instance. The flat monthly price holds either way; only the instance size changes.

Does the flat €9 plan mean unlimited translations?
The price is flat, not the speed. You pay €9 per app each month with no per-character metering, so volume never raises the bill. Throughput is bounded by your instance size, since translation is compute-bound. If you outgrow it, you size up and the price stays flat.

Can I choose the region where my translation server runs?
Yes. At DANIAN you pick the region from 21 datacenter locations across six continents, and you can move the instance later without changing your API calls. Self-hosting keeps the text on a server you control, rather than routing it through a translation provider's network.

Are my translations logged or stored on the instance?
You control logging and retention on a self-hosted instance. LibreTranslate does not need to keep the text it processes, and at DANIAN we turn request logging off if you ask. Unlike some free API tiers, no provider keeps your text to train its own models.

Is LibreTranslate actively maintained?
Yes. LibreTranslate is an active open-source project with over 15,000 GitHub stars and ongoing releases. Because it is open source under AGPL-3.0, the code and its language models stay available even if priorities shift, so you are not tied to one vendor's roadmap.

How hard is it to switch from a translation API to LibreTranslate?
The work is mostly repointing your code. LibreTranslate uses a simple POST to /translate with source and target languages, so a small adapter usually covers the move from DeepL, Google, or Microsoft. Test your real language pairs first, since fluency differs by pair.

Can I connect LibreTranslate to my website or app?
Yes. Anything that can call a REST API can use LibreTranslate, including websites, internal apps, and automation tools. You send text to /translate and read the result, the same way you would call a paid translation API. Batch jobs and live calls share the same endpoint.

What to do this week

Start small. Pick one workload: support tickets, a docs site, or user content. Run it through LibreTranslate on a trial instance. Compare the output to your current API on your own language pairs.

Then decide per piece. If the quality holds and the privacy and cost matter, switch that workload over. If fluency matters more for customer-facing copy, keep the API for that part and self-host the rest. You do not have to move everything at once.

Keep notes as you test. Record the pair, the volume, and your quality score for each workload. In a month that sheet shows which text belongs on a flat instance. The rest stays on the API.

When you are ready to try it, start a 7-day trial and point it at a real workload. We will have the instance running so you can test on day one.

Sources: libretranslate.com, LibreTranslate on GitHub, DeepL API pricing, Google Cloud Translation pricing. Prices change; verify before you budget.

LibreTranslate, Weblate, DeepL, Google, and Microsoft are trademarks of their respective owners. DANIAN provides managed hosting for open-source software and is independent, not affiliated with, sponsored by, or endorsed by these projects or companies.