Linkwarden: Self-Hosted Bookmark Manager with Full-Page Archiving

The Problem Linkwarden Addresses

Web pages disappear. A bookmark saved today may return a 404 in two years, a paywall in six months, or a domain-squatter page in a decade. This is link rot, and it is the core problem Linkwarden is built to solve. Rather than storing only a URL and a title, Linkwarden automatically captures a full-page screenshot, a PDF export, and a single-file HTML snapshot of each page you bookmark. The HTML copy is produced with the monolith tool, which embeds all page resources inline so the file can be opened without a network connection.

The project targets engineers, researchers, journalists, and anyone who depends on specific web content for ongoing reference work. The cloud offering at linkwarden.app handles hosting for subscribers who prefer not to manage infrastructure. The self-hosted path, covered in detail here, keeps your archive entirely under your own control with no per-link storage limits beyond your own disk.

Repository Layout and Capture Pipeline

Linkwarden is a TypeScript monorepo managed with Yarn workspaces. The `apps/` directory holds two packages: `@linkwarden/web` (the Next.js front end) and `@linkwarden/worker` (the background archival worker). The `packages/` directory provides shared libraries for Prisma database access, filesystem operations, routing, and shared type definitions.

The Dockerfile builds in two stages. The first stage compiles the Rust-based monolith binary (version 2.10.1) used for single-file HTML captures. The second stage installs Node.js dependencies via Yarn and builds the Next.js application. The final runtime image installs Playwright and its browser binaries, which drive screenshot and PDF capture. Because Playwright bundles a full browser, the final container image is large, but it requires no external browser service.

The docker-compose.yml bundles three services: the Linkwarden application container on port 3000, a PostgreSQL 16 Alpine database, and a Meilisearch instance for full-text search. Meilisearch indexes link names, descriptions, tags, and extracted text content, enabling search across the full archive rather than just metadata.

Deploying Linkwarden with Docker Compose

The official self-hosted path uses the provided docker-compose.yml. Copy .env.sample to .env, fill in the two required secrets, and start the stack:

cp .env.sample .env
docker compose up -d

The application is accessible at http://localhost:3000 after startup. When deploying behind a reverse proxy, set `NEXTAUTH_URL` to the externally reachable URL.

The .env.sample documents every optional setting. Notable ones include `MAX_LINKS_PER_USER` to cap storage per account, `BROWSER_TIMEOUT` to control how long Playwright waits before abandoning a capture attempt, and `MAX_WORKERS` to limit concurrent archival jobs. Setting `PLAYWRIGHT_WS_URL` lets you point Linkwarden at a remote Playwright instance rather than running a browser inside the application container, which is useful on memory-constrained servers.

For AI tagging, the sample exposes `NEXT_PUBLIC_OLLAMA_ENDPOINT_URL` and `OLLAMA_MODEL` for a local Ollama instance, or `OPENAI_API_KEY` and `OPENAI_MODEL` for an OpenAI-compatible provider. Setting either enables automatic tag suggestions based on link content. These settings are optional; Linkwarden runs fully without them.

Database schema changes between releases are managed with Prisma. After pulling a new image, apply migrations before restarting:

docker compose run --rm linkwarden yarn prisma:deploy
docker compose up -d

Collaboration, Sharing, and Access Control

Links are organized into collections and sub-collections. Each collection can be shared publicly as a read-only page, allowing you to publish a curated set of links without requiring visitors to have a Linkwarden account. Alternatively, you can share a collection with specific users on the same Linkwarden instance and assign different permissions per member, controlling whether they can add, edit, or only view links.

The RSS feed subscription feature pulls links automatically from external feeds into a collection, useful for archiving coverage of a specific topic over time. Bulk actions (move, tag, delete) reduce the overhead of managing large collections. An iOS shortcut is documented for saving links from the iOS share sheet. A browser extension is available for all major browsers, and Floccus-based synchronization enables two-way sync with the browser's native bookmarks folder.

SSO integration (via OIDC or SAML providers) is limited to the self-hosted and Enterprise tiers. The free cloud tier does not include SSO. The API key system allows programmatic access for automation, import pipelines, or integration with other tools.

Limitations and Cases Where Linkwarden Is the Wrong Tool

Each archived link triggers Playwright to launch a headless browser, load the full page, produce a screenshot, generate a PDF, and run monolith for the HTML copy. On a server with limited RAM, concurrent captures can cause worker failures or timeouts. Reducing `MAX_WORKERS` helps stability but slows archival throughput. The worker and the Meilisearch service compete for memory, so instances with less than 2 GB of available RAM will face problems.

The AGPL-3.0 license includes a network use clause. Organizations that modify Linkwarden and make the modified version available over a network must release the modified source. Private self-hosting without code changes carries no such obligation, but any customization intended for a commercial multi-tenant service requires a legal review of the AGPL terms.

Linkwarden is not a minimalist read-it-later tool. The reader view exists and supports highlighting and annotation, but it is secondary to the archival function. If your only need is clean article extraction for offline reading without full-page preservation, a dedicated tool designed around that workflow is simpler to operate.

Linkwarden vs. Raindrop.io

Raindrop.io is a cloud-based bookmark manager with a polished interface, browser extensions for every major browser, and a free tier. It stores metadata and link previews but does not create offline copies of linked pages by default. Link rot remains a risk for Raindrop users.

Linkwarden's core trade-off is that you own the archive. A Raindrop account holds your bookmarks on Raindrop's servers; a Linkwarden installation keeps both the metadata and the full-page copies on your own storage. The self-hosted path demands operational effort that a Raindrop subscription avoids.

Both products offer native mobile apps for iOS and Android. The choice between them comes down to one question: do you need guaranteed offline access to full-page snapshots, or is cloud-hosted metadata with fast search sufficient? Linkwarden answers the first need, Raindrop.io the second.

Maintenance, Licensing, and Upgrade Path

Linkwarden is under active development. The last push was on 2026-09-10, and v2.16.3 was released on 2026-09-09. Releases have followed a consistent cadence through 2026, with multiple patch releases per month.

The project is licensed under AGPL-3.0. For private self-hosting without modifications, the license imposes no obligations beyond what it requires of the original codebase. Commercial deployments that modify the source need careful review of the network use provision.

The monorepo uses Yarn 4 and Prisma for database schema management. After each upgrade, reviewing the .env.sample diff for newly added environment variables is worthwhile. The CHANGELOG and release notes on GitHub document breaking changes and required migration steps between minor versions.

Editorial conclusion

Linkwarden is the right choice for engineers, researchers, and small teams who need a permanent, searchable archive of saved links rather than a simple sync list. Anyone running three Docker services on a modest VPS will find the operational overhead acceptable. If your only goal is syncing bookmarks across browsers without archiving, a lighter tool such as Linkding requires far fewer resources. Before deploying, confirm that your server meets the memory requirements for three concurrent services, then set NEXTAUTH_SECRET and POSTGRES_PASSWORD before running `docker compose up -d`.

Frequently asked questions

Official sources

1. Official documentation
2. Official README
3. Project repository
4. Release notes