Skip to content
Klutch.sh Docs

Deploying linkding

Introduction

linkding is a self-hosted bookmark manager that provides a simple, clean interface for saving and organizing your web bookmarks. Built with Django and designed for minimalism, linkding focuses on essential features without unnecessary complexity.

Unlike cloud-based bookmark services, linkding gives you complete control over your data while providing modern features like full-text search, tagging, and automatic website archiving. The browser extension makes saving bookmarks effortless.

Key highlights of linkding:

  • Clean Interface: Minimalist design focused on usability
  • Full-Text Search: Search across bookmark titles, descriptions, and tags
  • Tagging System: Organize bookmarks with flexible tags
  • Bulk Editing: Manage multiple bookmarks at once
  • Browser Extensions: Extensions for Firefox, Chrome, and Edge
  • Import/Export: Standard bookmark format support (HTML, Netscape)
  • Read-It-Later: Mark bookmarks as unread for later reading
  • Website Archiving: Automatic snapshots via Internet Archive integration
  • REST API: Full API for custom integrations
  • Multi-User Support: Share an instance with family or team
  • 100% Open Source: MIT licensed with active development

This guide walks through deploying linkding on Klutch.sh using Docker, configuring your bookmark manager, and integrating browser extensions.

Why Deploy linkding on Klutch.sh

Deploying linkding on Klutch.sh provides several advantages:

Always-On Access: Your bookmarks are available 24/7 from any device.

Simplified Deployment: Klutch.sh builds and deploys without complex Django setup.

Persistent Storage: Bookmarks and configurations survive restarts.

HTTPS by Default: Secure access with automatic SSL certificates.

GitHub Integration: Track configuration changes in version control.

Custom Domains: Access your bookmarks from your own domain.

Data Ownership: Full control over your bookmark data.

Prerequisites

Before deploying linkding on Klutch.sh, ensure you have:

Understanding linkding Architecture

linkding is a straightforward Django application:

Django Backend: Handles bookmarks, users, and the REST API.

SQLite Database: Default storage for bookmarks and settings.

Static Assets: CSS, JavaScript, and images served by Django.

Background Tasks: Optional archive fetching and cleanup tasks.

Preparing Your Repository

Create a GitHub repository for your linkding deployment.

Repository Structure

linkding-deploy/
├── Dockerfile
├── README.md
└── .dockerignore

Creating the Dockerfile

Create a Dockerfile in the root of your repository:

FROM sissbruecker/linkding:latest


# Set environment variables
ENV LD_SUPERUSER_NAME=${LD_SUPERUSER_NAME}
ENV LD_SUPERUSER_PASSWORD=${LD_SUPERUSER_PASSWORD}


# Disable new user registration (optional)
ENV LD_DISABLE_URL_VALIDATION=${LD_DISABLE_URL_VALIDATION:-False}
ENV LD_DISABLE_BACKGROUND_TASKS=${LD_DISABLE_BACKGROUND_TASKS:-False}


# Expose the web interface
EXPOSE 9090


# Health check
HEALTHCHECK --interval=30s --timeout=10s --start-period=30s --retries=3 \
  CMD curl -f http://localhost:9090/health || exit 1

Advanced Dockerfile with PostgreSQL

For production deployments with PostgreSQL:

FROM sissbruecker/linkding:latest


# Admin user configuration
ENV LD_SUPERUSER_NAME=${LD_SUPERUSER_NAME}
ENV LD_SUPERUSER_PASSWORD=${LD_SUPERUSER_PASSWORD}


# Database configuration (PostgreSQL)
ENV LD_DB_ENGINE=postgres
ENV LD_DB_DATABASE=${LD_DB_DATABASE}
ENV LD_DB_USER=${LD_DB_USER}
ENV LD_DB_PASSWORD=${LD_DB_PASSWORD}
ENV LD_DB_HOST=${LD_DB_HOST}
ENV LD_DB_PORT=${LD_DB_PORT:-5432}


# Security settings
ENV LD_DISABLE_URL_VALIDATION=False
ENV LD_REQUEST_TIMEOUT=${LD_REQUEST_TIMEOUT:-60}


# Context path (if behind a reverse proxy with path)
ENV LD_CONTEXT_PATH=${LD_CONTEXT_PATH}


# Expose port
EXPOSE 9090


# Health check
HEALTHCHECK --interval=30s --timeout=10s --start-period=30s --retries=3 \
  CMD curl -f http://localhost:9090/health || exit 1

Environment Variables Reference

VariableRequiredDefaultDescription
LD_SUPERUSER_NAMEYes-Admin username
LD_SUPERUSER_PASSWORDYes-Admin password
LD_DB_ENGINENosqliteDatabase engine (sqlite, postgres)
LD_DB_DATABASENo-PostgreSQL database name
LD_DB_USERNo-PostgreSQL username
LD_DB_PASSWORDNo-PostgreSQL password
LD_DB_HOSTNo-PostgreSQL host
LD_DISABLE_URL_VALIDATIONNoFalseDisable URL validation
LD_DISABLE_BACKGROUND_TASKSNoFalseDisable background archiving
LD_REQUEST_TIMEOUTNo60Request timeout in seconds
LD_CONTEXT_PATHNo-Context path for reverse proxy

Deploying linkding on Klutch.sh

    Push Your Repository to GitHub

    Initialize and push your repository:

    Terminal window
    git init
    git add Dockerfile .dockerignore README.md
    git commit -m "Initial linkding deployment configuration"
    git remote add origin https://github.com/yourusername/linkding-deploy.git
    git push -u origin main

    Create a New Project on Klutch.sh

    Navigate to the Klutch.sh dashboard and create a new project named “linkding” or “bookmarks”.

    Create a New App

    Within your project, create a new app. Connect your GitHub account and select the repository containing your Dockerfile.

    Configure HTTP Traffic

    In the deployment settings:

    • Select HTTP as the traffic type
    • Set the internal port to 9090

    Set Environment Variables

    Add the following environment variables:

    VariableValue
    LD_SUPERUSER_NAMEYour admin username
    LD_SUPERUSER_PASSWORDYour secure password

    For PostgreSQL (optional):

    VariableValue
    LD_DB_ENGINEpostgres
    LD_DB_DATABASElinkding
    LD_DB_USERYour database username
    LD_DB_PASSWORDYour database password
    LD_DB_HOSTYour database host

    Attach Persistent Volumes

    Add storage for your data:

    Mount PathRecommended SizePurpose
    /etc/linkding/data1 GBSQLite database and settings

    Deploy Your Application

    Click Deploy to start the build process.

    Access linkding

    Once deployed, access your bookmark manager at https://your-app-name.klutch.sh.

Initial Setup

First Login

Log in with your configured superuser credentials:

  1. Navigate to your linkding instance
  2. Enter your admin username and password
  3. Start adding bookmarks

Installing Browser Extension

Install the official browser extension:

Configure the extension:

  1. Open extension settings
  2. Enter your linkding URL
  3. Generate an API token in linkding settings
  4. Enter the API token in the extension

Importing Existing Bookmarks

Import bookmarks from other services:

  1. Export bookmarks as HTML from your browser
  2. Go to Settings > Import in linkding
  3. Upload the HTML file
  4. Review and confirm the import

Managing Bookmarks

Adding Bookmarks

Add bookmarks through multiple methods:

  • Web Interface: Click “Add bookmark” and enter URL
  • Browser Extension: Click the extension icon on any page
  • Bookmarklet: Drag the bookmarklet to your browser toolbar
  • API: POST to /api/bookmarks/

Tagging System

Organize with tags:

  • Add tags while saving bookmarks
  • Use tag autocomplete for consistency
  • Filter bookmarks by tag
  • Combine multiple tags for precise filtering

Search Features

Find bookmarks quickly:

  • Search across titles, URLs, and descriptions
  • Filter by tags
  • Show archived or unread bookmarks
  • Sort by date added or title

User Management

Creating Additional Users

If sharing with family or team:

  1. Go to Settings > Users
  2. Create new user accounts
  3. Each user has their own bookmark collection

API Access

Generate API tokens for integrations:

  1. Go to Settings > Integrations
  2. Generate a new API token
  3. Use for browser extensions or custom apps

Archiving Features

Internet Archive Integration

linkding can automatically archive bookmarked pages:

  1. Enable background tasks
  2. Bookmarks are submitted to Internet Archive
  3. Access cached versions even if original is unavailable

Local Snapshots

For plus version, save local snapshots:

  • Full HTML snapshots stored locally
  • Independent of external services
  • Searchable within linkding

Backup and Export

Exporting Bookmarks

Export your bookmark collection:

  1. Go to Settings > Export
  2. Choose format (HTML or JSON)
  3. Download the export file

Database Backup

For SQLite deployments:

  1. Copy the data directory
  2. Store securely offsite
  3. Schedule regular backups

Troubleshooting

Login Issues

  • Verify superuser credentials are set correctly
  • Check for environment variable typos
  • Review application logs

Extension Not Connecting

  • Verify the URL is correct and accessible
  • Regenerate the API token
  • Check for HTTPS certificate issues

Slow Performance

  • Consider switching to PostgreSQL
  • Allocate more resources
  • Clean up unused tags

Additional Resources

Conclusion

Deploying linkding on Klutch.sh gives you a clean, self-hosted bookmark manager that keeps your web favorites organized and searchable. With browser extensions for easy saving and full-text search for quick retrieval, linkding provides everything you need for personal bookmark management.

Take control of your bookmarks with linkding on Klutch.sh, where your data stays yours while remaining accessible from anywhere.