mealie.io

Mealie is a self-hosted recipe manager. It is aimed at people who want to keep their own recipe collection on their own server, organize and search it, import recipes they already have in other apps, and control who can see what. The core feature set covers recipe storage and retrieval, importing from other apps, permissions and public access, and backup and restore. It also documents authentication options and AI providers, so it can fit into a home server setup rather than being a closed hosted service.

Storing, organizing, and finding recipes

Mealie's documentation lists a feature overview as a top-level section, which is the place to check the current, authoritative list of what the app does. In practice, the recipe-management value comes from three things:

• A single place for your recipes. Instead of scattered bookmarks, screenshots, and notes, recipes live in one collection you host yourself.
• Organization you control. Because it is self-hosted, your categories, tags, and structure are yours to define rather than dictated by a third-party service.
• Retrieval. The documentation includes a dedicated guide on improving the ingredient parser, which matters because search and filtering depend on ingredients being parsed into usable units and names. If your recipes import with messy ingredient lines, that guide is the fix.

If your main need is "find any recipe by an ingredient I have on hand," the ingredient parser quality is the feature to evaluate first. If your need is simply "keep my recipes in one searchable library," the storage and organization features are the core.

Importing recipes from other apps

Mealie documents an "Import from other apps" section, so migration is a first-class concern rather than an afterthought. The documentation also includes several concrete import paths under Community Guides:

• Bulk URL import — for bringing in recipes you have as links.
• Bookmarklet — for capturing a recipe from a page while you browse.
• iOS Shortcut — for importing from an iPhone or iPad.
• Home Assistant import — for pulling recipes in from a Home Assistant setup.
• Bring API without internet exposure — for integrating with the Bring shopping-list app while keeping your instance off the public internet.

This matters if you already have recipes in another app or in a pile of saved links. The existence of a bulk URL importer and a bookmarklet means you are not limited to entering recipes one at a time by hand. Check the "Import from other apps" documentation for the exact formats and steps, since supported sources and behavior can change between versions.

Permissions, public access, and authentication

Mealie separates permissions and public access from authentication, which tells you these are two distinct controls:

• Permissions and public access govern what anonymous or logged-in visitors can see and do.
• Authentication covers how users prove who they are, with documented support for LDAP and OpenID Connect.

That combination is useful if you want to share a recipe with family or the public without giving them an account, while still requiring login for editing. It also means Mealie can plug into an existing identity provider instead of maintaining separate passwords. If you run other self-hosted services with LDAP or OIDC, this is the feature that lets Mealie join that setup.

Backup, restore, and data management

The documentation includes a Backup and Restoring section and a community guide on automating backups with n8n. For a self-hosted recipe collection, this is the difference between a hobby project and something you can trust with years of recipes. Two practical points follow from the documentation:

• Backups are a documented, supported operation, not something you have to improvise.
• Automation is possible via n8n, so you can schedule backups rather than remembering to run them.

If you are choosing between self-hosted options, weigh how well each one documents backup and restore. Mealie documents both.

Installation and technology choices

The documentation's Installation section includes an installation checklist and two database options:

The checklist is the right starting point before you install, because it lists what to decide and prepare first. The database choice is the main architectural decision: SQLite is marked recommended, while PostgreSQL is available if you prefer it or already run it. The documentation also covers backend configuration, security, and logs, which are the areas you will touch when tuning or troubleshooting a deployment.

AI providers and extensibility

Mealie documents AI providers as a configuration area. This indicates the app can be connected to an AI provider for some functionality, and the documentation is where the supported providers and setup are described. Treat this as an optional capability to check against your needs rather than a core requirement — the recipe storage, import, permissions, and backup features stand on their own without it.

How to decide

• Choose Mealie if you want a self-hosted recipe manager with documented import paths from other apps, granular public-access and authentication controls (including LDAP and OIDC), and documented backup and restore.
• Look elsewhere if you want a fully hosted service with no server to run, or if you need a feature that is not in the current feature overview.
• Before committing, read the installation checklist, confirm whether SQLite (recommended) or PostgreSQL fits your setup, and test the importer against a sample of your existing recipes — the ingredient parser guide is there because import quality varies by source.

The authoritative, current list of features is the Feature overview in the Mealie documentation; use it to confirm anything version-specific before you migrate a large collection.

Mealie is a self-hosted recipe manager, and the official documentation treats installation as a checklist rather than a single command. Before you deploy, decide on two things: which database you will run (SQLite is marked as recommended, PostgreSQL is the alternative) and how the instance will be reached (directly, or behind a reverse proxy). The documentation also separates installation from the follow-up tasks of backend configuration, security, backups, and updates, so plan for those as part of setup rather than afterthoughts.

What to prepare before installing

The documentation's Installation Checklist is the starting point, and it sits alongside dedicated pages for Backend Configuration, Security, and Logs. In practice, that means gathering your deployment decisions first:

• Database choice — SQLite (Recommended) or PostgreSQL. This affects your storage layout and backup approach.
• Access method — whether the instance is exposed directly or through a reverse proxy. The community guides include a Reverse Proxy (SWAG) walkthrough if you go that route.
• Authentication model — the docs cover Authentication generally, plus LDAP and OpenID Connect for external identity providers.
• AI providers — there is a configuration page for AI Providers if you intend to use those features.

Work through the Installation Checklist page itself for the authoritative list, since it is the document the project maintains for this purpose.

Choosing SQLite or PostgreSQL

The documentation labels SQLite as Recommended and lists PostgreSQL as the other supported database. Both are documented under Installation, so the choice is a deployment preference rather than a feature gate.

If you have no existing reason to run PostgreSQL, the documentation's own recommendation points to SQLite.

Configuring the backend and security

After installation, the docs direct you to Backend Configuration and Security as distinct topics. These are where you set how the instance behaves and who can reach it. Related pages in the same section cover:

• Permissions and Public Access — controls what unauthenticated or limited users can see.
• Authentication, with LDAP and OpenID Connect as documented options for connecting an external identity provider.
• Logs — for diagnosing configuration problems after the instance is running.

Treat configuration and security as part of setup: an instance that installs cleanly but is left with default access settings is not finished.

Updating and migrating versions

The documentation keeps Updating and Version 1 Migration as separate pages under Getting Started. If you are moving from an older release, read the migration guide before upgrading, since it exists specifically to cover that transition. For routine maintenance, the Updating page is the reference.

Backups and integrations

Backup and Restoring is documented as its own topic, and the community guides go further with Automating Backups with n8n. Other community guides cover importing and integrating:

• Import from other apps — the feature overview lists this as a first-class capability.
• Bulk URL Import and Bookmarklet — for adding recipes from the web.
• Home Assistant Import and an iOS Shortcut — for pulling recipes in from those environments.
• Bring API without internet exposure — relevant if you want API access without exposing the instance publicly.

Where to go next

The documentation's own navigation is the most reliable map: Getting Started (Introduction, Features, Updating, Version 1 Migration, FAQ, API, Road Map), Installation, Usage, Authentication, Community Guides, API Reference, and the contributor and developer guides. If you are still deciding whether Mealie fits your needs at all, read the Features page before committing to an installation path.

Mealie is a self-hosted recipe manager whose documentation lists a defined technology stack plus separate resources for users, API consumers, and contributors. If you are deciding whether to deploy it yourself or build on top of it, the useful signals are the documented installation paths, the API reference, and the contributor and developer guides. The documentation does not publish a full dependency list or version numbers on the pages referenced here, so treat the stack as described at a category level rather than as a pinned specification.

What the documentation says about the technology stack

The documentation includes a dedicated "Technology stack" section alongside Installation, Feature overview, Import from other apps, and Project links. That grouping matters: the stack is presented as one of the project's identifying characteristics, not buried in a changelog.

The same documentation set also covers AI Providers as a configuration topic, which tells you the application is designed to integrate with external AI services rather than shipping a fixed built-in model. The specific providers are not enumerated in the material available here, so check the AI Providers page in the docs before assuming a particular vendor is supported.

Database options

Two database paths are documented:

If you want the lowest-friction self-hosted setup, SQLite is the documented default recommendation. PostgreSQL is the option to evaluate when you expect concurrent access, larger datasets, or you already run Postgres in your environment. The docs do not state migration tooling between the two here, so plan that as a separate question.

Installation and deployment resources

The Installation section is structured as a checklist rather than a single command, which is a reasonable indicator that deployment involves several decisions rather than one script. Documented installation-related topics include:

• Installation Checklist — the starting point for a new deployment
• Backend Configuration — server-side settings
• Security — hardening and access considerations
• Logs — where to look when something fails
• Updating — how to move between versions
• Version 1 Migration — a path for users coming from an older major version

Authentication is documented with LDAP and OpenID Connect support, which is the relevant detail if you need Mealie to sit behind an existing identity provider instead of managing its own accounts. There is also a Reverse Proxy (SWAG) community guide, useful if you are fronting the app with a proxy rather than exposing it directly.

Project links and developer resources

The documentation separates audiences clearly, which is a good sign for anyone evaluating long-term maintenance:

• API — an API reference exists, so programmatic access is a first-class concern rather than an afterthought.
• Contributors Guide — split into Non-Code (including Translating) and Developers Guide.
• Developers Guide — covers Building Packages, Code Contributions, Dev Getting Started, and Database Changes.
• Maintainers Guide and Migration Guide — governance and upgrade paths.
• Road Map — forward-looking plans.
• FAQ — common questions.

The presence of a translating workflow, a database-changes section, and a maintainers guide indicates an active multi-contributor project rather than a single-author script. For a self-hoster, that generally means upgrade instructions and issue triage are more likely to exist; for a developer, it means there is a documented path to submit changes rather than reverse-engineering the codebase.

Community guides worth knowing about

Beyond core documentation, the community guides cover practical integration and automation tasks:

• Bring API without internet exposure — relevant if you want API access on a network that is not publicly reachable
• Automating Backups with n8n — backup automation via an external workflow tool
• Bulk URL Import — importing many recipes at once
• Home Assistant Import — pulling recipes from a Home Assistant instance
• Bookmarklet and iOS Shortcut — capturing recipes from a browser or phone

These are user-contributed rather than core docs, so verify steps against your own version before relying on them.

How to use this to make a decision

If your goal is self-hosting a recipe manager, the documented SQLite-recommended path plus the installation checklist and reverse proxy guide give you a workable starting sequence; the LDAP/OpenID Connect support is the deciding factor if you need SSO.

If your goal is building on Mealie, the API reference and the developer guide sections on dev setup and database changes are your entry points, and the road map tells you where the project is heading.

If your goal is contributing, start with the contributors guide and pick the non-code or developer track depending on whether you are translating or writing code.

What the documentation does not give you here is a versioned dependency manifest, a support matrix, or a release cadence. Those are the gaps to close by checking the project links and the API reference directly before committing to a deployment or an integration.

Mealie is a self-hosted recipe management application. You run it on your own server or computer, and it gives you a central place to store, organize, and retrieve recipes for yourself or your household. It fits people who want their recipe collection on infrastructure they control rather than inside a third-party cloud service. The project's documentation covers installation, a feature overview, importing from other apps, and the technology stack, so you can evaluate it before committing.

What problem it solves

Most recipe collections end up scattered: browser bookmarks, screenshots, notes apps, email to yourself, and a few sites you keep revisiting. Mealie consolidates that into one searchable library you host yourself. Instead of depending on a vendor's account and uptime, you keep the data and decide who can access it.

Core capabilities

Based on the documentation's feature overview and usage sections, Mealie is built around:

• A centralized recipe library — save and organize recipes in one place rather than across scattered tools.
• Import from other apps — the docs include a dedicated "Import from other apps" path, so migrating an existing collection is a first-class concern.
• Backup and restore — documented under Usage, which matters when you are the one responsible for the data.
• Permissions and public access — you can control who sees what, including making parts public.
• Authentication options — the docs cover LDAP and OpenID Connect, which is relevant if you want to integrate with existing accounts.
• API access — an API reference is provided, enabling automation and integrations.

How it is deployed

Mealie is self-hosted, and the installation docs give you a choice of database:

The installation section also includes a checklist, backend configuration, security, and logging topics. In practice this means you need somewhere to run the app — a home server, a NAS, a VPS, or similar — and you follow the installation checklist rather than a one-click signup.

When Mealie is a good fit

Choose Mealie if:

• You want your recipes stored on hardware you control.
• You are comfortable running and maintaining a self-hosted service.
• You want household-level sharing with permission controls.
• You may want to integrate with existing authentication (LDAP, OpenID Connect) or automate via the API.

Look elsewhere if you want a zero-maintenance hosted service with no server to run, or if you have no interest in managing backups and updates yourself.

Getting oriented

The documentation is organized so you can move in a sensible order:

1. Getting Started → Introduction / Features — understand what the app does.
2. Installation — pick SQLite (recommended) or PostgreSQL and work through the checklist.
3. Usage — learn backup/restore, permissions, and public access.
4. Authentication — set up LDAP or OpenID Connect if you need it.
5. Community Guides — practical recipes such as automating backups with n8n, bulk URL import, Home Assistant import, and reverse proxy setups.

There is also a migration guide and a version 1 migration page, which is worth checking if you are coming from an older Mealie release or another tool.

Mealie supports bringing recipes in from other apps, and the documentation lists "Import from other apps" as a first-class feature area alongside installation and usage. The practical routes are a bulk URL import (covered in the community guides) and the migration guide for people moving off an older version. What you can't assume is that every source app has a dedicated one-click importer — for most apps you'll be importing by URL, then cleaning up the result.

What Mealie actually offers for imports

From the documentation structure, the import-relevant entry points are:

• Import from other apps — a top-level feature area in the docs, separate from general usage.
• Bulk URL Import — listed under Community Guides, i.e. a documented workflow rather than a core menu item.
• Version 1 Migration and a Migration Guide — for moving data from an older Mealie version, not from third-party apps.
• Improving Ingredient Parser — a guide that exists precisely because imported ingredient lines often need parsing fixes.

That last point is the honest framing: Mealie's import story is "get the recipe in, then fix the structured fields," not "every source app maps cleanly."

Bulk URL import: the general workflow

The docs describe bulk URL import as a community guide, so treat the exact UI labels as something to confirm in your own instance. The shape of the task is:

1. Collect the source URLs. Export or copy the recipe links from the app you're leaving. If that app has no export, you'll be copying links manually.
2. Feed them to Mealie's bulk import. You provide a list of URLs; Mealie fetches each page and creates a recipe entry from it.
3. Expect partial results. Pages behind a login, JavaScript-only recipe cards, or heavy anti-scraping will fail or come in thin. Re-run or add those manually.
4. Review each imported recipe. Check the ingredient list, quantities, and steps — this is where the ingredient parser guide becomes relevant.

The expected result is a set of draft recipes in your Mealie instance, not a finished library.

Importing from a specific app

The documentation does not enumerate per-app importers in the material available here, so don't plan around a "Import from Paprika/Nextcloud/whatever" button existing. Two things are worth checking before you commit to a method:

• Whether your source app can export to a file format (JSON, HTML, or a URL list). A file export is usually more reliable than scraping.
• Whether your source app's recipes are publicly reachable URLs. Bulk URL import depends on Mealie being able to fetch the page.

If the source app only exports a proprietary archive, the realistic path is exporting it, converting what you can to URLs or a supported format, and importing in batches.

What to check after importing

Imported recipes are the most common source of messy data. Verify:

The "Improving Ingredient Parser" guide exists for the first row — if your imports consistently mis-parse, that's the doc to read rather than fixing every recipe by hand.

Related docs worth reading first

• Installation Checklist — confirm your instance is set up before bulk-importing into it.
• Backup and Restoring — take a backup before a large import so you can roll back a bad batch.
• Migration Guide / Version 1 Migration — only relevant if you're coming from an older Mealie, not from another app.
• API Reference — if you'd rather script the import than use the UI, this is the entry point.

Choosing your approach

• Few recipes, public URLs → bulk URL import, then clean up.
• Many recipes, source app has file export → export first, convert to URLs or a supported format, import in batches.
• Coming from old Mealie → follow the Migration Guide, not the app-import path.
• Recipes behind a login → no documented bulk path; plan on manual entry or a script against the API.