LibreTranslate vs Argos Translate: Self-Hosted Translation Server Guide 2026

If you need to translate text programmatically but want to avoid sending your data to Google Translate, DeepL, or any cloud-based service, self-hosted translation engines are the answer. In 2026, two open-source projects dominate this space: LibreTranslate and Argos Translate.

Both are free, privacy-respecting, and can run entirely offline. But they serve different use cases. LibreTranslate is a full-featured translation API server with a REST interface, while Argos Translate is a Python library designed for embedding translation into applications. This guide compares them side by side and shows you how to deploy each one.

Why Self-Host Your Translation Service?

Cloud translation APIs are convenient but come with serious trade-offs:

• Data privacy: Every sentence you submit leaves your infrastructure. For businesses handling sensitive contracts, medical records, or legal documents, this is unacceptable.
• Usage limits and costs: Google Translate’s free tier caps at 500,000 characters per month. Beyond that, pricing scales quickly. DeepL’s free plan is limited to 500,000 characters monthly.
• Vendor lock-in: If a provider changes its pricing, deprecates an API version, or shuts down, your application breaks.
• Offline requirements: Environments with restricted or no internet connectivity (industrial networks, air-gapped servers, edge devices) cannot reach cloud APIs at all.
• Regulatory compliance: GDPR, HIPAA, and other data protection regulations may prohibit sending personal or health data to third-party processors.

Running your own translation server eliminates all of these concerns. The trade-off is hardware: translation models require CPU and RAM, especially for high-throughput workloads. But with modern open-source tools, the barrier to entry is lower than ever.

LibreTranslate: The Full-Featured API Server

LibreTranslate is the most popular self-hosted translation API, with over 14,200 GitHub stars and active development (last push: April 2026). It provides a RESTful API compatible with the Google Translate v2 API specification, making it a drop-in replacement for many existing applications.

Key Features

• REST API with OpenAPI/Swagger documentation
• Web-based UI for manual translations
• Supports 30+ language pairs
• API key management with per-key rate limiting
• Docker deployment with one command
• Optional GPU acceleration via CUDA
• Character limit and request rate limiting
• Batch translation support
• Argument/parameter tuning for translation quality

Architecture

LibreTranslate uses the CTranslate2 inference engine under the hood, which is a fast implementation of OpenNMT’s Transformer models. Models are downloaded automatically on first use and cached locally. The server is built with Flask and can handle concurrent requests efficiently.

Supported languages include English, Spanish, French, German, Italian, Portuguese, Russian, Chinese, Japanese, Korean, Arabic, Turkish, and many more. Each language pair has its own model file, typically 50-300 MB.

Argos Translate: The Embeddable Translation Library

Argos Translate is a Python library with around 5,900 GitHub stars, also actively maintained. Rather than being a server, it is designed to be imported directly into Python applications. It uses the same OpenNMT/CTranslate2 foundation as LibreTranslate but exposes a simpler, programmatic API.

Key Features

• Python library — import directly into your code
• Desktop GUI application included (argos-translate-gui)
• Command-line interface for batch file translation
• Supports 50+ language pairs via downloadable packages
• Automatic model package management (argostranslate.package)
• Works on Linux, macOS, and Windows
• Low memory footprint for single translations
• Peer-to-peer model distribution network

Architecture

Argos Translate uses the same underlying CTranslate2 engine but packages models in a custom .argosmodel format. Language pairs are installed via the argostranslate CLI tool or the GUI. The library is lightweight enough to run on a Raspberry Pi, making it ideal for edge deployments.

Feature Comparison Table

Installing LibreTranslate with Docker

The fastest way to get LibreTranslate running is with Docker Compose. Here is the official configuration:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

# docker-compose.yml
services:
  libretranslate:
    container_name: libretranslate
    image: libretranslate/libretranslate:latest
    ports:
      - "5000:5000"
    restart: unless-stopped
    healthcheck:
      test: ['CMD-SHELL', './venv/bin/python scripts/healthcheck.py']
      interval: 10s
      timeout: 4s
      retries: 4
      start_period: 5s
    # Optional: set API keys, character limits, and language filter
    # command: --req-limit 100 --char-limit 5000 --load-only en,fr,de,es
    environment:
      - LT_API_KEYS=true
      - LT_UPDATE_MODELS=true
    volumes:
      - libretranslate_api_keys:/app/db
      - libretranslate_models:/home/libretranslate/.local:rw

volumes:
  libretranslate_api_keys:
  libretranslate_models:

Save this as docker-compose.yml and run:

1

docker compose up -d

The server will be available at http://localhost:5000. On first startup, it downloads the default language models, which may take a few minutes depending on your connection.

Using the LibreTranslate API

Once running, you can translate text via the REST API:

1
2
3
4
5
6
7

curl -X POST "http://localhost:5000/translate" \
  -H "Content-Type: application/json" \
  -d '{
    "q": "Hello, how are you today?",
    "source": "en",
    "target": "fr"
  }'

Response:

1
2
3

{
  "translatedText": "Bonjour, comment allez-vous aujourd'hui?"
}

You can also batch translate multiple strings in a single request:

1
2
3
4
5
6
7

curl -X POST "http://localhost:5000/translate" \
  -H "Content-Type: application/json" \
  -d '{
    "q": ["Hello world", "Good morning", "Thank you"],
    "source": "en",
    "target": "de"
  }'

To manage API keys, use the /manage endpoint or the web UI. Keys can be created, deleted, and assigned custom rate limits.

Reverse Proxy Configuration

For production use, place LibreTranslate behind Nginx or Traefik with TLS termination:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

server {
    listen 443 ssl;
    server_name translate.example.com;

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

    location / {
        proxy_pass http://127.0.0.1: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;
    }
}

Installing Argos Translate

Argos Translate installs as a standard Python package:

1

pip install argostranslate

Installing Language Packages

After installation, update the package index and install language pairs:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

# Update package list
argostranslate -u

# List available languages
argostranslate -a

# Install a specific language pair (e.g., English to French)
argostranslate -i en fr

# Install French to English
argostranslate -i fr en

# List installed packages
argostranslate -l

Using Argos Translate in Python

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

from argostranslate import package, translate

# Update and install language pair if not already installed
package.update_package_index()
available = package.get_available_packages()
en_fr = [p for p in available if p.from_code == 'en' and p.to_code == 'fr'][0]
package.install_from_path(en_fr.download())

# Translate text
translated = translate.translate("Hello, how are you today?", "en", "fr")
print(translated)
# Output: Bonjour, comment allez-vous aujourd'hui?

Using the CLI for Batch Translation

Argos Translate includes a command-line tool for translating files:

1
2
3
4
5

# Translate a text file from English to Spanish
argostranslate --from-lang en --to-lang es < input.txt > output.txt

# Translate an entire directory of files
argostranslate --from-lang en --to-lang de --input-dir ./en_files/ --output-dir ./de_files/

Running as a Simple HTTP Server

Argos Translate does not include a built-in server, but you can wrap it in a lightweight Flask API:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

# translation_server.py
from flask import Flask, request, jsonify
from argostranslate import translate

app = Flask(__name__)

@app.route('/translate', methods=['POST'])
def translate_text():
    data = request.json
    text = data.get('text', '')
    source = data.get('source', 'en')
    target = data.get('target', 'es')
    result = translate.translate(text, source, target)
    return jsonify({'translatedText': result})

if __name__ == '__main__':
    app.run(host='0.0.0.0', port=5000)

Run it with:

1
2

pip install flask
python translation_server.py

Performance and Resource Usage

Resource requirements depend on the language pairs loaded and the concurrent request volume:

For a production server handling dozens of requests per minute, LibreTranslate’s architecture is better suited. For occasional translations embedded within a larger application, Argos Translate’s lower overhead is preferable.

Language Support

Both projects support a wide range of language pairs, though Argos Translate has a slight edge in total coverage thanks to its community-driven package system.

Commonly supported by both: English, Spanish, French, German, Italian, Portuguese, Russian, Chinese (Simplified), Japanese, Korean, Arabic, Turkish, Dutch, Polish, Swedish, Finnish, Norwegian, Danish, Czech, Hungarian, Romanian, Bulgarian, Ukrainian, Hindi, Thai, Vietnamese, Indonesian.

Argos Translate exclusives (via community packages): Several less common language pairs, including African and indigenous languages, are available through the community package registry.

LibreTranslate exclusives: Some language pairs are available only through LibreTranslate’s curated model set, particularly for Asian languages with complex tokenization requirements.

For the most current list of supported languages, check the respective project documentation or run the language listing commands shown above.

Security and Privacy Considerations

Both tools run entirely on your own hardware. No data is ever sent to external servers during translation. This makes them suitable for:

• Healthcare: Translating patient records without HIPAA concerns
• Legal: Processing contracts and legal documents under attorney-client privilege
• Government: Operating within classified or restricted networks
• Enterprise: Avoiding data leakage through third-party API logging
• Personal use: Keeping private communications off cloud servers

LibreTranslate adds an API key layer for multi-tenant environments, allowing you to track and limit usage per client. Argos Translate, being a library, relies on the host application’s authentication mechanisms.

For a comprehensive approach to privacy, consider combining your translation server with other self-hosted infrastructure components. Check out our complete privacy stack guide for a full overview of self-hosted privacy tools.

When to Choose Which Tool

Choose LibreTranslate if:

• You need a shared translation API for multiple applications or users
• You want API key management and rate limiting out of the box
• You prefer a Docker-based deployment with one-command setup
• You need GPU acceleration for high-throughput translation
• You want built-in web UI and API documentation
• You need compatibility with existing Google Translate API clients

Choose Argos Translate if:

• You are building a Python application and want to embed translation directly
• You need to run on resource-constrained hardware (Raspberry Pi, edge devices)
• You want to translate files in batch via the command line
• You prefer the MIT license over AGPL-3.0
• You need a desktop GUI application for manual translations
• You want access to the widest range of community-contributed language pairs

If you are already running self-hosted translation management tools like Weblate or Tolgee for your team’s localization workflow, adding LibreTranslate as a runtime translation backend creates a complete self-hosted translation pipeline. See our Weblate vs Tolgee vs Pootle comparison for the management side of the equation.

For users also interested in other self-hosted text processing tools, the Stirling-PDF toolkit provides document conversion and manipulation capabilities that complement translation workflows nicely.

FAQ

Can LibreTranslate and Argos Translate work offline?

Yes. Both tools download their translation models once and then run entirely offline. LibreTranslate caches models in a Docker volume or local directory. Argos Translate stores models in ~/.local/share/argostranslate. After the initial download, no internet connection is required for translation.

How much RAM do I need to run a self-hosted translation server?

For a single language pair, you need at least 1-2 GB of RAM. For a production LibreTranslate instance with 5-10 language pairs loaded, plan for 4-8 GB of RAM. Argos Translate is more lightweight — it loads only the active language pair, so 1-2 GB is sufficient for most use cases.

Which tool produces better translation quality?

Both use the same underlying CTranslate2 engine and similar OpenNMT Transformer models, so quality is comparable for shared language pairs. LibreTranslate may have slightly better quality for some Asian language pairs due to curated model selection. For most European languages, the difference is negligible.

Can I use LibreTranslate as a drop-in replacement for Google Translate?

LibreTranslate provides API compatibility with the Google Translate v2 API specification. Many applications that support Google Translate can be pointed at a LibreTranslate instance by changing the API endpoint. However, not all features are supported — advanced features like auto-detection reliability and batch limits may differ.

Does Argos Translate support GPU acceleration?

Not natively. Argos Translate runs on CPU by default. If you need GPU acceleration, LibreTranslate is the better choice as it supports CUDA for faster inference on NVIDIA GPUs. For CPU-bound workloads, both tools perform well on modern processors.

How do I add new language pairs?

In LibreTranslate, new models are downloaded automatically when you request a translation in a new language pair (if LT_UPDATE_MODELS=true is set). In Argos Translate, run argostranslate -i <source_lang> <target_lang> to install a specific pair, or use the GUI’s package manager.

What licenses do these tools use?

LibreTranslate is licensed under AGPL-3.0, which requires you to share modifications if you run it as a service. Argos Translate uses the MIT license, which is more permissive and allows proprietary use without source code disclosure. Choose based on your project’s licensing requirements.