Self-Host Your Recipe Manager: Mealie and Tandoor Setup Guide

Why Self-Host a Recipe Manager?

Commercial recipe apps like Paprika, AnyList, and Plan to Eat charge monthly fees to store data you could keep yourself. Free recipe websites survive on advertising that makes them increasingly painful to use. Self-hosting solves both problems: your recipes live on your own hardware, your family accesses them from any browser or phone with no account required, and no third party can shut down the service, raise the price, or sell your cooking habits to advertisers.

Mealie vs Tandoor: Which One to Choose?

Both apps cover the same core use case — recipe storage, meal planning, and shopping lists — but they have different strengths and different levels of complexity. Here is the honest comparison:

Setting Up Mealie with Docker Compose

Mealie runs as a single Docker container. The default SQLite setup is the right choice for most home use. Switch to PostgreSQL only if you need fuzzy search or expect more than 20 concurrent users.

Option A: SQLite (recommended for most users)

services:
  mealie:
    image: ghcr.io/mealie-recipes/mealie:latest
    container_name: mealie
    restart: unless-stopped
    ports:
      - "9925:9000"    # access at http://YOUR-IP:9925
    deploy:
      resources:
        limits:
          memory: 1000M
    volumes:
      - ./mealie-data:/app/data
    environment:
      - ALLOW_SIGNUP=false        # set true if you want anyone to register
      - PUID=1000
      - PGID=1000
      - TZ=Europe/Istanbul
      - MAX_WORKERS=1             # keep at 1 for low-powered hardware
      - WEB_CONCURRENCY=1
      - BASE_URL=http://YOUR-SERVER-IP:9925   # update after setting up Localtonet
      # Initial admin account
      - DEFAULT_EMAIL=admin@yourdomain.com
      - DEFAULT_PASSWORD=YourStrongPassword
      - DEFAULT_GROUP=Home
      - DEFAULT_HOUSEHOLD=Family

Option B: PostgreSQL (fuzzy search + more than 20 users)

services:
  mealie:
    image: ghcr.io/mealie-recipes/mealie:latest
    container_name: mealie
    restart: unless-stopped
    ports:
      - "9925:9000"
    deploy:
      resources:
        limits:
          memory: 1000M
    volumes:
      - ./mealie-data:/app/data
    environment:
      - ALLOW_SIGNUP=false
      - PUID=1000
      - PGID=1000
      - TZ=Europe/Istanbul
      - MAX_WORKERS=1
      - WEB_CONCURRENCY=1
      - BASE_URL=http://YOUR-SERVER-IP:9925
      - DEFAULT_EMAIL=admin@yourdomain.com
      - DEFAULT_PASSWORD=YourStrongPassword
      - DEFAULT_GROUP=Home
      - DEFAULT_HOUSEHOLD=Family
      # PostgreSQL connection
      - DB_ENGINE=postgres
      - POSTGRES_USER=mealie
      - POSTGRES_PASSWORD=MealieDBPassword
      - POSTGRES_SERVER=mealie-db
      - POSTGRES_PORT=5432
      - POSTGRES_DB=mealie
    depends_on:
      - mealie-db

  mealie-db:
    image: postgres:16-alpine
    container_name: mealie-db
    restart: unless-stopped
    volumes:
      - ./mealie-pgdata:/var/lib/postgresql/data
    environment:
      - POSTGRES_USER=mealie
      - POSTGRES_PASSWORD=MealieDBPassword
      - POSTGRES_DB=mealie

mkdir ~/mealie && cd ~/mealie
# paste docker-compose.yml content, then:
docker compose up -d
docker logs -f mealie

Starting Mealie...
Application startup complete.
Uvicorn running on http://0.0.0.0:9000

Mealie Features Worth Knowing

Groups and Households

Mealie's user model has two levels. Groups are completely isolated tenants — think of running Mealie for two different families with no shared data. Households are subdivisions within a group: household members share recipes and recipe organization, but each household has its own meal plans and shopping lists. For a typical family, one group and one household is all you need. For a shared server among friends, each family can be its own household under one group.

AI Video Import (YouTube, TikTok, Instagram)

Added in v3.13.0, this is Mealie's most distinctive recent feature. Paste a YouTube, TikTok, or Instagram video URL into the import field. Mealie downloads the video, transcribes it using OpenAI Whisper, and converts the spoken recipe into structured data with ingredients and steps. To enable this, add your OpenAI API key in Settings → Integrations → OpenAI.

Unit Standardization and Conversion

Since v3.13.0, Mealie standardizes ingredient units across recipes. When you add a recipe calling for "1 pint" and another calling for "2 cups" of the same ingredient to a shopping list, Mealie merges them correctly into a single measurement. You can also convert between unit systems (metric/imperial) for any recipe.

Image processing (v3.7.0)

Starting with v3.7.0, Mealie uses an improved image processing algorithm that produces thumbnails up to 40-50% smaller on disk while providing higher resolution. After upgrading, run the reprocessing script to apply the improvements to existing recipes:

docker exec -it mealie bash python \
  /opt/mealie/lib64/python3.12/site-packages/mealie/scripts/reprocess_images.py \
  --workers 2

Setting Up Tandoor with Docker Compose

Tandoor runs as three containers: a PostgreSQL database, a Django application server (gunicorn), and an Nginx container that serves static files and acts as the web frontend. This is more moving parts than Mealie but gives Tandoor better performance for static assets and is the officially supported architecture.

openssl rand -base64 48

K9mP2qR7vX3nL8wT6sY1cA4jE0uH5bF/dN+iM=... (copy this output)

SECRET_KEY=your-generated-key-here
DB_ENGINE=django.db.backends.postgresql
POSTGRES_HOST=tandoor-db
POSTGRES_PORT=5432
POSTGRES_USER=tandoor
POSTGRES_PASSWORD=TandoorDBPassword
POSTGRES_DB=tandoor
TANDOOR_PORT=8080
ENABLE_SIGNUP=0       # set 1 to allow public registration

services:
  tandoor-db:
    image: postgres:16-alpine
    container_name: tandoor-db
    restart: unless-stopped
    volumes:
      - ./tandoor-pgdata:/var/lib/postgresql/data
    env_file:
      - .env

  tandoor-app:
    image: vabene1111/recipes:latest
    container_name: tandoor-app
    restart: unless-stopped
    volumes:
      - ./tandoor-staticfiles:/opt/recipes/staticfiles
      - ./tandoor-mediafiles:/opt/recipes/mediafiles
    env_file:
      - .env
    depends_on:
      - tandoor-db

  tandoor-nginx:
    image: nginx:alpine
    container_name: tandoor-nginx
    restart: unless-stopped
    ports:
      - "8080:80"      # access at http://YOUR-IP:8080
    volumes:
      - ./tandoor-staticfiles:/static:ro
      - ./tandoor-mediafiles:/media:ro
      - ./nginx.conf:/etc/nginx/conf.d/default.conf:ro
    depends_on:
      - tandoor-app

server {
    listen 80;
    server_name _;

    client_max_body_size 100M;

    location /static/ {
        alias /static/;
    }

    location /media/ {
        alias /media/;
    }

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

mkdir ~/tandoor && cd ~/tandoor
# create .env, docker-compose.yml, nginx.conf with content above
docker compose up -d

# Wait 2-3 minutes for database migrations to complete
docker logs -f tandoor-app

# Create admin user
docker exec -it tandoor-app python manage.py createsuperuser

Username: admin
Email address: admin@yourdomain.com
Password: ********
Superuser created successfully.

Tandoor Features Worth Knowing

Nutrition Tracking with OpenFoodFacts

Tandoor integrates with the OpenFoodFacts open database to pull nutritional information for ingredients automatically. When you add an ingredient to a recipe, Tandoor looks it up and fills in calories, protein, carbohydrates, fat, and fiber. You can also enter values manually for ingredients not in the database. The weekly meal plan view shows a nutritional summary for the entire week, which is useful for dietary tracking without a separate app.

Barcode Scanning

The Tandoor mobile PWA can open your phone's camera to scan barcodes. Scan a product's barcode in the grocery store and Tandoor looks it up in OpenFoodFacts, returning the ingredient name and nutritional data. You can add it directly to a shopping list or to a recipe you are editing. This is the feature that most distinguishes Tandoor from Mealie for users who do detailed meal planning with nutritional goals.

Supermarket Layout Mapping

Tandoor lets you map ingredient categories to physical sections of your supermarket. Configure that produce is in aisle 1, dairy in aisle 5, and proteins in the back. When you generate a shopping list from a meal plan, Tandoor groups items by store section so you move through the store in one pass without backtracking. This is configurable per-supermarket, so you can have different layouts for different stores you visit.

Recipe Website Coverage

Tandoor's URL importer supports over 500 recipe websites. For sites not on the supported list, Tandoor falls back to structured data scraping (schema.org Recipe markup), which works on most modern recipe sites. If a site still fails, Tandoor provides a "bookmarklet" tool that lets you scrape the page HTML manually from your browser and paste it into the import dialog.

Accessing Your Recipe Manager from Anywhere

Both Mealie and Tandoor run on a port on your local network. Without any additional configuration, they are only accessible when you are connected to your home Wi-Fi. To access your recipe collection from your phone at the grocery store, or to share it with family members at other locations, you need a way to reach it from the internet.

A Localtonet HTTP tunnel creates a stable public HTTPS URL that forwards to your local port. This works even behind CGNAT, with a dynamic IP, and without any router configuration. The public URL stays the same permanently — set it once in BASE_URL (Mealie) or your Nginx proxy config (Tandoor) and never change it again.

chmod +x localtonet
sudo mv localtonet /usr/local/bin/
sudo localtonet authtoken YOUR_TOKEN

      - BASE_URL=https://recipes.localto.net

docker compose up -d

sudo localtonet --install-service --authtoken YOUR_TOKEN
sudo localtonet --start-service --authtoken YOUR_TOKEN

Backup and Restore

Mealie backup

Mealie has a built-in backup system at Administration → Backups. Each backup is a zip archive containing the SQLite database (or a PostgreSQL dump if using Postgres) plus all recipe images. Download the archive and store it somewhere safe. To restore, use the Restore option in the same menu.

For a simpler approach, just back up the Docker volume directory:

# Stop container, backup volume, restart
docker compose stop mealie
tar -czf mealie-backup-$(date +%Y%m%d).tar.gz ./mealie-data
docker compose start mealie

Tandoor backup

Tandoor stores data across two locations: the PostgreSQL database and the media files volume. Back up both:

# Dump the PostgreSQL database
docker exec tandoor-db pg_dump -U tandoor tandoor > tandoor-db-$(date +%Y%m%d).sql

# Backup media files (recipe images, etc.)
tar -czf tandoor-media-$(date +%Y%m%d).tar.gz ./tandoor-mediafiles

Troubleshooting Common Problems

Frequently Asked Questions