Linkding Bookmark Manager Installation

Linkding is a minimalist self-hosted bookmark manager that focuses on speed and simplicity, providing full-text search, automatic page archiving, tagging, and a clean REST API for integration with browser extensions and automation workflows. Running on Docker with minimal resource requirements, Linkding is one of the most lightweight bookmark management options available for self-hosted Linux deployments.

Prerequisites

  • Docker and Docker Compose installed
  • Root or sudo access
  • A domain name for external access (optional but recommended)

Installing Linkding with Docker

# Create Linkding directory
sudo mkdir -p /opt/linkding/data

# Create docker-compose.yml
sudo tee /opt/linkding/docker-compose.yml <<'EOF'
version: '3.8'

services:
  linkding:
    image: sissbruecker/linkding:latest
    restart: unless-stopped
    ports:
      - "9090:9090"
    environment:
      - LD_SUPERUSER_NAME=admin
      - LD_SUPERUSER_PASSWORD=change-me-now     # Change this!
      - LD_DISABLE_BACKGROUND_TASKS=False
      - LD_DISABLE_URL_VALIDATION=False
      - LD_ENABLE_AUTH_PROXY=False
      - LD_REQUEST_TIMEOUT=60
      - LD_DB_ENGINE=sqlite                     # or postgresql
      # For PostgreSQL:
      # - LD_DB_ENGINE=postgresql
      # - LD_DB_DATABASE=linkding
      # - LD_DB_USER=linkding
      # - LD_DB_PASSWORD=db-password
      # - LD_DB_HOST=db
    volumes:
      - /opt/linkding/data:/etc/linkding/data
EOF

cd /opt/linkding
sudo docker compose up -d

# Monitor startup
sudo docker compose logs linkding

Access Linkding at http://your-server:9090. Log in with the admin credentials you set.

With PostgreSQL for production:

sudo tee /opt/linkding/docker-compose.yml <<'EOF'
version: '3.8'

services:
  linkding:
    image: sissbruecker/linkding:latest
    restart: unless-stopped
    ports:
      - "9090:9090"
    environment:
      - LD_SUPERUSER_NAME=admin
      - LD_SUPERUSER_PASSWORD=change-me-now
      - LD_DB_ENGINE=postgresql
      - LD_DB_DATABASE=linkding
      - LD_DB_USER=linkding
      - LD_DB_PASSWORD=db-password
      - LD_DB_HOST=db
    volumes:
      - /opt/linkding/data:/etc/linkding/data
    depends_on:
      - db

  db:
    image: postgres:16-alpine
    restart: unless-stopped
    environment:
      POSTGRES_DB: linkding
      POSTGRES_USER: linkding
      POSTGRES_PASSWORD: db-password
    volumes:
      - /opt/linkding/postgres:/var/lib/postgresql/data
EOF

sudo docker compose up -d

Initial Setup

Configure Nginx reverse proxy with HTTPS:

# /etc/nginx/sites-available/linkding
server {
    listen 80;
    server_name bookmarks.example.com;
    return 301 https://$host$request_uri;
}

server {
    listen 443 ssl;
    server_name bookmarks.example.com;

    ssl_certificate /etc/letsencrypt/live/bookmarks.example.com/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/bookmarks.example.com/privkey.pem;

    location / {
        proxy_pass http://127.0.0.1:9090;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
    }
}

sudo ln -s /etc/nginx/sites-available/linkding /etc/nginx/sites-enabled/
sudo certbot --nginx -d bookmarks.example.com
sudo systemctl reload nginx

Create additional users via CLI:

# Create a regular user
sudo docker compose exec linkding \
  python manage.py createsuperuser

# Or create a standard (non-admin) user via the admin panel
# http://bookmarks.example.com/admin/ → Users → Add User

Browser Extension Setup

Linkding provides official browser extensions for one-click bookmarking:

Firefox: Linkding Extension on Mozilla Add-ons

Chrome/Chromium: Available on the Chrome Web Store

Configure the extension:

  1. Click the extension icon → Settings
  2. Set Server URL: https://bookmarks.example.com
  3. Generate an API token:
    • In Linkding → Settings > Integrations
    • Click Generate API Token
  4. Paste the token in the extension settings
  5. Click Test connection — should show "Connected"

Use the extension:

  • Click the extension icon to save the current page
  • Edit title, description, and tags before saving
  • Press Enter to save quickly

Tagging and Organization

Add bookmarks with tags:

  1. Click + Add bookmark or use the browser extension
  2. Enter URL, title, and description
  3. In the Tags field, type tag names (auto-complete suggests existing tags)
  4. Press Enter to add each tag

Managing tags:

  1. Go to Bookmarks > Tags (sidebar)
  2. All your tags are listed with bookmark counts
  3. Click a tag to filter bookmarks

Bulk tagging:

  1. Select multiple bookmarks using the checkboxes
  2. Click Action > Add tags from the bulk action menu
  3. Apply a tag to all selected bookmarks at once

Import bookmarks with tags:

# Import from Netscape/HTML bookmark format (standard for all browsers)
# Bookmarks > Import/Export > Import

# Or via CLI
sudo docker compose exec linkding \
  python manage.py import_bookmarks \
  --user admin \
  /tmp/bookmarks.html

Full-Text Search

Linkding indexes bookmark titles, descriptions, tags, and page content for full-text search:

Search syntax:

# Basic search - matches anywhere
docker

# Tag search
#linux

# Multiple terms (AND)
docker kubernetes

# Exact phrase
"container orchestration"

# URL search
url:github.com

# Combined
#devops docker

Search from browser address bar:

Configure a search engine shortcut in your browser:

Name:     Linkding
URL:      https://bookmarks.example.com/?q=%s
Keyword:  ld

Then type ld docker kubernetes in the address bar to search directly.

Automatic Archiving

Linkding can archive web pages locally so they remain accessible even if the original URL goes offline:

Enable archiving via environment variable:

# In docker-compose.yml environment:
- LD_ENABLE_SITE_FAVICONS=True
- LD_FAVICON_PROVIDER=https://www.google.com/s2/favicons?domain={domain}

# For local archiving (requires singlefile):
# Install singlefile in the container and configure

Configure SingleFile for full page archiving:

# Install Node.js and SingleFile CLI in the container
sudo docker compose exec linkding \
  npm install -g single-file-cli

# Enable in Linkding settings
# Settings > General > Enable page archiving

Manual archive a specific bookmark:

  1. Click the bookmark's edit icon
  2. Under Web archive, click Archive this page
  3. The archived version is stored in /opt/linkding/data/assets/

REST API Usage

Linkding's REST API enables automation and integration:

Generate an API token:

# In Linkding web UI:
# Settings > Integrations > REST API > Generate API Token

Common API operations:

TOKEN="your-api-token"
BASE="https://bookmarks.example.com/api"

# List bookmarks
curl -s -H "Authorization: Token $TOKEN" "${BASE}/bookmarks/" | jq '.results[].url'

# Create a bookmark
curl -s -X POST "${BASE}/bookmarks/" \
  -H "Authorization: Token $TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "url": "https://example.com/article",
    "title": "Great Article",
    "description": "A useful resource",
    "tag_names": ["reading", "tech"],
    "is_archived": false
  }'

# Search bookmarks
curl -s -H "Authorization: Token $TOKEN" \
  "${BASE}/bookmarks/?q=docker&tag=devops" | \
  jq '.results[] | {title: .title, url: .url}'

# Delete a bookmark
curl -X DELETE -H "Authorization: Token $TOKEN" \
  "${BASE}/bookmarks/42/"

Export bookmarks via API:

# Get all bookmarks as JSON
curl -s -H "Authorization: Token $TOKEN" \
  "${BASE}/bookmarks/?limit=1000" > bookmarks-backup.json

# Or use the built-in export (HTML format):
curl -s -H "Authorization: Token $TOKEN" \
  "${BASE}/bookmarks/export/" > bookmarks.html

Troubleshooting

Browser extension not saving (authentication error):

# Verify the API token is valid
curl -s -H "Authorization: Token your-token" \
  "https://bookmarks.example.com/api/bookmarks/" | jq '.count'

# Regenerate the token in Settings > Integrations

# Check if HTTPS is properly configured (extensions require HTTPS)
curl -I https://bookmarks.example.com

Search not returning expected results:

# Rebuild the full-text search index
sudo docker compose exec linkding \
  python manage.py update_index

# Check search index status
sudo docker compose exec linkding \
  python manage.py search_status

High disk usage from archived pages:

# Check archive size
sudo du -sh /opt/linkding/data/assets/

# Clean up orphaned archive files
sudo docker compose exec linkding \
  python manage.py clean_assets

# Disable archiving to stop growth
# Settings > General > uncheck "Enable page archiving"

Conclusion

Linkding delivers a focused, lightweight bookmarking experience with the essential features — tagging, full-text search, archiving, and a clean API — without the complexity of heavier alternatives. Its minimal resource footprint makes it ideal for running alongside other services on a VPS, while the browser extension and REST API ensure seamless integration into daily workflows and automation pipelines for building a personal knowledge base over time.