---
title: "Deploy Tolgee"
description: "Translation management platform for apps in multiple languages"
category: "Other"
url: https://railway.com/deploy/tolgee-i18n
---

# Deploy Tolgee

Translation management platform for apps in multiple languages

**[Deploy Tolgee on Railway](https://railway.com/template/tolgee-i18n)**

Machine-readable deploy manifest (JSON, validated by TemplateCI): https://railway.com/deploy/tolgee-i18n/manifest.json

- **Creator:** A3A
- **Category:** Other
- **Total deploys:** 1

## Template content

### tolgee https://cdn.jsdelivr.net/gh/homarr-labs/dashboard-icons/svg/tolgee.svg

- **Image:** tolgee/tolgee:latest
- **Health check:** /actuator/health
- **Public domain:** Yes

### Redis https://cdn.jsdelivr.net/gh/homarr-labs/dashboard-icons/svg/redis.svg

- **Image:** redis:8.2
- **Start command:** `/bin/sh -c "rm -rf $RAILWAY_VOLUME_MOUNT_PATH/lost+found/ && exec docker-entrypoint.sh redis-server --requirepass $REDIS_PASSWORD --save 60 1 --dir $RAILWAY_VOLUME_MOUNT_PATH"`

### Postgres https://cdn.jsdelivr.net/gh/homarr-labs/dashboard-icons/svg/postgresql.svg

- **Image:** ghcr.io/railwayapp-templates/postgres-ssl:18

## Buckets

- **tolgee-files**

## Documentation

# Deploy and Host Tolgee on Railway

Tolgee is an open-source localization platform for teams shipping software in more than one language. It replaces the spreadsheet-and-JSON-file workflow with a translation editor, a REST API, SDKs for React, Vue, Angular, Next.js, Android and iOS, and a CLI that syncs strings in and out of a repository. Its signature feature is in-context editing: with the SDK loaded, anyone can alt-click a string in the running app and edit it in place, capturing a screenshot that travels with the key so the translator sees where it appears. Self-host Tolgee and that source content — often unreleased copy — stays on infrastructure you control.

Deploy Tolgee on Railway and four pieces arrive wired together. **tolgee** is the application, the `tolgee/tolgee` image serving the editor and API on a public domain. **Postgres** holds every project, key, translation and activity record, and Tolgee migrates its own schema on each boot. **Redis** backs the cache, the rate-limit buckets, the websocket fan-out that keeps two editors in sync, and the locks that stop batch jobs running twice. A bucket holds screenshots, images and avatars, so the app needs no volume and stays stateless.

![Diagram of the Tolgee, Postgres and Redis services on Railway](https://res.cloudinary.com/rroe4rtk/image/upload/f_auto,q_auto/v1789623099/tolgee-architecture.webp)

## Getting Started with Tolgee on Railway

Open the deployed URL and you land on a login screen: this template enables authentication and closes public registration. Sign in as the first administrator — username `TOLGEE_AUTHENTICATION_INITIAL_USERNAME` (`admin` by default), password the generated `TOLGEE_AUTHENTICATION_INITIAL_PASSWORD` on the tolgee service. The form asks for an "email"; type the username anyway, it is the same field. Change the password from the user menu once in, after which the variable is ignored and a redeploy never reverts it.

You arrive at the projects dashboard with a seeded **Demo project**, so there is something real to click before importing anything. Open it and choose Translations for the editing grid: keys with descriptions, tags and screenshots on the left, translations per language on the right. Edit a string, add one with **+ KEY**, or attach a screenshot to confirm object storage works. Then create your own project, add languages and Import existing JSON, PO, XLIFF or ARB files. Finally open Integrate, pick a framework, and Tolgee generates an API key and a snippet for your app.

![Tolgee translation grid with English and German strings](https://res.cloudinary.com/rroe4rtk/image/upload/f_auto,q_auto/v1789623102/tolgee-translations-grid.webp)
![Tolgee project dashboard showing language progress and activity](https://res.cloudinary.com/rroe4rtk/image/upload/f_auto,q_auto/v1789623104/tolgee-project-dashboard.webp)
![Tolgee integration picker listing React, Vue and Android SDKs](https://res.cloudinary.com/rroe4rtk/image/upload/f_auto,q_auto/v1789623105/tolgee-integrate-sdks.webp)

## About Hosting Tolgee

Tolgee is a Kotlin/Spring Boot server with a React front end, Apache 2.0 licensed with some enterprise modules under a separate licence. Self-host it when source strings are sensitive, when a per-seat SaaS bill does not fit a team where half the contributors are occasional translators, or when the localization API belongs on your own network.

- In-context editing and one-click screenshot capture from the running app
- SDKs for React, Vue, Angular, Svelte, Next.js, Android, iOS and Unreal, plus REST API and CLI
- Import/export for JSON, PO, XLIFF, Properties, ARB, YAML, CSV and Apple/Android formats
- Machine translation via Google, DeepL, AWS or Azure, and AI translation with your own key

## Why Deploy Tolgee on Railway

Railway removes the setup between you and a working localization server.

- Postgres, Redis and object storage provisioned and connected for you
- A public HTTPS domain and TLS certificate, ready when the deploy finishes
- Private networking between the app and its data stores; neither database is exposed

## Common Use Cases

- **Multi-language web apps** — developers push keys with the Tolgee CLI, translators work in the editor, the SDK pulls translations at build or runtime.
- **Agencies with several clients** — one instance, one project per client, per-project permissions, no per-seat cost as translators come and go.
- **Replacing a paid SaaS tool** — import a Crowdin, Lokalise or Phrase export and keep the workflow on your own infrastructure.

## Dependencies for Tolgee

- **tolgee** — `tolgee/tolgee:latest`, the application server and web UI on port 8080.
- **Postgres** — every project, key, translation, comment, tag, API key and activity record. Tolgee runs Liquibase migrations at startup, so upgrades need no manual step.
- **Redis** — the cache, the rate-limit buckets, the websocket fan-out behind live editing, and the locks that keep batch jobs single-run.
- **Object storage bucket** — screenshots, images and avatars, served back through the app so the bucket needs no public access.

### Environment Variables Reference

| Variable | Purpose |
|---|---|
| `TOLGEE_AUTHENTICATION_ENABLED` | Must stay `true`. The image's own profile defaults it to `false`, logging every visitor in as the administrator |
| `TOLGEE_AUTHENTICATION_INITIAL_USERNAME` / `_PASSWORD` | First administrator's login and password, applied until changed in the UI |
| `TOLGEE_AUTHENTICATION_JWT_SECRET` | Signs session tokens; keep it stable |
| `TOLGEE_POSTGRES_AUTOSTART_ENABLED` | `false` — stops the bundled database starting |
| `TOLGEE_SMTP_HOST` and friends | Optional: invitation and password-reset email |

### Deployment Dependencies

- Image: [hub.docker.com/r/tolgee/tolgee](https://hub.docker.com/r/tolgee/tolgee) · Source: [github.com/tolgee/tolgee-platform](https://github.com/tolgee/tolgee-platform)
- Docs: [docs.tolgee.io](https://docs.tolgee.io/platform/self_hosting/getting_started)
- Runtime: JRE 25, Spring Boot 4, PostgreSQL, Redis, S3 storage

## Hardware Requirements for Self-Hosting Tolgee

| Resource | Minimum | Recommended |
|---|---|---|
| CPU | 1 vCPU | 2 vCPU |
| RAM | 2 GB | 4 GB app, plus database |
| Storage | 1 GB database | 5 GB database plus bucket |
| Runtime | JRE 25 (in the image) | Plus PostgreSQL 14+ and Redis 6+ |

## Self-Hosting Tolgee with Docker

The quickest local run uses the image's bundled database — fine for a look around, not for data you keep:

```
docker run -v tolgee_data:/data -p 8085:8080 tolgee/tolgee
```

For anything real, point it at an external PostgreSQL and set the security variables explicitly. This Compose file is the template's core, minus Redis and the bucket:

```
services:
  app:
    image: tolgee/tolgee:latest
    ports: ["8080:8080"]
    environment:
      TOLGEE_POSTGRES_AUTOSTART_ENABLED: "false"
      SPRING_DATASOURCE_URL: jdbc:postgresql://db:5432/postgres
      SPRING_DATASOURCE_USERNAME: postgres
      SPRING_DATASOURCE_PASSWORD: postgres
      TOLGEE_AUTHENTICATION_ENABLED: "true"
      TOLGEE_AUTHENTICATION_INITIAL_PASSWORD: change-me
      TOLGEE_AUTHENTICATION_JWT_SECRET: a-64-char-random-string
      TOLGEE_FRONT_END_URL: http://localhost:8080
  db:
    image: postgres:17
    environment: { POSTGRES_PASSWORD: postgres }
    volumes: ["./pg:/var/lib/postgresql/data"]
```

Leave `TOLGEE_AUTHENTICATION_ENABLED` out and the server runs with no login screen — every visitor becomes the administrator. It is the one variable to get right on an internet-facing instance.

## How Much Does Tolgee Cost to Self-Host?

Tolgee's platform is open source under Apache 2.0: no licence fee and no per-seat charge for the self-hosted server, so invite as many translators as you like. Some advanced modules, including quality-assurance checks and single sign-on, sit behind a separate enterprise licence and stay off without a subscription key. On Railway you pay only for compute, database and storage.

## FAQ

**What is Tolgee?**

An open-source localization and translation-management platform. Developers push keys from code, translators edit them in a web editor, and SDKs or the REST API deliver the finished strings back to the app — with in-context editing and screenshot capture from the running app itself.

**What does this Railway template deploy?**

A tolgee application service on a public domain, a managed Postgres database, a managed Redis instance and an object storage bucket, every connection variable wired between them. Authentication is on, registration is off, and the first administrator is created on the first boot.

**Why does the template include Redis and a storage bucket?**

Redis carries the cache, the rate limits, the websocket updates behind live collaborative editing and the locks that stop batch jobs running twice, so the app stays correct past one replica. The bucket stores screenshots, images and avatars, so the app holds no state on disk.

**How do I pull translations into my app from a self-hosted Tolgee server?**

Open the project's Integrate screen, choose your framework and generate an API key. Point the SDK or the `tolgee` CLI at your Railway URL with that key — `tolgee pull --api-url https://your-app.up.railway.app --api-key ` — and it writes the files into your repo.

**Can I use machine translation or AI with a self-hosted instance?**

Yes, with your own provider keys: `TOLGEE_MACHINE_TRANSLATION_GOOGLE_API_KEY`, the DeepL, AWS or Azure equivalents, or an LLM provider through `TOLGEE_LLM_PROVIDERS_0_*`. Nothing is enabled by default, so no external service is contacted until you add a key.


## Similar templates

- [Rocky Linux](https://railway.com/deploy/rocky-linux) — Hosted Rocky Linux 9 workspace with SSH and persistent storage. 🚀
- [Foundry Virtual Tabletop](https://railway.com/deploy/X5tR6G) — A Self-Hosted & Modern Roleplaying Platform
- [Letta Code Remote](https://railway.com/deploy/letta-code-remote) — Run a Letta Code agent 24/7. No inbound ports, just deploy.

Open this page in a browser: https://railway.com/deploy/tolgee-i18n