Self-hosted or cloud API — pick your translation stack with data, not guesswork.
A side-by-side reference for developers weighing LibreTranslate, Lingva, and local LLM runners like Ollama + Llama 3 against Google, DeepL, and Azure — hosting cost, latency at two batch sizes, i18n file support, and accuracy on domain-specific text.
Six engines, one table
Self-hosted engines run on infrastructure you manage; commercial APIs are pay-per-character with no infrastructure to operate. Scroll horizontally to compare all six.
| Feature | LibreTranslate | Lingva | Ollama + Llama 3 | DeepL | Azure | |
|---|---|---|---|---|---|---|
| Deployment & setup | ||||||
| Engine type | Argos Translate (NMT), offline models | Front-end proxy for Google Translate's public endpoint | General-purpose LLM prompted to translate | Neural MT (NMT) + LLM tier | Neural MT, EU-language focus | Neural MT (Microsoft) |
| Setup time | ~20–30 min (Docker run)production hardening: hours | ~15–20 min (Docker/Vercel one-click) | ~10–30 min (install + pull model)production API wrapper: 0.5–2 days | <15 min (API key + SDK call) | <15 min (API key + SDK call) | <15 min (API key + SDK call) |
| Data leaves your infra? | No | Yes — to Google | No | Yes | Yes | Yes |
| Cost model | ||||||
| Pricing basis | Flat infra cost, unlimited volume within capacity | Flat infra cost (minimal — thin proxy) | Flat GPU cost, unlimited volume within throughput | $20 / million charsfirst 500K/mo free | $5.49/mo + $25 / million chars | $10 / million charsfirst 2M/mo free |
| Typical monthly infra cost | $25–350CPU tiers, see Hosting section | ~$5–20small VPS / serverless | ~$277–1,600+per always-on GPU worker | scales with volume | scales with volume | scales with volume |
| Latency (illustrative) | ||||||
| 100-character request | ~130 ms | ~350 ms | ~2.2 s | ~190 ms | ~320 ms | ~90 ms |
| 10,000-character batch | ~3.4 s | ~9.8 s | ~51 s | ~2.6 s | ~3.1 s | ~2.1 s |
| i18n file support | ||||||
| JSON | Pipeline needed | Pipeline needed | Prompt-aware | Pipeline needed | Native | Pipeline needed |
| YAML | Pipeline needed | Pipeline needed | Prompt-aware | Pipeline needed | Pipeline needed | Pipeline needed |
| PO / gettext | Pipeline needed | Pipeline needed | Prompt-aware | Pipeline needed | Pipeline needed | Pipeline needed |
| XLIFF | Pipeline needed | Pipeline needed | Prompt-aware | Pipeline needed | Native (v1.2/2.0/2.1) | Native (v1.0–1.2) |
| Quality & coverage | ||||||
| General BLEU (WMT14 En→De) | 22.4 | ≈ Google (proxy) | domain-dependent | 26.8 | 28.1 | comparable to Google |
| Rate limits | None (self-managed capacity) | None (self-managed capacity) | None (self-managed capacity) | Quota-based, raise on request | Plan-based, no hard cap on Pro | Quota-based, raise on request |
| Offline capable | Yes | No | Yes | No | No | No |
Small requests vs. large batches behave differently
Cloud APIs pay a fixed network round-trip but translate short strings quickly; local LLM runners pay a much larger fixed cost because generation is autoregressive. The gap widens, not narrows, as batch size grows — throughput (chars/sec), not just per-call latency, is what actually matters at scale.
Figures are illustrative, aggregated from published third-party benchmarks (wxrks.com, bakalis.io), not a live test run against these exact endpoints. Batch figures assume single-worker serial processing — cloud APIs and multi-worker self-hosted deployments both parallelize in practice, which lowers wall-clock time for large jobs. Always benchmark your own payloads before committing to a stack.
Quality ranking flips by domain
On general news text, commercial NMT APIs lead. On a video-transcript domain benchmark using COMET-QE, a locally-run Llama 3 model narrowly outscored both Google and DeepL — at roughly 6–7× the latency and 2.4–6.7× less throughput. There is no universal winner; benchmark on your own domain-specific dataset before deciding.
Benchmark your own domain. Academic studies (ACL Findings 2024, PMC clinical-translation study) confirm that MT and LLM engines trade rank depending on domain, document length, and language pair — traditional MT tends to win on surface-level metrics (BLEU/CHRF) while LLMs show relative gains on semantic similarity for some language pairs. Sample 200–500 real segments from your own corpus, score with BLEU/COMET/CHRF against a human reference, and re-run whenever you change providers or models.
What self-hosting actually costs, by tier
Self-hosted engines have a step-function cost: you pay for a capacity tier, not per character. Below that ceiling, more volume is free; above it, you pay for the next tier or another GPU worker.
LibreTranslate — CPU-based, req/s capacity
Ollama + Llama 3 8B — GPU worker, chars/sec throughput
LibreTranslate additionally needs ~10 GB persistent storage for the full language-model set (railway.com). Llama 3 8B needs 6–8 GB VRAM at Q4 quantization minimum (localaimaster.com); GPU worker costs above use published on-demand rates from RunPod and Lambda run 24/7 (×730 hrs/mo). Neither estimate includes engineering/on-call time.
Where does self-hosting start winning?
Set your expected monthly volume and peak traffic spike. We size the self-hosted tier needed to absorb the spike, then compare its flat monthly cost against per-character cloud pricing across the same volume range.
Sizing: at your settings, this needs — (—).
Simplified model: ignores egress bandwidth, engineering/on-call time, SLA requirements, and quality differences between engines. Use it to find a starting range, then validate against your real traffic pattern. See Hosting cost for tier definitions and Sources for pricing references.
Where these numbers come from
Every pricing, latency, and quality figure above traces to one of the sources below. Cloud pricing reflects publicly listed rates at time of writing and changes frequently — always confirm current pricing on the provider's site before budgeting.