LibreTranslate: Self-Hosted Translation API with 14.4K+ Stars — Production Deployment Guide 2026

{{< resource-info >}}

LibreTranslate is a free, open-source machine translation API that you host yourself. No API keys from Google. No per-character billing from DeepL. No data leaving your infrastructure. With 14,400+ GitHub stars and an active release cycle (v1.9.5 as of May 2026), it has become the default choice for developers who need private, offline-capable translation at zero marginal cost. This LibreTranslate tutorial covers everything from libretranslate setup to libretranslate docker production deployment, with benchmarks and integration guides. We also include a detailed libretranslate vs deepl comparison to help you decide if self-hosted translation fits your use case.

What Is LibreTranslate? #

LibreTranslate is a self-hosted REST API for machine translation, built on top of the open-source Argos Translate engine. It provides a drop-in alternative to proprietary translation services, with a simple HTTP interface, a built-in web UI, and support for 30+ languages. The project is licensed under AGPL-3.0 and is actively maintained by the LibreTranslate organization.

Unlike cloud-based translation APIs, LibreTranslate runs entirely on your hardware. All text processing happens locally, making it suitable for privacy-sensitive applications, air-gapped networks, and compliance-heavy industries. The project was started as a response to the lack of privacy-respecting translation tools and has grown into a production-ready platform used by enterprises, governments, and individual developers.

How LibreTranslate Works #

LibreTranslate’s architecture is straightforward: a Python Flask backend serves a REST API, while the translation heavy lifting is handled by Argos Translate’s neural machine translation (NMT) models. These models are downloaded on first run and cached locally, enabling offline operation after initial setup.

Core Architecture #

┌─────────────────┐     ┌──────────────────┐     ┌─────────────────┐
│   Client (Web)  │────▶│  Flask REST API  │────▶│ Argos Translate │
│   / API Call    │◀────│    (Port 5000)   │◀────│   (NMT Engine)  │
└─────────────────┘     └──────────────────┘     └─────────────────┘
                                                        │
                              ┌─────────────────────────┘
                              ▼
                        ┌──────────────┐
                        │ Language     │
                        │ Models (~2GB)│
                        └──────────────┘

Key Components #

• Flask API Server: Handles HTTP requests, authentication, rate limiting, and request validation.
• Argos Translate Engine: The NMT backend that loads language pair models and performs inference.
• Language Models: Pre-trained OpenNMT models for each language pair, downloadable on demand.
• SQLite Database: Stores API keys, request logs, and usage statistics when API key management is enabled.

Translation requests flow through the system as follows: the client sends a JSON payload with the source text, source language, and target language. The API validates the request, routes it to the appropriate Argos model, and returns the translated text along with metadata such as confidence scores and detected language.

Installation & Setup #

LibreTranslate offers multiple deployment paths. The Docker route is recommended for production due to its isolation, reproducibility, and ease of updates.

System Requirements #

Docker Quick Start #

The fastest way to get LibreTranslate running locally:

# Run with Docker
docker run -ti --rm -p 5000:5000 \
  -v lt-models:/home/libretranslate/.local \
  -e LT_LOAD_ONLY=en,es,fr \
  libretranslate/libretranslate:latest

After startup, open http://localhost:5000 in your browser. The first run downloads language models, so expect a brief delay before the UI becomes responsive.

Production Docker Compose #

For a production deployment, use a dedicated docker-compose.yml with persistent volumes, health checks, and resource limits:

# docker-compose.yml - Production Setup
version: '3.8'

services:
  libretranslate:
    container_name: libretranslate
    image: libretranslate/libretranslate:v1.9.5
    restart: unless-stopped
    ports:
      - "5000:5000"
    environment:
      - LT_LOAD_ONLY=en,es,fr,de,it,zh,ja,ru,pt,pl,nl
      - LT_API_KEYS=true
      - LT_REQ_LIMIT=60
      - LT_THREADS=4
      - LT_UPDATE_MODELS=true
    volumes:
      - lt-models:/home/libretranslate/.local
      - lt-db:/app/db
    healthcheck:
      test: ['CMD-SHELL', './venv/bin/python scripts/healthcheck.py']
      interval: 30s
      timeout: 10s
      retries: 3
      start_period: 60s
    deploy:
      resources:
        limits:
          memory: 4G
        reservations:
          memory: 2G

volumes:
  lt-models:
  lt-db:

Deploy with:

docker compose up -d

GPU-Accelerated Deployment (CUDA) #

For high-throughput scenarios, LibreTranslate supports NVIDIA GPU acceleration via CUDA. Requirements: NVIDIA GPU with CUDA 11.2+ and nvidia-docker2 installed.

# Clone the repository
git clone https://github.com/LibreTranslate/LibreTranslate.git
cd LibreTranslate

# Build and run CUDA-enabled version
docker compose -f docker-compose.cuda.yml up -d --build

Verify GPU utilization:

nvidia-smi

Native Python Installation #

For development or environments where Docker is not available:

# Install via pip
pip install libretranslate==1.9.5

# Start the server
libretranslate --host 0.0.0.0 --port 5000 \
  --load-only en,es,fr,de \
  --req-limit 60 \
  --threads 4

Or build from source:

git clone https://github.com/LibreTranslate/LibreTranslate.git
cd LibreTranslate
pip install -e .
python main.py --host 0.0.0.0 --port 5000

Deploy to DigitalOcean (Production Cloud) #

For a cloud-hosted production instance, DigitalOcean provides an easy path with their App Platform or Droplets. Deploy using the 1-Click Docker image:

# On a fresh Ubuntu 24.04 Droplet
curl -fsSL https://get.docker.com | sh
mkdir -p ~/libretranslate && cd ~/libretranslate

# Create production compose file
cat > docker-compose.yml << 'EOF'
version: '3.8'
services:
  libretranslate:
    image: libretranslate/libretranslate:v1.9.5
    restart: always
    ports:
      - "5000:5000"
    environment:
      - LT_LOAD_ONLY=en,es,fr,de,it,zh,ja,ru,pt
      - LT_API_KEYS=true
      - LT_REQ_LIMIT=120
      - LT_THREADS=4
    volumes:
      - ./models:/home/libretranslate/.local
      - ./db:/app/db
EOF

docker compose up -d

Note: If you’re setting up a new VPS, DigitalOcean offers $200 in free credits for new users, which covers several months of a 4GB Droplet running LibreTranslate 24/7.

Integration with Popular Tools #

LibreTranslate’s REST API makes it compatible with virtually any stack. Below are integration examples for common workflows.

Python SDK Usage #

# translate_client.py
import requests

LIBRETRANSLATE_URL = "http://localhost:5000/translate"

def translate_text(text: str, source: str = "en", target: str = "es") -> str:
    payload = {
        "q": text,
        "source": source,
        "target": target,
        "format": "text",
        "api_key": ""  # Add your API key if enabled
    }
    headers = {"Content-Type": "application/json"}

    response = requests.post(LIBRETRANSLATE_URL, json=payload, headers=headers)
    response.raise_for_status()
    return response.json()["translatedText"]

# Example usage
if __name__ == "__main__":
    result = translate_text("Hello, production deployment!", "en", "de")
    print(f"Translated: {result}")

JavaScript/TypeScript Integration #

// libretranslate-client.ts
interface TranslateResponse {
  translatedText: string;
}

class LibreTranslateClient {
  private baseUrl: string;
  private apiKey?: string;

  constructor(baseUrl: string = "http://localhost:5000", apiKey?: string) {
    this.baseUrl = baseUrl;
    this.apiKey = apiKey;
  }

  async translate(
    text: string,
    source: string = "en",
    target: string = "es"
  ): Promise<string> {
    const response = await fetch(`${this.baseUrl}/translate`, {
      method: "POST",
      headers: { "Content-Type": "application/json" },
      body: JSON.stringify({
        q: text,
        source,
        target,
        format: "text",
        api_key: this.apiKey,
      }),
    });

    if (!response.ok) {
      throw new Error(`Translation failed: ${response.statusText}`);
    }

    const data: TranslateResponse = await response.json();
    return data.translatedText;
  }
}

// Usage
const client = new LibreTranslateClient("http://localhost:5000");
const result = await client.translate("Deploy to production", "en", "fr");
console.log(result); // "Déployer en production"

OpenAI Whisper Audio-to-Translated-Text Pipeline #

A common pattern is combining speech recognition with translation. Here is a complete pipeline using Whisper for transcription and LibreTranslate for translation:

# whisper_translate_pipeline.py
import whisper
import requests

WHISPER_MODEL = whisper.load_model("base")
LIBRE_URL = "http://localhost:5000/translate"

def transcribe_and_translate(audio_path: str, target_lang: str = "en") -> dict:
    # Step 1: Transcribe audio with Whisper
    result = WHISPER_MODEL.transcribe(audio_path)
    source_text = result["text"]
    detected_lang = result.get("language", "auto")

    # Step 2: Translate with LibreTranslate
    payload = {
        "q": source_text,
        "source": detected_lang,
        "target": target_lang,
        "format": "text"
    }
    response = requests.post(LIBRE_URL, json=payload)
    translated = response.json()["translatedText"]

    return {
        "original": source_text,
        "translated": translated,
        "source_language": detected_lang,
        "target_language": target_lang
    }

# Run pipeline
output = transcribe_and_translate("meeting.mp3", target_lang="es")
print(f"ES: {output['translated']}")

Coqui TTS Integration (Translation + Speech Synthesis) #

Translate text and synthesize speech in the target language:

# translate_and_speak.py
import requests
from TTS.api import TTS

# Initialize TTS
tts = TTS("tts_models/multilingual/multi-dataset/xtts_v2", gpu=False)

def translate_and_speak(text: str, target_lang: str, speaker_wav: str):
    # Translate
    payload = {"q": text, "source": "en", "target": target_lang, "format": "text"}
    response = requests.post("http://localhost:5000/translate", json=payload)
    translated = response.json()["translatedText"]

    # Synthesize speech
    output_path = f"output_{target_lang}.wav"
    tts.tts_to_file(
        text=translated,
        speaker_wav=speaker_wav,
        language=target_lang,
        file_path=output_path
    )
    return output_path

# Generate multilingual audio
for lang in ["es", "fr", "de"]:
    translate_and_speak("Welcome to our service", lang, "reference.wav")

cURL API Examples #

# Basic translation
curl -X POST http://localhost:5000/translate \
  -H "Content-Type: application/json" \
  -d '{"q": "Hello world", "source": "en", "target": "es"}'

# Response: {"translatedText": "Hola mundo"}

# Detect language
curl -X POST http://localhost:5000/detect \
  -H "Content-Type: application/json" \
  -d '{"q": "Bonjour le monde"}'

# Get supported languages
curl http://localhost:5000/languages

# Translate with API key (if enabled)
curl -X POST http://localhost:5000/translate \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer your-api-key" \
  -d '{"q": "Production deployment", "source": "en", "target": "de"}'

# HTML translation
curl -X POST http://localhost:5000/translate \
  -H "Content-Type: application/json" \
  -d '{
    "q": "<p>Hello <b>world</b></p>",
    "source": "en",
    "target": "fr",
    "format": "html"
  }'

Nginx Reverse Proxy Configuration #

For production deployments behind a domain with HTTPS:

# /etc/nginx/sites-available/libretranslate
server {
    listen 443 ssl http2;
    server_name translate.yourdomain.com;

    ssl_certificate /etc/letsencrypt/live/yourdomain.com/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/yourdomain.com/privkey.pem;

    client_max_body_size 50M;

    location / {
        proxy_pass http://localhost:5000;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
        proxy_read_timeout 300s;
    }
}

# Redirect HTTP to HTTPS
server {
    listen 80;
    server_name translate.yourdomain.com;
    return 301 https://$server_name$request_uri;
}

Enable the configuration:

sudo ln -s /etc/nginx/sites-available/libretranslate /etc/nginx/sites-enabled/
sudo nginx -t && sudo systemctl reload nginx

Benchmarks / Real-World Use Cases #

LibreTranslate performance varies significantly based on hardware configuration, loaded languages, and text length. Below are measured benchmarks from production deployments.

Translation Speed Benchmarks #

Translation Quality Comparison #

BLEU score comparison on WMT14 English-to-German test set (higher is better):

LibreTranslate matches Argos Translate CLI performance exactly, since they share the same engine. The quality gap versus commercial APIs is measurable but narrowing: on common European language pairs, LibreTranslate produces acceptable translations for most use cases. The gap widens for less common language pairs, technical domain text, and nuanced creative content.

Cost Analysis at Scale #

The economic argument for LibreTranslate strengthens proportionally with volume. At 100M+ characters per month, self-hosting is 10-50x cheaper than commercial alternatives.

Real-World Use Cases #

• Government agencies: Processing confidential documents without data exfiltration risks.
• Healthcare systems: Translating patient records under HIPAA/GDPR constraints.
• E-commerce platforms: Bulk translation of product catalogs at zero per-item cost.
• Content management systems: Real-time translation of user-generated content.
• Research institutions: Processing multilingual academic papers on internal infrastructure.
• Mobile app backends: Low-latency translation for travel and communication apps.

Advanced Usage / Production Hardening #

Running LibreTranslate in production requires attention to security, scaling, and monitoring.

API Key Management #

Enable API key authentication to control access and prevent abuse:

# docker-compose.yml with API keys
services:
  libretranslate:
    image: libretranslate/libretranslate:v1.9.5
    environment:
      - LT_API_KEYS=true
      - LT_REQ_LIMIT=100
      - LT_REQ_LIMIT_PER_DAY=10000
    volumes:
      - lt-models:/home/libretranslate/.local
      - lt-db:/app/db

Generate and manage API keys via the database or the admin interface.

Custom Model Loading #

Control memory usage by loading only required languages:

# Load only European languages
LT_LOAD_ONLY=en,es,fr,de,it,pt,nl,pl,ru docker compose up -d

# Load Asian + European languages
LT_LOAD_ONLY=en,ja,zh,ko,es,fr,de docker compose up -d

Health Monitoring #

LibreTranslate includes a built-in health check endpoint:

# Check service health
curl http://localhost:5000/health

# Expected response: {"status": "ok"}

For Prometheus-based monitoring, add a simple exporter:

# prometheus_exporter.py
from prometheus_client import start_http_server, Counter, Histogram
import requests
import time

TRANSLATION_COUNTER = Counter('libretranslate_requests_total', 'Total translations')
LATENCY_HISTOGRAM = Histogram('libretranslate_latency_seconds', 'Translation latency')

def monitor():
    start_http_server(9090)
    while True:
        start = time.time()
        requests.post("http://localhost:5000/translate",
            json={"q": "test", "source": "en", "target": "es"})
        LATENCY_HISTOGRAM.observe(time.time() - start)
        TRANSLATION_COUNTER.inc()
        time.sleep(30)

if __name__ == "__main__":
    monitor()

Auto-Scaling with Kubernetes #

For high-availability deployments, use Kubernetes with Horizontal Pod Autoscaler:

# libretranslate-deployment.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: libretranslate
spec:
  replicas: 2
  selector:
    matchLabels:
      app: libretranslate
  template:
    metadata:
      labels:
        app: libretranslate
    spec:
      containers:
      - name: libretranslate
        image: libretranslate/libretranslate:v1.9.5
        ports:
        - containerPort: 5000
        env:
        - name: LT_LOAD_ONLY
          value: "en,es,fr,de,it"
        - name: LT_THREADS
          value: "4"
        resources:
          requests:
            memory: "2Gi"
            cpu: "1000m"
          limits:
            memory: "4Gi"
            cpu: "2000m"
        livenessProbe:
          httpGet:
            path: /health
            port: 5000
          initialDelaySeconds: 60
          periodSeconds: 30
---
apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
  name: libretranslate-hpa
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: libretranslate
  minReplicas: 2
  maxReplicas: 10
  metrics:
  - type: Resource
    resource:
      name: cpu
      target:
        type: Utilization
        averageUtilization: 70

Deploy:

kubectl apply -f libretranslate-deployment.yaml

Backup Strategy #

Language models can be re-downloaded, but the SQLite database with API keys and logs should be backed up:

#!/bin/bash
# backup.sh - Daily backup cron job
BACKUP_DIR="/backups/libretranslate"
DATE=$(date +%Y%m%d)

# Backup database
docker cp libretranslate:/app/db "$BACKUP_DIR/db_$DATE.sqlite"

# Sync models (optional - can be re-downloaded)
rsync -av /var/lib/docker/volumes/lt-models/_data/ "$BACKUP_DIR/models/"

# Keep only 7 days of backups
find "$BACKUP_DIR" -name "db_*.sqlite" -mtime +7 -delete

Add to crontab:

0 2 * * * /path/to/backup.sh

Comparison with Alternatives #

LibreTranslate fills a specific niche: it is the only option that combines a REST API, web UI, GPU acceleration, and full offline capability under an open-source license. Argos Translate offers the same translation engine but lacks the API layer. Google and DeepL offer superior quality and broader language support, but at the cost of privacy, recurring fees, and external dependency.

Limitations / Honest Assessment #

LibreTranslate is not a universal replacement for commercial translation APIs. Understanding its limitations is essential for making an informed adoption decision.

Translation quality gap: On the WMT14 benchmark, LibreTranslate trails DeepL by approximately 5.7 BLEU points and Google Translate by 4.4 points. This gap is most noticeable for: (1) less common language pairs like English to Swahili or Finnish to Vietnamese, (2) domain-specific terminology in legal, medical, or technical texts, and (3) creative or idiomatic content where context and nuance matter.

Resource intensity: Each loaded language pair consumes 300-600MB of RAM. A full 30-language deployment requires 8GB+ of memory. This makes LibreTranslate unsuitable for resource-constrained environments like Raspberry Pi (unless loading only 2-3 languages) or small VPS instances.

Language coverage: With 30+ languages, LibreTranslate covers the most common language pairs but falls far short of Google Translate’s 130+ languages. If your use case requires translation for minority or endangered languages, LibreTranslate is not sufficient.

No real-time streaming: LibreTranslate processes complete text segments. It does not support streaming translation or real-time speech-to-text translation, which limits its applicability in live conversation scenarios.

AGPL-3.0 license implications: The AGPL-3.0 license requires that any network use of the software (including via API) triggers the share-alike requirement. Organizations building proprietary products on top of LibreTranslate should consult legal counsel regarding license compliance.

Maintenance burden: Self-hosting means you are responsible for updates, security patches, model updates, and infrastructure monitoring. Factor in operational overhead when comparing costs against managed APIs.

Frequently Asked Questions #

How does LibreTranslate compare to running Argos Translate directly? #

LibreTranslate is essentially a REST API wrapper around Argos Translate. If you only need command-line translation, Argos Translate has lower overhead. If you need an HTTP API, web interface, or multi-user access, LibreTranslate adds those layers. Both share identical translation models and produce identical output.

Can LibreTranslate run on a Raspberry Pi? #

Yes, with constraints. The ARM Docker image is optimized for ARM64 systems. Load only 2-3 language pairs to keep memory usage under 2GB. Expect translation latency of 800ms-1.5s per request on a Raspberry Pi 4 with 4GB RAM. For production use, a minimum of 4GB RAM is recommended.

How do I update language models without restarting the container? #

Set the LT_UPDATE_MODELS=true environment variable. LibreTranslate checks for model updates on startup. For rolling updates in a Kubernetes deployment, use a rolling restart strategy: update the deployment with the new image version, and Kubernetes replaces pods incrementally.

What is the maximum text length per translation request? #

The default maximum is configurable via the --char-limit flag or LT_CHAR_LIMIT environment variable. The built-in default is 10,000 characters per request. For longer documents, split the text into chunks and make sequential API calls.

Is LibreTranslate suitable for HIPAA or GDPR compliance? #

LibreTranslate’s self-hosted nature means no data leaves your infrastructure, which simplifies compliance. However, compliance is a system-level property, not just a software property. You must also secure the host OS, network, backups, and access controls. Consult your compliance officer for a full assessment.

How do I add a custom language model? #

LibreTranslate supports models in the Argos Translate format (OpenNMT CTranslate2 models). Place custom .argosmodel files in the models directory and restart the container. Custom models are useful for domain-specific terminology or languages not covered by the default model set.

Can I use LibreTranslate with a frontend framework like React or Vue? #

Yes. The /translate endpoint accepts JSON and supports CORS when configured. Example React hook:

// useTranslation.ts
import { useState, useCallback } from "react";

export function useTranslation() {
  const [translating, setTranslating] = useState(false);

  const translate = useCallback(async (text: string, source: string, target: string) => {
    setTranslating(true);
    try {
      const res = await fetch("http://localhost:5000/translate", {
        method: "POST",
        headers: { "Content-Type": "application/json" },
        body: JSON.stringify({ q: text, source, target }),
      });
      const data = await res.json();
      return data.translatedText;
    } finally {
      setTranslating(false);
    }
  }, []);

  return { translate, translating };
}

What are the network requirements for an offline deployment? #

For fully offline operation, build the Docker image with --build-arg with_models=true to embed language models during the build. The resulting image contains all necessary files and requires no internet connection at runtime. Image size increases by approximately 2-3GB depending on the number of included languages.

Conclusion #

LibreTranslate delivers on its core promise: a capable, self-hosted translation API with zero per-request costs and complete data privacy. With 14,400+ GitHub stars, active maintenance, and v1.9.5 delivering stability improvements, it is production-ready for teams that prioritize control over absolute translation quality.

The ideal LibreTranslate adopter is a team with: (1) consistent translation volume that makes per-character pricing painful, (2) strict data residency requirements, (3) DevOps capacity to manage infrastructure, and (4) tolerance for a measurable but acceptable quality gap versus commercial alternatives.

If that describes your situation, start with the Docker Compose setup in this guide, load 5 languages, and measure translation quality against your specific content. Most teams find the quality adequate for internal tools, product catalogs, and user-generated content.

For teams that need the absolute highest translation quality or support for 100+ languages, commercial APIs remain the pragmatic choice. For everyone else, LibreTranslate eliminates a recurring line item from your cloud bill.

Join the LibreTranslate Telegram group for community support, or follow the project on GitHub for release updates.

Recommended Hosting & Infrastructure #

Before you deploy any of the tools above into production, you’ll need solid infrastructure. Two options dibi8 actually uses and recommends:

• DigitalOcean — $200 free credit for 60 days across 14+ global regions. The default option for indie devs running open-source AI tools.
• HTStack — Hong Kong VPS with low-latency access from mainland China. This is the same IDC that hosts dibi8.com — battle-tested in production.

Affiliate links — they don’t cost you extra and they help keep dibi8.com running.

Sources & Further Reading #

• LibreTranslate GitHub Repository
• LibreTranslate Official Documentation
• Argos Translate GitHub Repository
• LibreTranslate Docker Hub
• OpenNMT Framework Documentation
• AGPL-3.0 License Summary
• DigitalOcean Docker Deployment Guide
• NVIDIA CUDA Docker Setup
• LibreTranslate Kubernetes Examples

Disclosure: This article contains affiliate links. If you sign up for DigitalOcean using the referral link in this guide, we may receive a commission at no additional cost to you. Affiliate links help support the ongoing maintenance of open-source documentation projects like this one.