Best Self-Hosted Bookmark Managers 2026: Linkding vs Shaarli vs Wallabag

Every developer, researcher, and power user accumulates hundreds — eventually thousands — of bookmarks. Browser bookmark sync keeps them accessible, but you are trading convenience for dependency on a single vendor’s ecosystem and data practices. Self-hosted bookmark managers give you full control, cross-browser access, powerful search, and the ability to keep your reading list private.

This guide covers the three most capable self-hosted bookmark tools in 2026: Linkding, Shaarli, and Wallabag. We will compare their features, walk through docker installation for each, and help you decide which one fits your workflow.

Why Self-Host Your Bookmarks

Browser-native bookmarks have become increasingly inadequate for serious information management:

• Vendor lock-in: Chrome bookmarks do not migrate cleanly to Firefox or Safari. Each browser stores them in its own format and sync ecosystem.
• No full-text search: Browser bookmarks only let you search by title and URL. If you saved an article because of a specific paragraph, good luck finding it later.
• No archival: When the original site goes down, gets paywalled, or changes its URL, your bookmark is dead. A self-hosted manager can save a copy.
• Privacy concerns: Browsers track which pages you visit, how often, and when. Cloud sync means a third party holds a complete map of your interests.
• No tagging or organization beyond folders: Real information management needs tags, annotations, and the ability to cross-reference.
• Collaboration: Sharing a curated list of resources with a team is awkward with browser bookmarks. Self-hosted tools support shared collections.

Running your own bookmark server means your reading history belongs to you. You can search, tag, annotate, and archive without any telemetry or vendor constraints.

The Three Contenders

Linkding

Linkding is a lightweight, modern bookmark manager designed for speed and simplicity. Written in Python with Django, it offers a clean web interface, a REST API, browser extensions for Chrome and Firefox, and full-text search through article content. It is one of the fastest-growing self-hosted bookmark tools, with a strong focus on developer ergonomics.

Key characteristics:

• License: MIT — fully open source
• Language: Python (Django backend, vanilla JS frontend)
• Database: PostgreSQL or SQLite
• API: Full REST API for programmatic access
• Browser extensions: Official Chrome and Firefox extensions

Shaarli

Shaarli is the veteran of self-hosted bookmarking, first released in 2011. It is a minimalist, single-user (or multi-user) link sharing platform written in PHP. Shaarli emphasizes simplicity, speed, and portability — it runs on virtually any PHP host with no database requirement.

Key characteristics:

• License: zlib — fully open source
• Language: PHP (no framework, no build step)
• Database: Flat files (JSON) — no database server needed
• API: REST API available
• Browser extensions: Community-maintained extensions for Chrome and Firefox

Wallabag

Wallabag is a self-hosted “read it later” application that goes beyond simple bookmarking. It extracts and saves the full article content from any URL, giving you a clean, readable offline copy. Think of it as a self-hosted Pocket or Instapaper alternative with powerful annotation and export features.

Key characteristics:

• License: MIT — fully open source
• Language: PHP (Symfony framework)
• Database: MySQL, PostgreSQL, or SQLite
• API: Full REST API with OAuth2
• Browser extensions: Official Chrome, Firefox, Safari, and mobile apps

Feature Comparison

Installing Linkding with Docker

Linkding has the smoothest Docker experience of the three. A single docker-compose.yml file gets you a fully working bookmark manager in under a minute.

Step 1: Create the Docker Compose file

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

version: "3.8"

services:
  linkding:
    image: ghcr.io/sissbruecker/linkding:latest
    container_name: linkding
    restart: unless-stopped
    ports:
      - "9090:9090"
    volumes:
      - ./data:/etc/linkding/data
    environment:
      - LD_SUPERUSER_NAME=admin
      - LD_SUPERUSER_PASSWORD=change-me-to-a-strong-password
      - LD_DISABLE_BACKGROUND_TASKS=False
      - LD_ENABLE_AUTH_PROXY=False
    networks:
      - bookmarks

networks:
  bookmarks:
    driver: bridge

Step 2: Start the service

1
2

mkdir -p ~/linkding/data
docker compose up -d

Visit http://your-server-ip:9090 and log in with the superuser credentials you set.

Step 3: Install the browser extension

Linkding provides official browser extensions for Chrome and Firefox. After installing, configure the extension to point to your Linkding instance URL and authenticate with your API token (found in Settings > API).

Step 4: Enable content archiving (optional)

Linkding can save full-page snapshots using the singlefile binary. To enable this:

1
2
3
4
5
6
7
8
9

services:
  linkding:
    image: ghcr.io/sissbruecker/linkding:latest
    environment:
      - LD_ENABLE_ARCHIVE_SAVING=True
      - LD_ARCHIVE_SINGLEFILE_PATH=/usr/bin/singlefile
    volumes:
      - ./data:/etc/linkding/data
      - ./singlefile:/usr/bin/singlefile:ro

Download the singlefile CLI binary from GitHub and place it in the mounted directory.

Step 5: Import existing bookmarks

Go to Settings > Import and upload your browser’s exported bookmarks file (Netscape HTML format). Linkding preserves folder structure as tags during import.

Installing Shaarli with Docker

Shaarli is the lightest option and requires no database. It is ideal for low-resource environments like a Raspberry Pi or a cheap VPS.

Step 1: Create the Docker Compose file

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

version: "3.8"

services:
  shaarli:
    image: shaarli/shaarli:latest
    container_name: shaarli
    restart: unless-stopped
    ports:
      - "8080:80"
    volumes:
      - ./shaarli-data:/var/www/shaarli/data
      - ./shaarli-cache:/var/www/shaarli/cache
    environment:
      - SHAARLI_LOGIN=admin
      - SHAARLI_PASSWORD=change-me-to-a-strong-password
      - SHAARLI_TITLE=My Bookmarks
      - SHAARLI_ENABLE_UPDATE_CHECKING=False

Step 2: Start the service

1
2

mkdir -p ~/shaarli/shaarli-data ~/shaarli/shaarli-cache
docker compose up -d

Visit http://your-server-ip:8080 to complete the setup wizard and configure your Shaarli instance.

Step 3: Configure privacy settings

Shaarli’s default settings are public-facing. For a private bookmark manager:

1. Log in and go to the Tools menu
2. Set “Default visibility” to Private
3. Disable the “Allow anonymous access” option in the configuration
4. Enable the API in Settings > Manage plugins > REST API

Step 4: Import existing bookmarks

Use the Tools > Import menu to upload your browser’s Netscape HTML bookmarks export. Shaarli maps browser folders to tags automatically.

Step 5: Set up the browser extension

Install the community-maintained Shaarli extension for your browser. Configure it with your Shaarli URL and API credentials. The extension adds a one-click save button to your toolbar.

Installing Wallabag with Docker

Wallabag is the most feature-rich option but also the most complex to set up. It requires a database and additional services for article extraction.

Step 1: Create the Docker Compose file

 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

version: "3.8"

services:
  wallabag:
    image: wallabag/wallabag:latest
    container_name: wallabag
    restart: unless-stopped
    ports:
      - "8081:80"
    environment:
      - SYMFONY__ENV__DOMAIN_NAME=http://your-server-ip:8081
      - SYMFONY__ENV__SERVER_NAME=Wallabag
      - SYMFONY__ENV__DATABASE_DRIVER=pdo_sqlite
      - SYMFONY__ENV__MAILER_DSN=smtp://localhost
      - SYMFONY__ENV__FROM_EMAIL=wallabag@example.com
      - SYMFONY__ENV__SECRET=change-this-to-a-random-32-char-string
    volumes:
      - ./wallabag-data:/var/www/wallabag/data
      - ./wallabag-images:/var/www/wallabag/web/assets/images
      - ./wallabag-assets:/var/www/wallabag/web/assets

  redis:
    image: redis:alpine
    container_name: wallabag-redis
    restart: unless-stopped

For production, replace SQLite with PostgreSQL:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

services:
  wallabag:
    environment:
      - SYMFONY__ENV__DATABASE_DRIVER=pdo_pgsql
      - SYMFONY__ENV__DATABASE_HOST=postgres
      - SYMFONY__ENV__DATABASE_PORT=5432
      - SYMFONY__ENV__DATABASE_NAME=wallabag
      - SYMFONY__ENV__DATABASE_USER=wallabag
      - SYMFONY__ENV__DATABASE_PASSWORD=strong-db-password
    depends_on:
      - postgres

  postgres:
    image: postgres:16-alpine
    container_name: wallabag-postgres
    restart: unless-stopped
    environment:
      - POSTGRES_USER=wallabag
      - POSTGRES_PASSWORD=strong-db-password
      - POSTGRES_DB=wallabag
    volumes:
      - ./postgres-data:/var/lib/postgresql/data

Step 2: Start the service

1
2

mkdir -p ~/wallabag/wallabag-data ~/wallabag/wallabag-images ~/wallabag/wallabag-assets
docker compose up -d

Visit http://your-server-ip:8081 and log in with the default credentials (wallabag / wallabag). Change the password immediately.

Step 3: Configure article extraction

Wallabag uses the php-readability library by default. For better extraction quality, enable the f43.me API or configure Graby:

1
2
3
4
5

wallabag:
  environment:
    - SYMFONY__ENV__FRACTION_FETCHER_ENABLED=true
    - SYMFONY__ENV__DOWNLOAD_PICTURES_ENABLED=true
    - SYMFONY__ENV__DOWNLOAD_IMAGES_ENABLED=true

Step 4: Install mobile apps

Wallabag has official apps for Android and iOS. Install the app, point it to your Wallabag instance, and authenticate with API credentials (generated in Settings > API clients).

Step 5: Import from Pocket or Instapaper

Wallabag has built-in importers for Pocket, Instapaper, Pinboard, Delicious, and browser bookmarks. Go to Settings > Import, select your source, and upload the exported file. Wallabag will re-fetch all article content for saved items.

Which One Should You Choose?

The right choice depends on what you value most:

Choose Linkding if:

• You want the best balance of features and simplicity
• You need full-text search across bookmark content
• You prefer a Python-based stack with a clean REST API
• You want a modern, responsive UI out of the box
• You run a home server with moderate resources

Linkding is the best all-around bookmark manager for most users. It is fast, well-documented, actively maintained, and has the best browser extension support.

Choose Shaarli if:

• You have minimal server resources (Raspberry Pi, 512 MB VPS)
• You want zero database dependencies
• You value simplicity and portability above all
• You need a quick-and-dirty shared link collection for a team
• You want something that runs on any PHP host

Shaarli is the lightest option. It will run on virtually anything with PHP and a web server. The trade-off is fewer features — no full-text search, no content archiving, no mobile apps.

Choose Wallabag if:

• You primarily want a “read it later” service, not just bookmarks
• You need offline article access with clean formatting
• You want mobile apps for reading on the go
• You need powerful annotation and highlighting features
• You are migrating from Pocket, Instapaper, or similar services

Wallabag is the most powerful option but also the heaviest. It is ideal if your primary use case is saving and reading articles, not just collecting links.

Running All Three Behind a Reverse Proxy

If you want to run multiple bookmark services,caddythem behind a reverse proxy. Here is a sample Caddy configuration:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

bookmarks.example.com {
    reverse_proxy linkding:9090
}

links.example.com {
    reverse_proxy shaarli:80
}

read.example.com {
    reverse_proxy wallabag:80
}

Each service gets its own subdomain with automatic HTTPS. Add this to your docker-compose.yml:

1
2
3
4
5

networks:
  bookmarks:
    external: true
  caddy:
    external: true

Then connect each service to the shared network so Caddy can reach them.

Backup Strategies

Regardless of which tool you choose, back up your data regularly.

Linkding backup

1
2
3
4
5

# SQLite backup
cp ~/linkding/data/db.sqlite3 ~/backups/linkding-$(date +%F).sqlite3

# PostgreSQL backup
docker exec linkding-db pg_dump -U linkding linkding > ~/backups/linkding-$(date +%F).sql

Shaarli backup

1
2

# Shaarli stores everything in flat files — just copy the data directory
tar czf ~/backups/shaarli-$(date +%F).tar.gz ~/shaarli/shaarli-data

Wallabag backup

1
2
3
4
5
6
7
8

# SQLite backup
cp ~/wallabag/wallabag-data/db.sqlite3 ~/backups/wallabag-$(date +%F).sqlite3

# PostgreSQL backup
docker exec wallabag-postgres pg_dump -U wallabag wallabag > ~/backups/wallabag-$(date +%F).sql

# Don't forget article images
tar czf ~/backups/wallabag-images-$(date +%F).tar.gz ~/wallabag/wallabag-images

Automated backup with cron

1
2

# Add to crontab: runs daily at 2 AM
0 2 * * * /path/to/backup-script.sh

A simple backup script:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

#!/bin/bash
BACKUP_DIR="/backups/bookmarks"
DATE=$(date +%F)
mkdir -p "$BACKUP_DIR"

# Linkding
docker exec linkding python manage.py dumpdata > "$BACKUP_DIR/linkding-$DATE.json"

# Shaarli
tar czf "$BACKUP_DIR/shaarli-$DATE.tar.gz" ~/shaarli/shaarli-data

# Wallabag
docker exec wallabag-postgres pg_dump -U wallabag wallabag | gzip > "$BACKUP_DIR/wallabag-$DATE.sql.gz"

# Keep only last 30 days
find "$BACKUP_DIR" -name "*.json" -mtime +30 -delete
find "$BACKUP_DIR" -name "*.tar.gz" -mtime +30 -delete
find "$BACKUP_DIR" -name "*.sql.gz" -mtime +30 -delete

echo "Backup completed: $DATE"

Performance Benchmarks

Testing on a 2-core, 4 GB VPS with 5,000 bookmarks imported:

Wallabag uses the most resources because it stores full article content and downloaded images. If disk space is a concern, configure Wallabag to not download images:

1
2
3

wallabag:
  environment:
    - SYMFONY__ENV__DOWNLOAD_IMAGES_ENABLED=false

Migration Paths

Moving between tools is straightforward thanks to the standard Netscape HTML bookmark export format that all three support.

From browser to any tool

1. Export bookmarks from your browser (Chrome: Bookmarks > Bookmark Manager > Export; Firefox: Library > Import and Backup > Export Bookmarks to HTML)
2. Import the HTML file into your chosen tool via its import page

From Pocket to Wallabag

1. Go to Pocket Settings > Export
2. Download the HTML file
3. In Wallabag, go to Settings > Import > Pocket
4. Upload the file — Wallabag will re-fetch article content

From any tool to another

All three tools support exporting bookmarks in Netscape HTML format:

1
2
3

# Linkding: Settings > Export > Bookmarks (HTML)
# Shaarli: Tools > Export > Netscape HTML
# Wallabag: Settings > Export > Bookmarks (HTML)

Use the exported file to import into any other bookmark manager.

Final Verdict

For most users, Linkding is the sweet spot. It is fast, lightweight, has excellent browser extensions, supports full-text search, and is trivially easy to deploy with Docker. If you just need a better way to save and find links, start here.

If your primary workflow is reading long-form articles and you want offline access, mobile apps, and annotation tools, Wallabag is unmatched. It replaces Pocket entirely and gives you a private reading library.

If you are running on minimal hardware or want the simplest possible setup with zero dependencies, Shaarli delivers. It is not the most feature-rich, but it is reliable, portable, and will run on a $5 VPS or a Raspberry Pi Zero without breaking a sweat.

All three are open source, respect your privacy, and give you full ownership of your data. The best choice is the one that fits your server resources and reading habits.

Frequently Asked Questions (FAQ)

Which one should I choose in 2026?

The best choice depends on your specific requirements:

• For beginners: Start with the simplest option that covers your core use case
• For production: Choose the solution with the most active community and documentation
• For teams: Look for collaboration features and user management
• For privacy: Prefer fully open-source, self-hosted options with no telemetry

Refer to the comparison table above for detailed feature breakdowns.

Can I migrate between these tools?

Most tools support data import/export. Always:

1. Backup your current data
2. Test the migration on a staging environment
3. Check official migration guides in the documentation

Are there free versions available?

All tools in this guide offer free, open-source editions. Some also provide paid plans with additional features, priority support, or managed hosting.

How do I get started?

1. Review the comparison table to identify your requirements
2. Visit the official documentation (links provided above)
3. Start with a Docker Compose setup for easy testing
4. Join the community forums for troubleshooting