Your saved links are a mess. A few live in your browser’s bookmark bar, others are scattered across Pocket, Raindrop.io, or a Google Sheet you never open. Some of those pages have already disappeared—link rot is real—and the service holding your curated collection could pivot or shut down at any moment. Even if the site stays up, you’re trusting someone else to keep your data, your privacy, and your access forever. There’s a better way. Linkwarden is an open-source, self-hosted bookmark manager that doesn’t just save links; it quietly archives the full page content so that the article you bookmarked today remains readable ten years from now. In this guide, we’ll walk through setting up your own instance, configuring automatic snapshots, and building a permanent, private archive you truly control.

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. Every bookmark you save to a hosted service becomes part of a profile that can be analysed, sold, or leaked. Even well-intentioned providers can be breached. Self-hosting flips that dynamic: your data lives on hardware you own, behind a firewall you control. Nobody else can see which pages you’re saving or how you’re tagging them.

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 automatic snapshots mean your saved reading stays readable, even when the original site is gone.

What Is Linkwarden and How Does It Compare?

Linkwarden is an open-source bookmark manager and web archiver built with Next.js and PostgreSQL. It offers a clean web interface, browser extensions for Chrome and Firefox, and a flexible API. The killer feature is built-in page archiving: each time you save a link, Linkwarden can fetch and store a static copy of the page using either SingleFile (a self-contained HTML snapshot with images and styles) or Readability (a cleaned-up text-and-image version). You can also upload your own PDF or screenshot as a manual snapshot. Everything stays inside your database or a configured file storage location, so you never lose a page to takedowns or domain expirations.

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.

Compared to other self-hosted bookmark tools, Linkwarden stands out for its polish and its archival focus. Shiori is a lightweight alternative with basic page archiving, but its single-file executable and simpler UI feel less feature-rich for daily heavy use. Wallabag is excellent for capturing articles to read later, offering a reading view and tagging, but it’s not a full bookmark manager—it’s more of a Pocket replacement, and its archiving is designed for text-heavy pages. Shaarli is a minimalist, database-free bookmarking engine that runs great on tiny hardware, but it stores only links and descriptions; there’s no built-in snapshot mechanism. Linkwarden marries the best of both worlds: it manages bookmarks like Shaarli while archiving content like a dedicated web archiver, all inside a modern interface that feels at home alongside your other homelab dashboards. If you want one place to store links and ensure they survive, Linkwarden makes a compelling choice.

Getting Linkwarden Up and Running

The easiest way to deploy Linkwarden is with Docker and Docker Compose. The project maintains an official image and a sample compose file that bundles the app, a PostgreSQL database, and optional Redis for caching.

First, create a directory for Linkwarden and a docker-compose.yml file:

version: "3.8"
services:
  linkwarden:
    image: ghcr.io/linkwarden/linkwarden:latest
    container_name: linkwarden
    ports:
      - "3000:3000"
    environment:
      - NEXTAUTH_URL=http://localhost:3000
      - NEXTAUTH_SECRET=replace_with_a_long_random_string
      - DATABASE_URL=postgresql://postgres:${POSTGRES_PASSWORD}@db:5432/linkwarden
      - REDIS_URL=redis://redis:6379
      - STORAGE_FOLDER=/data/storage
    volumes:
      - ./data:/data/data
      - ./storage:/data/storage
    depends_on:
      - db
      - redis
    restart: unless-stopped

  db:
    image: postgres:15-alpine
    container_name: linkwarden-db
    environment:
      POSTGRES_DB: linkwarden
      POSTGRES_USER: postgres
      POSTGRES_PASSWORD: ${POSTGRES_PASSWORD}
    volumes:
      - ./pgdata:/var/lib/postgresql/data
    restart: unless-stopped

  redis:
    image: redis:7-alpine
    container_name: linkwarden-redis
    restart: unless-stopped

Set a strong POSTGRES_PASSWORD in a .env file and generate a random string for NEXTAUTH_SECRET (you can use openssl rand -base64 32). Adjust the port and paths to suit your environment. If you already run a PostgreSQL instance, you can point DATABASE_URL there and omit the bundled database service. On a Raspberry Pi, stick with the standard image—it works well on ARM.

Start the stack:

docker compose up -d

On first launch, the application creates the database schema automatically. Navigate to http://your-server-ip:3000 and create an admin account. The first user registered becomes the administrator. Change NEXTAUTH_URL to your actual domain if you plan to put Linkwarden behind a reverse proxy, otherwise authentication callbacks may fail.

First Steps: Configuring Your Archive Settings

Before you start saving everything, take a moment to tailor the archiving behaviour. Log in and head to Settings → Archives. Linkwarden offers two archiving engines: SingleFile and Readability. SingleFile archives the complete page as a self-contained HTML file, preserving layout, images, fonts, and even interactive elements—this yields the most faithful snapshots but can consume more storage per bookmark (a few hundred KB to a few MB). Readability strips the page down to its main text and images, similar to a reading mode, producing much smaller files and a cleaner reading experience. You can’t use both on a single bookmark, but you can switch later and re-archive specific items.

Choose the format that matches your goal. If you’re archiving documentation or pages with heavy formatting, stick with SingleFile. If you’re mostly saving articles to read later and want to save disk space, Readability is great. The setting applies to all new bookmarks by default; you can override it individually when saving.

Next, check the Storage settings. By default, archived files are stored in the database. For a larger collection, consider using the Filesystem storage driver and pointing it to the /data/storage volume you mapped in the compose file. This keeps database backups smaller and makes it easier to manage archives directly on the filesystem. Set the path to /data/storage and the URL format accordingly.

Finally, enable the Automatic Snapshot toggle. Without it, you have to manually request an archive for each bookmark. With it on, Linkwarden will grab a snapshot as soon as you save the link, and optionally re-archive it periodically if you configure a schedule (daily, weekly, monthly). That’s especially useful for pages that change over time, like documentation or dashboards.

Saving Bookmarks and Using the Browser Extension

You can add a bookmark from the web UI by clicking the New Link button, pasting the URL, and optionally setting a collection, tags, description, and archive method. 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.

Now, when you’re on a page you want to keep, click the extension icon. A popup lets you set the title, collection, tags, and choose to archive now or later. The extension can also pre-fill the page title, and you can enable a quick-save mode that instantly sends the bookmark with your default settings and a single click. If you’ve enabled automatic snapshots in your profile, the archive happens in the background—no extra steps needed.

For importing an existing trove of bookmarks, head to Settings → Import. Linkwarden accepts standard HTML bookmark exports from browsers, as well as CSV files from services like Raindrop.io or Pocket exports. It’s a good idea to run a test import first with a small set, then review how titles and tags map. After importing, you can trigger bulk archiving for all imported links using the “Re-archive” action on the Links page.

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”. The search bar supports title, description, collection name, and tags, so a query like tag:docker or collection:homelab narrows things down quickly. Full-text search of the archived content isn’t built in yet, but you can combine search with the tagging system to find what you need.

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 bookmarks and archives reside in two places: the PostgreSQL database (which holds metadata, tags, and potentially archived files if you stored them there) and the filesystem storage folder if you chose that option. You must back up both.

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

docker exec linkwarden-db pg_dump -U postgres linkwarden > backup.sql

Store the dump outside your homelab server (a NAS, an S3 bucket, or a second disk). If you use filesystem storage, also back up the entire /data/storage volume. With these two backups, you can restore your entire library on a fresh machine in minutes.

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 linkwarden
docker compose up -d linkwarden

Always check the release notes for any breaking changes, especially around environment variables or database migrations. The project tends to make migrations backward-compatible, but a quick review never hurts.

Disk space will grow. SingleFile archives can be a few megabytes each; 5,000 bookmarks might consume 10–20 GB. That’s not much by modern standards, but on a small SSD or SD card it adds up. Monitor usage, and consider periodically archiving older bookmarks with Readability to slim things down, or purging snapshots you no longer need.

Conclusion

Linkwarden turns your homelab into a personal Wayback Machine for the pages you actually care about. 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 becomes a muscle-memory action that guarantees the page stays readable forever. Regular database and filesystem backups, plus an eye on storage growth, will keep the system humming. 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.