Deployment guide

Self-Host Weblate on a VPS: Translate Your Apps Straight From Git

Deploy on a VPS Cloud →

Tutorial

Self-hosting

Self-Host Weblate on a VPS: Translate Your Apps Straight From Git

Translating an app into Arabic, French and English often ends in JSON files exchanged by e-mail, broken placeholders and translations that land after the release. Weblate fixes this at the source: it connects to your Git repository, shows each string to translators in the browser and sends approved translations back as commits. This guide installs it on a VPS with Docker Compose, closes it to strangers, publishes it over HTTPS behind nginx and connects a first repository.

6 min read3 steps
Contents· What Weblate does1/11
  1. 01What Weblate does
  2. 02What Weblate gives you
  3. 03Hosted platform or Weblate on your VPS
  4. 04Prerequisites
  5. 05Install Weblate with Docker Compose
  6. 06Do not publish an open instance
  7. 07Publish Weblate over HTTPS with nginx
  8. 08Translate your first Git repository
  9. 09Connect LibreTranslate for suggestions
  10. 10Back up and update
  11. 11One-click Weblate on ServOrbit

What Weblate does

Weblate is a continuous localization platform: instead of exporting files by hand, you give it the address of your application's Git repository. It reads the language files — gettext PO, JSON (i18next, vue-i18n), XLIFF, YAML, Android, iOS, ARB, Java properties — and presents each string to translators in a web editor. Approved translations go back to the repository as commits, or as pull requests if you prefer to review.

The project is released under the GPL-3.0 licence. The official Docker image relies on PostgreSQL and on Valkey (or Redis) for the cache and the task queue. On a VPS, expect about 1.7 GB of memory at rest with two worker processes.

What Weblate gives you

  • A single source of truth: Git — developers add strings in the code, translations come back to the same repository.
  • Quality checks — missing placeholders, broken tags, spacing and punctuation, incomplete plurals.
  • Arabic without workarounds — right-to-left editing and six plural forms.
  • Explicit review — each string can be marked as needing edit, translated or approved.
  • Translation memory and glossary — your product terms always translated the same way.
  • Machine suggestions — from your own LibreTranslate or another translation service.

Hosted platform or Weblate on your VPS

Scroll the table

Hosted platform (Crowdin, Lokalise…)Weblate on your VPS
Where strings liveVendor's serversYour VPS
Link with the codeGit integrationGit integration
Translator accountsDepends on the planAs many as you want
Unreleased textsAt a third partyOn your server
Server licenceProprietary serviceGPL-3.0

Prerequisites

An Ubuntu 24.04 VPS with 4 GB of RAM and 2 vCPUs. You need Docker with the Compose plugin, nginx and certbot on the host, and a name (weblate.example.com in this guide) pointing to the VPS IP. Also plan an SMTP account listening on port 587 with TLS: Weblate sends invitations and password resets by e-mail.

Install Weblate with Docker Compose

  1. Prepare the folder and the .env file

    The same file is used by Docker Compose and by the Weblate container. WEBLATE_REGISTRATION_OPEN=0 closes sign-ups and WEBLATE_REQUIRE_LOGIN=1 requires a login to read anything. Replace the three SMTP lines with your provider's.

    mkdir -p /opt/weblate && cd /opt/weblate
    cat > .env <<EOF
    WEBLATE_SITE_DOMAIN=weblate.example.com
    WEBLATE_ENABLE_HTTPS=1
    WEBLATE_SECURE_PROXY_SSL_HEADER=HTTP_X_FORWARDED_PROTO,https
    WEBLATE_IP_PROXY_HEADER=HTTP_X_FORWARDED_FOR
    [email protected]
    WEBLATE_ADMIN_PASSWORD=$(openssl rand -hex 16)
    WEBLATE_REGISTRATION_OPEN=0
    WEBLATE_REQUIRE_LOGIN=1
    [email protected]
    [email protected]
    WEBLATE_EMAIL_HOST=smtp.example.com
    [email protected]
    WEBLATE_EMAIL_HOST_PASSWORD=<SMTP_PASSWORD>
    POSTGRES_HOST=database
    POSTGRES_DB=weblate
    POSTGRES_USER=weblate
    POSTGRES_PASSWORD=$(openssl rand -hex 16)
    REDIS_HOST=cache
    REDIS_PASSWORD=$(openssl rand -hex 16)
    EOF
    chmod 600 .env
  2. Write the docker-compose.yml file

    Three services: PostgreSQL, password-protected Valkey, and Weblate. The port is only published on the loopback interface: only nginx will be exposed to the Internet.

    services:
      database:
        image: postgres:18.7-alpine
        restart: unless-stopped
        environment:
          POSTGRES_DB: weblate
          POSTGRES_USER: weblate
          POSTGRES_PASSWORD: "${POSTGRES_PASSWORD}"
        volumes:
          - weblate-db:/var/lib/postgresql
    
      cache:
        image: valkey/valkey:9.1.3
        restart: unless-stopped
        command: ["valkey-server", "--save", "60", "1", "--requirepass", "${REDIS_PASSWORD}"]
        volumes:
          - weblate-redis:/data
    
      weblate:
        image: weblate/weblate:2026.11.2.0
        restart: unless-stopped
        depends_on: [database, cache]
        env_file: .env
        ports:
          - "127.0.0.1:8080:8080"
        volumes:
          - weblate-data:/app/data
          - weblate-cache:/app/cache
        tmpfs: [/run, /tmp]
    
    volumes:
      weblate-db: {}
      weblate-redis: {}
      weblate-data: {}
      weblate-cache: {}
  3. Start and check

    The first start creates the database and the admin account, which takes one to two minutes. The health endpoint must answer 200, and the last command prints the administrator password:

    docker compose up -d
    docker compose ps
    curl -s -o /dev/null -w '%{http_code}\n' http://127.0.0.1:8080/healthz/
    grep WEBLATE_ADMIN_PASSWORD .env

Do not publish an open instance

With WEBLATE_REGISTRATION_OPEN=1, anyone can create an account on your instance, and without WEBLATE_REQUIRE_LOGIN=1 public projects can be read without an account — including the strings of a feature not announced yet. Keep both settings from this guide and leave the port on 127.0.0.1.

Publish Weblate over HTTPS with nginx

Create /etc/nginx/sites-available/weblate with this server block, then enable it with a symbolic link in sites-enabled. The X-Forwarded-Proto header is essential: it tells Weblate the request arrived over HTTPS.

server {
    listen 80;
    server_name weblate.example.com;
    client_max_body_size 100m;

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

Check the configuration, reload nginx and request the certificate; certbot adds the HTTPS block and the redirect from HTTP itself.

sudo nginx -t && sudo systemctl reload nginx
sudo certbot --nginx -d weblate.example.com

Then open https://weblate.example.com/accounts/login/ and log in with the user admin.

Translate your first Git repository

Create a project, then a component. Give the repository URL, the branch and the language file mask — for example locales/*.json for vue-i18n or locale/*/LC_MESSAGES/django.po for Django. Weblate clones the repository, detects the languages present and offers to add more.

For it to send translations back, open Manage › SSH keys, generate the instance key and add it as a deploy key with write access to the repository, then set the component's push URL over SSH. Weblate groups changes and pushes them as commits. To have it update as soon as a developer pushes code, declare a webhook to https://weblate.example.com/hooks/github/ (there are also /hooks/gitlab/ and /hooks/gitea/).

Everything can also be driven through the REST API, with the token shown in your profile:

curl -s https://weblate.example.com/api/projects/ \
  -H "Authorization: Token <API_TOKEN>"

Connect LibreTranslate for suggestions

Weblate offers machine suggestions under each string. If you run your own LibreTranslate instance, open Manage › Translation services, add the LibreTranslate service with your instance URL and its API key. Translators then see a proposal for Arabic, French, English or Spanish, which they correct before approving: the text never leaves your servers. The same setting exists at project level if you want to reserve it for some projects.

Back up and update

Two things to back up: the PostgreSQL database and the weblate-data volume, which holds the instance secret key, the SSH keys and the repository clones.

cd /opt/weblate
docker compose exec -T database pg_dump -U weblate weblate | gzip > weblate-db-$(date +%F).sql.gz
docker run --rm -v weblate_weblate-data:/data -v "$PWD":/backup alpine:3.22 \
  tar czf /backup/weblate-data-$(date +%F).tar.gz -C /data .

To update, first read the release notes on GitHub, back up, then change the image tag; Weblate applies its migrations on start:

cd /opt/weblate
sed -i 's|weblate/weblate:2026.11.2.0|weblate/weblate:<NEW_VERSION>|' docker-compose.yml
docker compose pull && docker compose up -d

One-click Weblate on ServOrbit

On a ServOrbit VPS, Weblate installs from the Marketplace. The script deploys the official image with PostgreSQL and Valkey, generates the administrator password and the service passwords, closes sign-ups, requires a login and configures the nginx reverse proxy over HTTPS — on a subdomain of one of your domains or on the VPS's free subdomain. You log in with the user admin and the password shown in your client area, then connect your first repository as above. Only SMTP remains to be set up to invite your translators.

Share this articleservorbit.com/ma-en/blog/self-host-weblate-vps-translation-platform