You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
Piero Toffanin 393eebe235
Merge pull request #283 from jonwiggins/main
15 hours ago
.github/workflows prevent github action error with python 3.10 recognized as python 3.1 2 months ago
app Merge pull request #279 from SethFalco/chores-2 2 weeks ago
docker Add cuda pytorch install 16 hours ago
tests add more tests for /translate 3 months ago
.dockerignore Keep license 8 months ago
.editorconfig chore: add editorconfig 6 months ago
.gitattributes Add .gitattributes 3 months ago
.gitignore Save suggestions in a database 9 months ago
.gitmodules Removed models submodule 1 year ago
Dockerfile Added models include option in docker build 3 months ago Update 8 months ago
LICENSE Initial commit 2 years ago Add --get-api-key-link 2 weeks ago Update 2 months ago
VERSION Bump version (2) 2 months ago
docker-compose.cuda.yml Add CUDA docker version 2 weeks ago
docker-compose.yml Add Dockerfile to build and run LibreTranslate as a Docker image. Also added a docker-compose.yml file to provide a reproducible way to run the Docker image. And finally added how to build and run the Docker image to the Tested with local deployment on port 5000 and public HTTPS deployment using a docker based nginx-proxy 2 years ago Fix (2) 3 months ago Update 1 year ago API keys support, bug fixes, improvements 1 year ago
requirements.txt Add --api-keys-remote 2 weeks ago
setup.cfg Update setup.cfg 1 year ago Merge pull request #254 from dingedi/feature/add-python3-10 2 months ago Extract JSONL from suggestions.db script 1 month ago wsgi support 1 year ago


Try it online! | API Docs | Community Forum

Python versions Run tests Build and Publish Docker Image Publish package Awesome Humane Tech

Free and Open Source Machine Translation API, entirely self-hosted. Unlike other APIs, it doesn't rely on proprietary providers such as Google or Azure to perform translations. Instead, its translation engine is powered by the open source Argos Translate library.


Try it online! | API Docs

API Examples



const res = await fetch("", {
	method: "POST",
	body: JSON.stringify({
		q: "Hello!",
		source: "en",
		target: "es"
	headers: { "Content-Type": "application/json" }

console.log(await res.json());


    "translatedText": "¡Hola!"

Auto Detect Language


const res = await fetch("", {
	method: "POST",
	body: JSON.stringify({
		q: "Ciao!",
		source: "auto",
		target: "en"
	headers: { "Content-Type": "application/json" }

console.log(await res.json());


    "detectedLanguage": {
        "confidence": 83,
        "language": "it"
    "translatedText": "Bye!"

HTML (beta)


const res = await fetch("", {
	method: "POST",
	body: JSON.stringify({
		q: '<p class="green">Hello!</p>',
		source: "en",
		target: "es",
		format: "html"
	headers: { "Content-Type": "application/json" }

console.log(await res.json());


    "translatedText": "<p class=\"green\">¡Hola!</p>"

Install and Run

You can run your own API server with just a few lines of setup!

Make sure you have Python installed (3.8 or higher is recommended), then simply run:

pip install libretranslate
libretranslate [args]

Then open a web browser to http://localhost:5000

If you're on Windows, we recommend you Run with Docker instead.

On Ubuntu 20.04 you can also use the install script available at

If you would rather run it natively, you can follow the guide here.

Build and Run

If you want to make changes to the code, you can build from source, and run the API:

git clone
cd LibreTranslate
pip install -e .
libretranslate [args]

# Or
python [args]

Then open a web browser to http://localhost:5000

Run with Docker

Simply run:

docker run -ti --rm -p 5000:5000 libretranslate/libretranslate

Then open a web browser to http://localhost:5000

Build with Docker

docker build [--build-arg with_models=true] -t libretranslate .

If you want to run the Docker image in a complete offline environment, you need to add the --build-arg with_models=true parameter. Then the language models are downloaded during the build process of the image. Otherwise these models get downloaded on the first run of the image/container.

Run the built image:

docker run -it -p 5000:5000 libretranslate [args]

Or build and run using docker-compose:

docker-compose up -d --build

Feel free to change the docker-compose.yml file to adapt it to your deployment needs, or use an extra file for your deployment configuration.


You can use hardware acceleration to speed up translations on a GPU machine with CUDA 11.2 and nvidia-docker installed.

Run this version with:

docker-compose -f docker-compose.cuda.yml up -d --build


Argument Description Default Env. name
--host Set host to bind the server to LT_HOST
--port Set port to bind the server to 5000 LT_PORT
--char-limit Set character limit No limit LT_CHAR_LIMIT
--req-limit Set maximum number of requests per minute per client No limit LT_REQ_LIMIT
--batch-limit Set maximum number of texts to translate in a batch request No limit LT_BATCH_LIMIT
--ga-id Enable Google Analytics on the API client page by providing an ID No tracking LT_GA_ID
--debug Enable debug environment False LT_DEBUG
--ssl Whether to enable SSL False LT_SSL
--frontend-language-source Set frontend default language - source en LT_FRONTEND_LANGUAGE_SOURCE
--frontend-language-target Set frontend default language - target es LT_FRONTEND_LANGUAGE_TARGET
--frontend-timeout Set frontend translation timeout 500 LT_FRONTEND_TIMEOUT
--api-keys Enable API keys database for per-user rate limits lookup Don't use API keys LT_API_KEYS
--api-keys-remote Use this remote endpoint to query for valid API keys instead of using the local database Use local API key database LT_API_KEYS_REMOTE
--get-api-key-link Show a link in the UI where to direct users to get an API key Don't show a link LT_GET_API_KEY_LINK
--require-api-key-origin Require use of an API key for programmatic access to the API, unless the request origin matches this domain No restrictions on domain origin LT_REQUIRE_API_KEY_ORIGIN
--load-only Set available languages all from argostranslate LT_LOAD_ONLY
--suggestions Allow user suggestions false LT_SUGGESTIONS
--disable-files-translation Disable files translation false LT_DISABLE_FILES_TRANSLATION
--disable-web-ui Disable web ui false LT_DISABLE_WEB_UI

Note that each argument has an equivalent environment variable that can be used instead. The env. variables overwrite the default values but have lower priority than the command aguments and are particularly useful if used with Docker. The environment variable names are the upper-snake-case of the equivalent command argument's name with a LT prefix.

Run with WSGI and Gunicorn

pip install gunicorn
gunicorn --bind 'wsgi:app'

You can pass application arguments directly to Gunicorn via:

gunicorn --bind 'wsgi:app(api_keys=True)'

Run with Kubernetes

See "LibreTranslate: your own translation service on Kubernetes" by JM Robles

Manage API Keys

LibreTranslate supports per-user limit quotas, e.g. you can issue API keys to users so that they can enjoy higher requests limits per minute (if you also set --req-limit). By default all users are rate-limited based on --req-limit, but passing an optional api_key parameter to the REST endpoints allows a user to enjoy higher request limits.

To use API keys simply start LibreTranslate with the --api-keys option.

Add New Keys

To issue a new API key with 120 requests per minute limits:

ltmanage keys add 120

Remove Keys

ltmanage keys remove <api-key>

View Keys

ltmanage keys

Language Bindings

You can use the LibreTranslate API using the following bindings:

Discourse Plugin

You can use this discourse translator plugin to translate Discourse topics. To install it simply modify /var/discourse/containers/app.yml:

## Plugins go here
## see for details
    - exec:
        cd: $home/plugins
          - git clone
          - git clone

Then issue ./launcher rebuild app. From the Discourse's admin panel then select "LibreTranslate" as a translation provider and set the relevant endpoint configurations.

Mobile Apps

Web browser


This is a list of public LibreTranslate instances, some require an API key. If you want to add a new URL, please open a pull request.

URL API Key Required Payment Link Cost ✔️ Buy $19 / month, 80 requests / minute limit - - - - - - - - - - - - - -

Adding New Languages

To add new languages you first need to train an Argos Translate model. See this video for details.

First you need to collect data, for example from Opus, then you need to add the data to data-index.json in the Argos Train repo.


Help us by opening a pull request!


Can I use your API server at for my application in production?

In short, no. You need to buy an API key. You can always run LibreTranslate for free on your own server of course.

Can I use LibreTranslate behind a reverse proxy, like Apache2?

Yes, here is an example Apache2 config that redirects a subdomain (with HTTPS certificate) to LibreTranslate running on a docker at localhost.

sudo docker run -ti --rm -p libretranslate/libretranslate

You can remove on the above command if you want to be able to access it from domain.tld:5000, in addition to subdomain.domain.tld (this can be helpful to determine if there is an issue with Apache2 or the docker container).

Add --restart unless-stopped if you want this docker to start on boot, unless manually stopped.

Apache config

Replace [YOUR_DOMAIN] with your full domain; for example, translate.domain.tld or libretranslate.domain.tld.

Remove # on the ErrorLog and CustomLog lines to log requests.


#Redirect http to https
<VirtualHost *:80>
    ServerName http://[YOUR_DOMAIN]
    Redirect / https://[YOUR_DOMAIN]
    # ErrorLog ${APACHE_LOG_DIR}/error.log
    # CustomLog ${APACHE_LOG_DIR}/tr-access.log combined

<VirtualHost *:443>
    ServerName https://[YOUR_DOMAIN]
    ProxyPass /
    ProxyPassReverse /
    ProxyPreserveHost On
    SSLEngine on
    SSLCertificateFile /etc/letsencrypt/live/[YOUR_DOMAIN]/fullchain.pem
    SSLCertificateKeyFile /etc/letsencrypt/live/[YOUR_DOMAIN]/privkey.pem
    SSLCertificateChainFile /etc/letsencrypt/live/[YOUR_DOMAIN]/fullchain.pem
    # ErrorLog ${APACHE_LOG_DIR}/tr-error.log
    # CustomLog ${APACHE_LOG_DIR}/tr-access.log combined

Add this to an existing site config, or a new file in /etc/apache2/sites-available/new-site.conf and run sudo a2ensite new-site.conf.

To get a HTTPS subdomain certificate, install certbot (snap), run sudo certbot certonly --manual --preferred-challenges dns and enter your information (with subdomain.domain.tld as the domain). Add a DNS TXT record with your domain registrar when asked. This will save your certificate and key to /etc/letsencrypt/live/{subdomain.domain.tld}/. Alternatively, comment the SSL lines out if you don't want to use HTTPS.


This work is largely possible thanks to Argos Translate, which powers the translation engine.


GNU Affero General Public License v3


See Trademark Guidelines