Getting Started

Minato ships as a single Docker image. It runs the API server, background workers, and the web frontend all together, managed internally by supervisord and proxied by nginx. The only external services you need are PostgreSQL, Redis, and Meilisearch, all included in the compose file below.

Prerequisites

Docker 24+ and Docker Compose v2
A TMDB Read Access Token: free, get one at themoviedb.org

1. Get the compose file

Download the latest docker-compose.yaml directly:

curl -O https://raw.githubusercontent.com/gergogyulai/minato/main/docker-compose.yaml

Or create it manually:

name: minato

services:
  minato:
    image: gergogyulai/minato:latest
    container_name: minato
    restart: unless-stopped
    ports:
      - "7271:7271"
    environment:
      BETTER_AUTH_SECRET: ${BETTER_AUTH_SECRET}
      DATABASE_URL: postgresql://minato:${POSTGRES_PASSWORD}@postgres:5432/minato
      MEILISEARCH_MASTER_KEY: ${MEILISEARCH_MASTER_KEY}
      TMDB_READ_ACCESS_TOKEN: ${TMDB_READ_ACCESS_TOKEN}
      OPENROUTER_API_KEY: ${OPENROUTER_API_KEY:-}
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:7271/api/v1/health"]
      interval: 10s
      timeout: 5s
      retries: 5
      start_period: 10s
    volumes:
      - minato_config:/config
    depends_on:
      postgres:
        condition: service_healthy
      redis:
        condition: service_healthy
      meilisearch:
        condition: service_healthy

  postgres:
    image: postgres:16-alpine
    restart: unless-stopped
    environment:
      POSTGRES_DB: minato
      POSTGRES_USER: minato
      POSTGRES_PASSWORD: ${POSTGRES_PASSWORD}
    volumes:
      - postgres_data:/var/lib/postgresql/data
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U minato -d minato"]
      interval: 5s
      timeout: 5s
      retries: 10

  redis:
    image: redis:7-alpine
    restart: unless-stopped
    command: redis-server --save 60 1 --loglevel warning
    volumes:
      - redis_data:/data
    healthcheck:
      test: ["CMD", "redis-cli", "ping"]
      interval: 5s
      timeout: 5s
      retries: 10

  meilisearch:
    image: getmeili/meilisearch:v1.12
    restart: unless-stopped
    environment:
      MEILI_MASTER_KEY: ${MEILISEARCH_MASTER_KEY}
      MEILI_NO_ANALYTICS: "true"
    volumes:
      - meilisearch_data:/meili_data
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:7700/health"]
      interval: 5s
      timeout: 5s
      retries: 10

volumes:
  minato_config:
  postgres_data:
  redis_data:
  meilisearch_data:

2. Create the .env file

In the same directory, create a .env file with your secrets. These are the only values you need to set, everything else is wired up automatically within the Docker network.

# Generate with: openssl rand -base64 32
BETTER_AUTH_SECRET=

# Choose a strong password for the internal Postgres database
POSTGRES_PASSWORD=

# Generate with: openssl rand -hex 32
MEILISEARCH_MASTER_KEY=

# TMDB Read Access Token — https://developer.themoviedb.org
TMDB_READ_ACCESS_TOKEN=

# Only needed if you enable AI repair features in Settings
# OPENROUTER_API_KEY=

BETTER_AUTH_SECRET and MEILISEARCH_MASTER_KEY are security secrets! Generate them with the commands shown, don't reuse passwords.

3. Start

docker compose up -d

On first boot, Minato runs database migrations automatically. Once the minato container is healthy, the UI is available at http://localhost:7271.

Updating

docker compose pull
docker compose up -d

Migrations run automatically on startup — no manual steps after a version bump.

Configuration reference

All available environment variables and their defaults

Reverse proxy setup

Configure a reverse proxy for Minato