Self-Hosted Translation vs DeepL and Google: 2026 Cost

By AIFoss · 10 min read
libretranslatetranslationselfhostedcost-analysisai

TL;DR: Self-hosted machine translation is the cheapest workload in the entire local AI stack — LibreTranslate (AGPL-3.0) runs on a CPU with a few GB of RAM, no GPU, so the hardware floor is $0 on a machine you already own. Against Google Cloud Translation at $20 per million characters, self-hosting wins the moment you translate real volume. Against the free tiers — roughly 500,000 characters a month on Google — it never wins on cost alone. Self-host for privacy, unlimited volume, and offline operation; stay on the API if your bill is $0 and the text isn’t sensitive.

Google Cloud TranslationDeepL APISelf-hosted LibreTranslate
Best forBroad language coverage, pay-as-you-goBest-in-class quality for European languagesUnlimited volume, private, offline
Price / Cost$20/M characters after ~500K free~$32.50/mo Growth plan + ~$27.50/M extra$0 marginal; CPU-only, no GPU needed
The catchEvery document transits Google’s serversPlans restructured mid-2026, no recurring free API tier for new signupsQuality below DeepL, especially on low-resource language pairs

Honest take: translation is the rare local AI workload with no hardware excuse — it runs on the oldest box in your house. But it’s also the workload where cloud free tiers are most generous. If you translate under half a million characters a month of non-sensitive text, the API is free and better. Self-host when the text is private or the volume is real.

This is the translation entry in our cost series, alongside Whisper vs cloud STT, local TTS vs ElevenLabs, and image generation vs cloud APIs. Same method: real prices, verification dates, a hardware floor, and a clear “don’t do this” section. Prices checked October 2026.

What do cloud translation APIs cost in 2026?

Google Cloud Translation’s standard NMT model costs $20.00 per 1,000,000 characters (cloud.google.com/translate/pricing, October 2026), with a free allowance equivalent to about the first 500,000 characters each month ($10 of monthly credit that doesn’t roll over). Google’s newer LLM-based translation is metered separately at $10 per million input characters plus $10 per million output characters — effectively the same ~$20/M for translation, since output length roughly tracks input.

The rest of the field, as of October 2026:

ProviderPriceFree allowanceSource
Google Cloud Translation (NMT)$20.00/M chars~500K chars/mo ($10 credit)Official pricing page
DeepL API Growth~$32.50/mo base + ~$27.50/M extra charsDeveloper plan: 1M chars, one-timeThird-party trackers, Sep 2026
DeepL API Pro (legacy)$5.49/mo + $25.00/M chars500K chars/mo (legacy Free tier)Closed to new signups mid-2026
Azure Translator~$10.00/M chars pay-as-you-goVaries by subscriptionThird-party listings
LibreTranslate hosted API$29/mo Pro, $58/mo BusinessRate-limited public demoportal.libretranslate.com, via third-party listings

Two caveats on that table. DeepL restructured its API plans in mid-2026: the long-standing API Free (500,000 characters/month recurring) and API Pro tiers were discontinued for new signups, replaced by a Developer plan with a one-time 1M-character credit and the Growth plan above. Those figures come from third-party pricing trackers dated September 2026 — deepl.com and azure.microsoft.com were both unreachable from our verification environment, so check the live pages before budgeting around them. Google’s numbers are from its official pricing page.

For scale: 1 million characters is roughly 150,000–170,000 English words — about two novels. A personal workload (emails, articles, the occasional document) rarely clears the free allowances. A product feature, a localization pipeline, or a document archive clears them immediately: translating a 10 GB text corpus through Google’s API is a $200,000 line item at list price.

What does self-hosting LibreTranslate cost to run?

On hardware you already own, the marginal cost is zero — LibreTranslate is CPU-only by default and needs no GPU, which makes it the lowest hardware floor of anything we’ve covered in this series.

LibreTranslate (AGPL-3.0, v1.9.6 as of October 2026) wraps the Argos Translate neural engine in a self-hosted REST API that mirrors the commercial providers’ shape. It supports around 45 languages — third-party counts range from 30+ to 55, and the live demo at libretranslate.com lists the current set. Setup is one command:

$ docker run -d -p 5000:5000 libretranslate/libretranslate
$ curl -s -X POST http://localhost:5000/translate \
    -H "Content-Type: application/json" \
    -d '{"q":"The server is down again","source":"en","target":"de"}'
{"translatedText":"Der Server ist wieder ausgefallen"}

The resource math, from the project’s deployment guides (figures vary slightly by source):

  • RAM is the only real requirement. Budget roughly 200 MB per language pair loaded; all languages at once wants 8 GB+ RAM and ~10 GB of disk for models. Most deployments don’t need that — --load-only en,de,fr (or the LT_LOAD_ONLY environment variable) loads just the pairs you use and runs comfortably in 2–4 GB.
  • Any CPU from the last decade works. Argos Translate’s models are small sequence-to-sequence networks, not LLMs. Translation is fast on CPU; there is no GPU tier to buy into, no VRAM table to consult.
  • A Raspberry Pi-class box or old laptop is genuinely enough for personal volume. For an always-on family or team endpoint, a mini PC drawing ~30W costs about $3–4/month in electricity at the US average residential rate — our always-on server cost breakdown has per-region numbers.
  • No home server? A small 2–4 GB VPS runs a trimmed language set; that’s the entry compute tier at providers like Vultr, a few dollars a month — still an order of magnitude under one million Google-priced characters.

The cost that doesn’t show up in dollars: AGPL-3.0. For personal and internal use it changes nothing. If you embed LibreTranslate in a product you distribute or offer as a service, the copyleft terms apply — our open-weight license guide covers how to think about that class of restriction.

Where is the break-even point?

Self-hosting breaks even immediately at any volume beyond the cloud free tiers, because the hardware floor is $0 — the honest comparison isn’t payback months, it’s whether you ever leave the free tier at all.

Monthly cost by volume, October 2026 prices:

Monthly volumeGoogle Cloud (after free credit)DeepL GrowthLibreTranslate, self-hosted
300K chars (personal)$0~$32.50$0
1M chars (heavy personal)~$10~$32.50$0
5M chars (app feature)~$90~$143$0 (fits in 2 GB RAM)
50M chars (localization pipeline)~$990~$1,380$0–$6 (VPS tier)

Three readings of that table:

  1. Below ~500K characters a month, cloud is free and self-hosting saves nothing. The only reasons to run LibreTranslate at that volume are privacy and offline use — both real, neither financial.
  2. Above the free tier, the gap grows linearly and never stops. There’s no volume discount rescuing the API side: Google’s $20/M rate is flat until 1 billion characters. A 5M-character monthly workload pays Google ~$1,080/year for something an idle corner of an existing machine does for free.
  3. Batch jobs are the extreme case. Re-translating a document archive, subtitles for a video library, or a scraped dataset is exactly the shape of job where API metering explodes and a local box quietly grinds through it overnight for pennies of electricity.

What quality do you give up?

The honest answer: Argos Translate sits below DeepL and Google on translation quality, and the gap widens on low-resource language pairs — this is the real price of the $0 marginal cost.

For high-resource pairs (English↔Spanish, English↔German, English↔French), LibreTranslate’s output is serviceable: readable, occasionally awkward, fine for gist, internal tooling, and UI strings you’ll review anyway. For morphology-heavy or low-resource pairs, expect visibly rougher output than DeepL, whose lead on European-language quality is the main thing its pricing buys. We’re deliberately not quoting BLEU scores here — public head-to-head benchmarks for the current model versions are thin, and translation quality is pair-specific. Test your actual language pair on the libretranslate.com demo against DeepL’s free web translator before committing a workflow to either.

One alternative worth knowing: a local LLM through Ollama translates too, often better than Argos for context-heavy text — at 100x the hardware cost and a fraction of the speed. If you already run a local LLM stack, try your 8B+ model on your language pair before adding another service; if translation is the only job, a dedicated LLM box is wildly oversized.

When should you NOT self-host translation?

Skip self-hosting when any of these hold:

  • Your volume fits the free tiers and the text isn’t sensitive. Google’s ~500K characters/month covers most personal use at literally $0. Running a server to save $0 is a hobby, not a savings plan.
  • Output quality is customer-facing. Marketing copy, legal documents, support replies — the quality gap to DeepL is real, and a mistranslation in front of a customer costs more than $20/M characters. Use DeepL or a human for those.
  • You need a language pair Argos covers poorly or not at all. ~45 languages sounds like a lot until your pair isn’t in it; Google covers 240+.
  • You’d be shipping it inside a commercial product without reading the AGPL. The license is the cost. Budget a legal-review hour or use the hosted LibreTranslate API ($29/month), which exists largely to make that problem go away while funding development.

The flip side — self-host without hesitation when the text is private (contracts, medical, internal docs; the same logic as our self-hosted privacy stack), when volume is unbounded, or when the workload must run offline.

What to actually buy

Prices as of October 2026, all taken from the comparison above:

Your situationThe setupPriceWhere
Any existing machine with 2 GB RAM freeLibreTranslate in Docker, trimmed language set$0Command above
Need an always-on endpoint, no home server2–4 GB VPS running LibreTranslateA few $/moVultr
Under 500K chars/mo, public textGoogle Cloud Translation free allowance$0cloud.google.com/translate
Quality-critical European-language workDeepL API Growth~$32.50/modeepl.com

FAQ

Does LibreTranslate need a GPU? No. LibreTranslate runs on CPU by default and that’s how nearly everyone deploys it. The Argos Translate models behind it are small enough that CPU inference is fast; RAM (roughly 200 MB per loaded language) is the binding constraint, not compute.

Is LibreTranslate really free for commercial use? The software is AGPL-3.0: free to use, including commercially, but if you offer it to users over a network as part of a product, the copyleft source-sharing terms apply to your modifications. Internal company use is uncontroversial; embedding it in a SaaS deserves a license review. The hosted API plans ($29–$58/month) are the project’s own escape hatch.

Is self-hosted translation quality good enough to replace DeepL? For gist, internal tools, and high-resource pairs like English↔Spanish — usually yes. For customer-facing or nuance-critical text — usually no. Quality is pair-specific, so run your own ten-sentence test on both before deciding; it takes five minutes and settles the question better than any benchmark.

Sources

Was this article helpful?

What self-hosting actually costs

Real cost breakdowns for self-hosted AI: hardware floors, power, maintenance hours, and the honest comparison against paying for it. No spam, unsubscribe anytime.