Hoarder vs Linkwarden: Bookmark Managers Compared

Quick Verdict

Want to save links and have AI organize them automatically? Hoarder (recently rebranded to Karakeep) handles that — you bookmark a page and its AI tagging engine categorizes it without manual effort. Linkwarden is the better choice for teams or anyone who needs organized collections with full-page screenshots, PDF archival, and shared workspaces. Both are excellent; the deciding factor is whether you value AI-assisted organization or structured collaboration.

Updated March 2026: Verified with latest Docker images and configurations.

Feature	Hoarder (Karakeep)	Linkwarden
Primary strength	AI auto-tagging and search	Collections, archival, collaboration
AI tagging	Built-in (OpenAI, Ollama, local models)	No
Full-page screenshots	No	Yes (automatic)
PDF archival	No	Yes (saves page as PDF)
Browser extension	Chrome, Firefox	Chrome, Firefox, Safari
Mobile app	iOS, Android (native)	Progressive Web App
Collaboration	No (single-user)	Yes (shared collections, permissions)
Import from	Browser bookmarks, Omnivore	Browser bookmarks, Raindrop, Pocket, Omnivore
Full-text search	Yes (content indexed via AI)	Yes (archived page content)
RSS feeds	No	Per-collection RSS output
API	REST API	REST API
OCR	Yes (images and screenshots)	No
Tags	AI-generated + manual	Manual only
Storage backend	SQLite or PostgreSQL	PostgreSQL (required)
Docker image	karakeep/karakeep:0.31.0	ghcr.io/linkwarden/linkwarden:v2.13.5
License	AGPL v3	AGPL v3

Architecture Differences

Hoarder runs as a monolithic application with an optional AI worker. The core stack is a Next.js app with Meilisearch for full-text search and either SQLite (simpler) or PostgreSQL. If you enable AI features, it connects to OpenAI’s API or a local Ollama instance to generate tags and summaries.

Linkwarden requires PostgreSQL and runs a Next.js application server alongside a background worker that captures screenshots and generates PDF archives of saved links. The archival pipeline is the core differentiator — every bookmarked page gets a full screenshot and optional PDF copy, protecting you against link rot.

Docker Deployment

Hoarder (Karakeep)

services:
  karakeep:
    image: karakeep/karakeep:0.31.0
    ports:
      - "3000:3000"
    environment:
      DATABASE_URL: "postgresql://karakeep:changeme_db_password@db:5432/karakeep"
      MEILI_ADDR: "http://meilisearch:7700"
      MEILI_MASTER_KEY: changeme_meili_key_32chars_min
      NEXTAUTH_SECRET: changeme_random_secret_32chars
      NEXTAUTH_URL: "http://localhost:3000"
      # AI tagging (optional — remove if not using AI)
      OPENAI_API_KEY: "your-openai-key"
      # Or for local AI via Ollama:
      # OLLAMA_BASE_URL: "http://ollama:11434"
      # INFERENCE_TEXT_MODEL: "llama3.2"
    volumes:
      - karakeep_data:/data
    restart: unless-stopped
    depends_on:
      db:
        condition: service_healthy
      meilisearch:
        condition: service_started

  db:
    image: postgres:17-alpine
    environment:
      POSTGRES_USER: karakeep
      POSTGRES_PASSWORD: changeme_db_password
      POSTGRES_DB: karakeep
    volumes:
      - postgres_data:/var/lib/postgresql/data
    restart: unless-stopped
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U karakeep"]
      interval: 10s
      timeout: 5s
      retries: 5

  meilisearch:
    image: getmeili/meilisearch:v1.13
    environment:
      MEILI_MASTER_KEY: changeme_meili_key_32chars_min
      MEILI_NO_ANALYTICS: "true"
    volumes:
      - meili_data:/meili_data
    restart: unless-stopped

volumes:
  karakeep_data:
  postgres_data:
  meili_data:

Three services: the app, PostgreSQL, and Meilisearch. AI tagging is optional — without an OpenAI key or Ollama instance, Hoarder works as a standard bookmark manager with manual tags.

Linkwarden

services:
  linkwarden:
    image: ghcr.io/linkwarden/linkwarden:v2.13.5
    ports:
      - "3000:3000"
    environment:
      DATABASE_URL: "postgresql://linkwarden:changeme_db_password@db:5432/linkwarden"
      NEXTAUTH_SECRET: changeme_random_secret_32chars
      NEXTAUTH_URL: "http://localhost:3000"
      NEXT_PUBLIC_DISABLE_REGISTRATION: "false"
      STORAGE_FOLDER: "/data/archives"
      AUTOSCROLL_TIMEOUT: "30"
    volumes:
      - linkwarden_data:/data
    restart: unless-stopped
    depends_on:
      db:
        condition: service_healthy

  db:
    image: postgres:17-alpine
    environment:
      POSTGRES_USER: linkwarden
      POSTGRES_PASSWORD: changeme_db_password
      POSTGRES_DB: linkwarden
    volumes:
      - postgres_data:/var/lib/postgresql/data
    restart: unless-stopped
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U linkwarden"]
      interval: 10s
      timeout: 5s
      retries: 5

volumes:
  linkwarden_data:
  postgres_data:

Two services: the app and PostgreSQL. Linkwarden uses Playwright internally for screenshot capture — it’s bundled in the Docker image, so no additional container is needed.

Resource Usage

Resource	Hoarder (with Meilisearch)	Linkwarden
RAM (idle)	400-600 MB	250-400 MB
RAM (during archival)	500-800 MB	400-700 MB (Playwright)
CPU (idle)	Low	Low
CPU (during AI tagging)	Moderate-High	N/A
Disk per 1,000 bookmarks	~200 MB (search index)	~2-5 GB (screenshots + PDFs)

Linkwarden’s archival (screenshots + PDFs) consumes significantly more disk than Hoarder’s text-based index. If you bookmark thousands of pages, plan for 5-10 GB of storage for Linkwarden’s archives versus under 1 GB for Hoarder.

Hoarder’s resource usage spikes during AI tagging. If using a local Ollama model, add the model’s RAM requirement (2-8 GB depending on model size) to the baseline.

Organization and Discovery

Hoarder’s AI tagging is its signature feature. Bookmark a page and within seconds it generates relevant tags — “docker,” “monitoring,” “open-source” — without any manual input. Over time, your bookmark library self-organizes. You can search by AI-generated tags, full-text content, or natural language queries (“that article about Kubernetes networking”).

Linkwarden uses a traditional collections model. You create collections (folders), optionally share them with other users, and organize bookmarks manually. Tags exist but are user-created. The strength is structure — shared collections with read/write permissions make Linkwarden useful for teams curating research or reference material.

Collaboration

Hoarder is designed for individual use. There’s no multi-user mode, no shared collections, and no permission system. Each instance serves one user.

Linkwarden supports multiple users with shared collections. You can create a team workspace where members contribute bookmarks to shared collections with configurable permissions (view, add, edit, delete). This makes it suitable for research teams, study groups, or families sharing a bookmark library.

Mobile Experience

Hoarder offers native iOS and Android apps — not just a responsive web page, but actual native applications in the app stores. The mobile experience is polished, with quick-share integration for saving links from any mobile browser or app.

Linkwarden provides a Progressive Web App (PWA) that works on mobile browsers. It’s functional but not as smooth as a native app. The share-sheet integration depends on browser PWA support, which varies by platform.

Use Cases

Choose Hoarder (Karakeep) If…

• You save lots of links and hate manual tagging
• AI-powered organization and search appeals to you
• You want native mobile apps for quick bookmarking
• You’re a solo user who doesn’t need collaboration
• OCR of images and screenshots is useful for your workflow
• You prefer SQLite simplicity over PostgreSQL for smaller deployments

Choose Linkwarden If…

• You need full-page screenshots and PDF archives of saved pages
• Multiple users need shared bookmark collections
• Link rot protection is important (archived copies survive dead links)
• You want per-collection RSS feeds for sharing curated lists
• Team collaboration with permissions matters
• You’re migrating from Raindrop.io or Pocket and want import support

Final Verdict

For solo users who bookmark heavily, Hoarder’s AI tagging transforms a chaotic pile of links into a searchable, organized library with zero manual effort. The native mobile apps and OCR support make it the more capable personal tool.

For teams or anyone who treats bookmarks as a research archive, Linkwarden wins on collaboration and preservation. Shared collections, full-page screenshots, and PDF archival make it a proper knowledge management tool rather than just a bookmark list. If the link you saved today might be a dead URL next year, Linkwarden’s archival pipeline is the reason to choose it.

FAQ

Why was Hoarder renamed to Karakeep?

The project rebranded from Hoarder to Karakeep in early 2026 to resolve trademark concerns. The software is identical — only the name and Docker image changed. Existing Hoarder installations can migrate by updating the image name.

Can I use Hoarder’s AI features with local models only?

Yes. Hoarder supports Ollama for fully local AI inference. Point OLLAMA_BASE_URL to your Ollama instance and set INFERENCE_TEXT_MODEL to a supported model (llama3.2, mistral, etc.). No data leaves your network.

Does Linkwarden capture JavaScript-rendered pages?

Yes. Linkwarden uses Playwright (headless Chromium) for screenshots, so it renders JavaScript-heavy pages, SPAs, and dynamically loaded content before capturing.

Can I self-host both and sync between them?

Not natively. Both have REST APIs, so a custom integration is possible, but no built-in sync exists. Most users choose one based on whether they value AI tagging or archival more.

Related

• How to Self-Host Hoarder
• How to Self-Host Linkwarden
• How to Self-Host Linkding
• Linkwarden vs Linkding: Bookmark Managers Compared
• Linkding vs Wallabag: Read-Later Tools Compared
• Wallabag vs Hoarder: Bookmark Managers Compared
• How to Self-Host Wallabag
• Best Self-Hosted Bookmark Managers