Mealie: A Self-Hosted Recipe Manager for People Who Actually Cook

I have a confession. For years my recipe collection was a chaotic sprawl of browser bookmarks, phone screenshots, a Google Doc nobody could ever find, and three different paper notebooks written in the handwriting of a doctor having a stroke. Every single time I wanted to cook something I’d dig up the original blog post, scroll past 1,400 words about the author’s grandmother in Tuscany, dodge a video ad that started playing on its own with the sound on, dismiss a newsletter pop-up, and then — finally — reach the one line telling me how much flour to use. I once measured it: forty seconds of scrolling and ad-swatting to find a quantity I needed in two.

Mealie fixed that. It’s a self-hosted recipe manager you run on your own box, and it has quietly become one of the three most-used services on my home server, right alongside the things I actually built the server for.

What Mealie actually is

Mealie is a web app for managing recipes, and the headline feature — the one that sells it in ten seconds flat — is the URL importer. Paste a recipe link and Mealie fetches the page, parses out the ingredients and the method, and saves a clean, structured copy with none of the life story and none of the ads. Just the food. The first time you watch a bloated, ad-infested recipe page collapse into a tidy card with a numbered ingredient list, you understand the entire appeal.

Beyond that headline trick you get:

• A proper recipe database with tags and categories you define and control.
• Meal planning — drag recipes onto a calendar week.
• Shopping lists generated automatically from the recipes you planned.
• A genuine REST API, so it plays nicely with other tools and a bit of scripting.
• Multi-user support, so the whole household isn’t fighting over one login.

It’s open source, it’s actively developed, and it doesn’t phone home to a company that might one day pivot to selling your meal-planning data to a supermarket chain. Your recipes live in your database, on your disk, under your backups.

Why self-host a recipe box at all

The honest answer is the same one behind most of the self-hosting I do: the free web version of anything can vanish, enshittify, or start charging, and your data goes with it. A recipe collection you’ve curated for years is worth protecting from that. Recipe websites are also, frankly, an adversarial reading experience — the long preamble and the ad density exist to keep you on the page and serve impressions, not to help you cook. Mealie strips all of that incentive away because you run it and there’s nobody to serve ads to.

If you already run a home server, adding Mealie is a genuinely trivial evening project, and it sits comfortably in the same category of “small services that quietly make daily life better” as something like Paperless-ngx for a paperless office that actually works — both take an annoying analogue-ish mess and turn it into something searchable that you own.

Getting it running

Mealie ships as a Docker image and it’s about as painless as self-hosting gets. You can run it against the bundled SQLite database, which is genuinely fine for a single household, or point it at Postgres if you want something sturdier for multiple users and heavier use. Here’s a compose file that uses Postgres, which is what I’d recommend if you intend to keep this around for years:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

services:
  mealie:
    image: ghcr.io/mealie-recipes/mealie:latest
    container_name: mealie
    restart: unless-stopped
    ports:
      - "9925:9000"
    environment:
      ALLOW_SIGNUP: "false"
      BASE_URL: "https://mealie.example.com"
      DB_ENGINE: postgres
      POSTGRES_USER: mealie
      POSTGRES_PASSWORD: change-me-please
      POSTGRES_SERVER: postgres
      POSTGRES_DB: mealie
    volumes:
      - ./mealie/data:/app/data
    depends_on:
      - postgres

  postgres:
    image: postgres:15
    container_name: mealie-postgres
    restart: unless-stopped
    environment:
      POSTGRES_USER: mealie
      POSTGRES_PASSWORD: change-me-please
      POSTGRES_DB: mealie
    volumes:
      - ./postgres:/var/lib/postgresql/data

A few things worth flagging from experience. The BASE_URL matters far more than it looks — get it wrong and the import preview, the share links, and the generated OpenGraph cards all misbehave in ways that are annoying to trace back to one variable. The ./mealie/data volume is the bit you genuinely care about: it holds recipe images and uploaded files, so that directory plus your Postgres database is exactly what a backup job needs to cover. And I set ALLOW_SIGNUP: "false" immediately after creating my admin account, because there’s no reason to leave open registration on once everyone who needs an account has one. Stick the whole thing behind a reverse proxy with TLS and you’re done.

If you’d rather skip Postgres entirely, drop the second service, remove the DB_ENGINE and POSTGRES_* variables, and Mealie falls back to SQLite inside that same data volume. For one family, honestly, that’s perfectly fine and one fewer container to worry about.

The actual workflow

This is where it earns its keep, and where I’ll try to describe how it maps onto real cooking rather than how an app designer imagines cooking works. Say I’ve found a curry recipe on some food blog. I open Mealie, hit Create → Import from URL, paste the link, and a few seconds later I’ve got a tidy recipe card: title, ingredients as a proper checkable list, numbered method steps, the photo, and the source link preserved so I can credit the original author.

Then I tidy it. I add tags — curry, weeknight, freezer-friendly — and slot it into a category like Mains. This sounds fussy, and the first time you do it it feels like busywork. But two months later, when I search “freezer-friendly” and get back the eight things I actually cook and freeze, those five minutes of tagging have paid for themselves many times over. Tagging is the difference between a recipe archive and a recipe tool.

From there it’s meal planning. I open the planner, drag recipes onto the days of the week, and once the week is roughed out I generate a shopping list straight from those planned recipes. Mealie pools the ingredients across the week, I tick off what’s already in the cupboard, and I shop from my phone in the aisle. That loop — import, tag, plan, list — is the entire reason to run this thing, and it genuinely maps onto how a home cook operates.

Troubleshooting the rough edges

Import quality varies, and it varies a lot. This is the thing to set expectations on. Sites that publish proper structured recipe metadata (the JSON-LD Recipe schema) import beautifully — the big recipe networks and most well-built food blogs are basically flawless. Smaller or older sites that just dump the recipe into a wall of prose with no structured data will give you a half-parsed mess of run-together ingredients you’ll need to fix by hand. The importer is good, not magic. Budget for the occasional five-minute cleanup, and for a handful of sites, expect to type it in manually.

The import preview looks broken or links are wrong. Nine times out of ten this is a BASE_URL mismatch. It must exactly match the URL you actually reach Mealie on, scheme included. Fix it and restart the container.

Images or recipes “disappeared” after a rebuild. They didn’t — you almost certainly weren’t persisting ./mealie/data, or you were persisting it but not the Postgres volume, so the metadata and the images fell out of sync. Both volumes travel together. Back them up together, restore them together.

Updates. Pin a version tag rather than blindly tracking latest if uptime matters to you, read the release notes before major version bumps, and always have a fresh backup before upgrading. This is the standard self-hosting tax: you own the backups, the updates, and the reverse proxy. If ./mealie/data and your database aren’t in a backup that you’ve actually tested restoring, you don’t have a recipe collection — you have a recipe collection waiting to be deleted by a bad disk. The same discipline I’d apply to anything holding data I’d miss, like a Vaultwarden password manager, applies here in miniature.

The API, and the things it quietly enables

The REST API is the feature I underrated at first and now use constantly, and it’s what separates Mealie from a glorified bookmark folder. Every recipe, tag, meal plan and shopping list is reachable programmatically with a bearer token you generate in the settings. That opens up automations that are genuinely useful rather than gimmicky: I have a small script that posts the week’s meal plan to a family chat every Sunday evening, and another that flags any recipe I haven’t cooked in a year as a candidate for pruning. You can push a generated shopping list into a notes app, pull recipes into a kiosk display in the kitchen, or bulk-import a folder of old text files you’d typed up years ago.

The point isn’t any one of those scripts — it’s that because the data is structured and the API is real, your recipe box becomes something you can build on rather than just read from. That’s the dividend of self-hosting a tool with a proper API instead of renting a closed app: the recipes are yours, and so is everything you can automate around them.

A note on updates and staying current

Mealie has been through a significant rewrite in its history — the older “v0” line and the current “v1”/mealie-recipes line differ enough that migration between them was a genuine, planned operation rather than a routine docker pull. The practical takeaway is to run the current ghcr.io/mealie-recipes/mealie image (as in the compose file above), read release notes before major bumps, and not assume that every self-hosted app upgrades transparently. Most days it’s a boring pull and restart; occasionally it’s a schema migration you want a backup in hand for. This is the ordinary rhythm of running your own services, and Mealie is a gentle one to learn it on.

Who it’s for

If you cook regularly, hoard recipes, and quietly resent the modern recipe-blog experience, Mealie is close to ideal and I’d recommend it without reservation. If you already run a home server it’s a no-brainer evening project with an immediate daily payoff. If you cook mostly from boxes and order takeaways, this genuinely isn’t for you, and that’s completely fine — not every tool needs to fit every person, and I’d rather tell you that plainly than oversell it.

For me it replaced the bookmarks, the screenshots, the buried Doc, and the doctor’s-handwriting notebooks with one clean, searchable, ad-free place that I control and back up. My only regret is the years I spent scrolling past somebody’s grandmother in Tuscany to find out how much flour I needed — and that I didn’t set this up two home-server rebuilds ago, because it’s the service that most reliably earns a smile every single week.