Linkwarden is a self-hosted bookmark manager that organizes links and preserves saved pages in several formats. Deploy it with the official Docker Compose stack, then protect its database, stored captures, and search index with regular backups.

Why Self-Host Your Bookmarks?

Most people store bookmarks inside a browser’s sync system or a third-party service. Browser sync is convenient, but it ties your library to one vendor and one device ecosystem. If you switch browsers or lose access to that account, the links can vanish. Third-party services add features like tagging and full-text search, yet they come with their own risks: the company can change its pricing model, strip away the free tier, or simply go out of business. When that happens, exporting your data may be an afterthought—if it’s even possible.

Privacy is another concern. A hosted bookmark service necessarily processes the URLs and metadata you save. Self-hosting moves that database and archive storage onto infrastructure you control, but it does not make activity invisible: the Linkwarden host, DNS/network providers, and sites fetched for preservation can still observe parts of the workflow. Protect logs, accounts, backups, and outbound traffic accordingly.

Link rot is the silent killer of bookmark collections. Studies show that a significant fraction of web pages disappear within a few years. Saving only the URL is like writing a library call number on a scrap of paper—if the library burns down, the reference is useless. Self-hosting with web archiving solves this because the software can take a snapshot of the full page content at the moment you bookmark it. This complements the homelab mindset perfectly: you’re not just cataloguing the web; you’re preserving it on your own hardware, with full control over retention and backups. Linkwarden’s preserved copies can keep useful material available after an original disappears, subject to capture quality and your own backups.

What Is Linkwarden and How Does It Compare?

Linkwarden is an open-source bookmark manager and web archiver built around a web application, PostgreSQL, and optional Meilisearch-powered advanced search. It can automatically preserve a page as a screenshot, PDF, readable text, and Monolith HTML, with formats configurable in archive preferences. Preserved files are stored under the configured local STORAGE_FOLDER by default, or in configured S3-compatible object storage—not automatically inside PostgreSQL. Preservation is best-effort: authentication walls, anti-bot systems, dynamic applications, and external media can still produce incomplete captures.

On top of archiving, Linkwarden supports collections (folders), rich tags, search, import of bookmarks from browsers and other services, and export to HTML or CSV. There’s multi-user support, so you can share a server with family or a small team, and optional public page sharing. A dark mode, REST API, and mobile-friendly design round out the package.

The important comparison is workload rather than a permanent feature ranking. Linkwarden emphasizes multi-format preservation and collaboration; read-later tools may emphasize extraction and reading, while minimalist bookmark managers may use fewer services. Check each project’s current documentation before choosing, then test import/export and preservation against the kinds of pages you actually save.

Getting Linkwarden Up and Running

Linkwarden maintains an official self-hosting setup and Compose file. Download those instead of copying a stack from an article, because the dependencies and required variables have changed:

mkdir linkwarden && cd linkwarden
curl -O https://raw.githubusercontent.com/linkwarden/linkwarden/refs/heads/main/docker-compose.yml
curl -L https://raw.githubusercontent.com/linkwarden/linkwarden/refs/heads/main/.env.sample -o .env

Edit .env and give each secret a different strong value:

NEXTAUTH_URL=http://localhost:3000/api/v1/auth
NEXTAUTH_SECRET=replace_with_a_long_random_secret
MEILI_MASTER_KEY=replace_with_a_different_random_secret
POSTGRES_PASSWORD=replace_with_a_database_password

For a reverse-proxied deployment, change the origin in NEXTAUTH_URL but keep the required /api/v1/auth suffix—for example, https://links.example.com/api/v1/auth. The current environment-variable reference calls out that suffix explicitly.

Start the unmodified stack:

docker compose up -d
docker compose ps

The maintained Compose file currently includes PostgreSQL 16 and Meilisearch alongside Linkwarden. It mounts pgdata, data, and meili_data; those are durable application state. Open http://your-server-ip:3000, create the initial account, and configure a reverse proxy and TLS before exposing it outside a trusted network. Review release notes before every upgrade rather than assuming a latest image is migration-free.

First Steps: Configuring Preservation

Open Settings → Preferences → Archive Settings and choose which formats your instance should generate. Current Linkwarden can preserve multiple formats for the same link: screenshot, PDF, readable text, and Monolith HTML. You do not have to choose a single “SingleFile versus Readability” engine.

Each format has a different purpose. Readable text supports a clean reading view, highlights, and full-text indexing. PDF captures a printable representation. Screenshots preserve appearance, and Monolith HTML keeps a self-contained HTML rendition where possible. None is guaranteed to reproduce every dynamic or authenticated site, so test representative pages before trusting the archive.

By default, local files live under STORAGE_FOLDER (normally the mounted data directory). S3-compatible storage is optional and is enabled only when the required SPACES_* variables are configured. For stronger browser isolation, Linkwarden also documents a separate user-content domain for serving untrusted preserved HTML. Do not invent a database-storage toggle that current Linkwarden does not expose.

Add a test link, wait for the background worker, and confirm the formats you enabled appear. Then inspect data/archives on the host and confirm that your backup captures it.

Saving Bookmarks and Using the Browser Extension

You can add a bookmark from the web UI by clicking New Link, supplying the required address and collection, and optionally adding tags, a name, or a description. But the real convenience comes from the browser extension. Install it from the Chrome Web Store or Firefox Add-ons, then point it to your instance’s URL in the extension settings. Log in with your account.

When you are on a page you want to keep, use the extension to send it to your self-hosted instance without leaving the tab. Follow Linkwarden’s current browser-extension setup for the supported browsers and instance-address login flow; popup fields and behavior can change with extension versions.

For importing an existing trove of bookmarks, head to Settings → Import. Linkwarden’s documented profile import accepts the standard bookmarks HTML format exported by major browsers. It’s a good idea to run a test import first with a small set, then review how titles and tags map. After importing, review a sample of titles, collections, and preserved formats before processing a large archive backlog.

Linkwarden’s organisational backbone is Collections, essentially folders. You can nest collections to create a hierarchy—for example, “Homelab” might contain “Networking”, “Docker”, and “Storage”. A bookmark lives in exactly one collection at a time, though you can move it around later.

Tags are more flexible: they’re free-form labels that let you attach multiple keywords to any bookmark. Use them for cross-cutting themes like “security”, “reference”, or “to-read”. Search covers bookmark metadata, and the standard Compose stack includes Meilisearch for advanced operators and full-text search across preserved readable content. If you deliberately remove Meilisearch for a lighter deployment, you retain metadata search but lose those advanced and full-text capabilities. Linkwarden documents that trade-off in its lighter-setup guide.

A few tagging habits are worth adopting early. Tag bookmarks by action (“read-later”, “reference”, “project-xyz”) and by status if you plan to revisit them. Use the “Unarchived” filter to find links that still need a snapshot. Periodically pruning duplicates and dead collections keeps the interface fast and the database manageable.

Maintaining Long-Term Integrity: Backups and Updates

Self-hosting puts you in charge of durability. Your deployment has several durable parts: PostgreSQL metadata, the mounted data directory containing local archives and uploads, and Meilisearch data if you want to preserve the current search index rather than rebuild it. If you configure S3-compatible storage, include that bucket in the recovery plan too. Back up the Compose file and .env securely without publishing its secrets.

For the database, a simple pg_dump run nightly via cron is enough. If your containerised database includes pg_dump, you can run:

docker compose exec -T postgres pg_dump -U postgres postgres > backup.sql

Store the dump outside your homelab server (a NAS, an S3 bucket, or a second disk). Also back up the host directories mounted by the current Compose file—normally data, pgdata, and meili_data. Test a restore on a separate system; recovery time depends on archive size and database integrity, so do not promise a minutes-long restore you have never measured.

Keep the application updated. The Linkwarden project moves quickly, adding features and fixing bugs. Watch the GitHub releases, and when a new version drops, pull the latest image and recreate the container:

docker compose pull
docker compose up -d

Always check the release notes for breaking changes, especially around environment variables, database migrations, and required dependency versions. Take a current backup before upgrading and verify the application and preservation worker afterward.

Disk space grows with screenshots, PDFs, Monolith HTML, and imported files. The result varies too much by page to estimate from bookmark count alone. Monitor data/archives (or your object-storage bucket) and disable preservation formats you do not need under Settings → Preferences → Archive Settings. Linkwarden notes that PDF and Monolith are the most expensive formats, while readable text is the cheapest.

Conclusion

Linkwarden gives your homelab a maintained archive of the pages you choose to preserve. It combines the convenience of a modern bookmark manager with the assurance of local, automatic web archiving, all under your own roof. The initial setup with Docker is straightforward, and once you’ve tailored the archive settings and installed the browser extension, saving a link can automatically queue preservation in several formats. Regular, tested database and archive backups plus monitored storage growth are what make that preservation durable. If you’ve ever lost a critical guide or a beloved article to link rot, a self-hosted bookmark archive is one of the most satisfying things you can add to your homelab—and Linkwarden makes it friendly enough that you’ll actually use it every day.