Self-Host Kavita for Comics, Manga & Ebooks

ComiXology became Amazon Kindle and lost its identity. Mangadex is great but it's not your collection. Calibre-Web is showing its age. Kavita is the modern self-hosted answer for anyone with a comic, manga, or ebook library: clean web reader, mobile-responsive UI, proper right-to-left manga support, EPUB and PDF and CBR and CBZ all handled in one place, with progress sync and multi-user libraries.

This guide installs Kavita via Docker, sets up HTTPS, configures the file naming Kavita uses to detect series and volumes, walks through metadata fetching from ComicVine and Anilist, and covers the multi-user permission system for shared family libraries with age-gating. By the end you'll have a fast, organised library that works in any browser and on any phone.

1. Library size planning

Comic/manga storage math:

Content type	Per file	Per series (50 issues / volumes)	500 series =
Standard comic CBR/CBZ	30–60 MB	~2 GB	~1 TB
Manga volume (200 pages)	50–100 MB	~3 GB	~1.5 TB
Webtoon vertical scroll	30–60 MB	~2 GB	~1 TB
EPUB ebook	500 KB–3 MB	~50 MB	~25 GB
PDF technical books	5–20 MB	~500 MB	~250 GB

Comics and manga are the storage drivers. Ebooks are negligible. For a serious manga collection (200+ series, full volumes), plan for 1 TB+. The 2 TB plan handles roughly 40,000 comic issues or full collections of 500+ long-running manga series.

2. Prepare the VPS

apt update && apt upgrade -y
apt install -y curl ca-certificates gnupg ufw

ufw allow 22/tcp
ufw allow 80/tcp
ufw allow 443/tcp
ufw --force enable

adduser kavita
usermod -aG sudo kavita
rsync --archive --chown=kavita:kavita ~/.ssh /home/kavita

3. Install Docker

install -m 0755 -d /etc/apt/keyrings
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | \
  gpg --dearmor -o /etc/apt/keyrings/docker.gpg

echo "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.gpg] \
  https://download.docker.com/linux/ubuntu $(. /etc/os-release && echo "$VERSION_CODENAME") stable" | \
  tee /etc/apt/sources.list.d/docker.list > /dev/null

apt update
apt install -y docker-ce docker-ce-cli containerd.io docker-compose-plugin
usermod -aG docker kavita

4. Deploy Kavita

su - kavita
mkdir -p ~/kavita/{config,manga,comics,books}
cd ~/kavita

cat > compose.yaml <<'EOF'
services:
  kavita:
    image: jvmilazz0/kavita:latest
    container_name: kavita
    restart: unless-stopped
    ports:
      - "127.0.0.1:5000:5000"
    volumes:
      - ./manga:/manga
      - ./comics:/comics
      - ./books:/books
      - ./config:/kavita/config
    environment:
      TZ: UTC
EOF

docker compose up -d
docker compose logs -f

First boot is fast (~15 seconds). Visit http://localhost:5000 via SSH tunnel to confirm. Once Nginx is up (next step), use the real domain.

5. Nginx reverse proxy + HTTPS

sudo apt install -y nginx certbot python3-certbot-nginx

sudo tee /etc/nginx/sites-available/kavita <<'EOF'
server {
    listen 80;
    server_name comics.example.com;

    client_max_body_size 500M;
    proxy_read_timeout 300s;

    location / {
        proxy_pass http://127.0.0.1:5000;
        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;
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection "upgrade";
    }
}
EOF

sudo ln -s /etc/nginx/sites-available/kavita /etc/nginx/sites-enabled/
sudo nginx -t && sudo systemctl reload nginx
sudo certbot --nginx -d comics.example.com

Visit https://comics.example.com — Kavita's first-run wizard. Create the admin account (first user becomes admin). Pick a strong password — this account has full library access.

6. Create libraries

Kavita supports multiple library types, each with different defaults:

• Manga — assumes right-to-left reading order, volume-based grouping
• Comic — issue-based grouping, left-to-right by default
• Book — EPUB / PDF for traditional ebooks
• Light Novel — text-heavy with light illustration
• Image — image-only folders (good for art collections)

In the admin panel: Libraries → + Add Library. For each library:

• Pick a type (Manga, Comic, Book...)
• Add the source folder path (e.g. /manga)
• Set scan schedule (default: daily)
• Save

Kavita scans the folder, detects series, and adds books to the library. The first scan takes ~1 minute per 100 books.

7. File naming and series detection

Kavita auto-detects series, volumes, and chapters from filenames. The patterns that just work:

# Manga — series with volumes
/manga/
└── One Piece/
    ├── One Piece Vol. 01.cbz
    ├── One Piece Vol. 02.cbz
    └── ...

# Manga — series with chapters
/manga/
└── Chainsaw Man/
    ├── Chainsaw Man Ch. 001.cbz
    ├── Chainsaw Man Ch. 002.cbz
    └── ...

# Comics — issues
/comics/
└── Batman/
    ├── Batman 001 (2016).cbr
    ├── Batman 002 (2016).cbr
    └── ...

# Light novels with volumes
/books/
└── Re_Zero/
    ├── Re_Zero Vol. 1.epub
    ├── Re_Zero Vol. 2.epub
    └── ...

Common pitfalls:

• Inconsistent naming — mixing "Vol. 1" and "v01" confuses the scanner. Pick one convention per series.
• Year in the filename — Kavita uses this to disambiguate reprints. "(2016)" vs "(2022)" creates separate series unless you set "Match by name regardless of year" in library settings.
• Folder for single book — Kavita expects a folder per series even if it has just one volume. Don't drop loose files at the library root.

8. Metadata fetching

Kavita pulls cover art, descriptions, character lists, and tags from:

• ComicVine — best for Western comics
• Anilist — best for manga and anime-adjacent content
• Mangadex — best for manga not in Anilist
• Google Books / OpenLibrary — best for traditional ebooks

Configure under Settings → Metadata. For ComicVine you'll need a free API key from comicvine.gamespot.com. Anilist, Mangadex, and OpenLibrary are key-less.

For a series with bad metadata: open the series page, click Edit, search for the right title, pick the correct match. Kavita overwrites cover and details. Manual override is also available — type whatever description you want.

9. Manga and right-to-left reading

Kavita has a proper manga reader. In a manga library, the default reading direction is right-to-left and double-page spreads work correctly (page 5 on the left, page 4 on the right — Japanese convention).

Per-user override: Profile → Reading Preferences. Options:

• Reading Direction: Left-to-right, Right-to-left, Up-to-down (webtoon)
• Layout: Single page, double page, webtoon (continuous scroll)
• Page Fitting: Fit width, fit height, original size
• Background: Light, dark, AMOLED black

The webtoon mode is particularly well-implemented — endless vertical scroll with progress saved by scroll position. Lezhin / Tappytoon converts can keep their reading experience identical.

10. Multi-user and age-gating

Each user has their own:

• Account credentials
• Reading progress (independent per-user)
• Reading lists and bookmarks
• Library scope (which libraries they can see)
• Age restriction (filters out content above their threshold)

Create users under Users → + Invite User. Email-based invite — they sign up with their own password.

For families with kids: set up Age Restriction on the child's account. Series tagged Mature/Explicit get hidden from them automatically. Tag content via the metadata fetch (Anilist returns age ratings) or manually under each series.

11. Reference: formats, alternatives

Supported file formats

Format	What it is	Best for
CBR	RAR archive of images	Older comic distributions
CBZ	ZIP archive of images	Modern standard, faster to read
CB7	7-Zip archive of images	Smaller files, slower to open
PDF	Standard PDF	Technical books, scanned content
EPUB	Standard ebook format	Novels, light novels, anything text-heavy

Kavita is happy with all of them. For best performance, prefer CBZ over CBR — ZIP is faster to seek than RAR for the random-access page-flipping use case.

Kavita vs Komga vs Calibre-Web

	Kavita	Komga	Calibre-Web
Comics + manga	✅ Excellent	✅ Excellent	⚠️ Limited
Ebooks (EPUB)	✅ Built-in reader	⚠️ Basic	✅ Excellent
Manga RTL reading	✅ Native	✅ Native	❌
Mobile UI	✅ Responsive web	⚠️ Web only	⚠️ Web only
Best for	Mixed libraries	Pure comic/manga	Pure ebook

Kavita is the best balance if you have mixed content (some comics, some manga, some novels). Komga edges Kavita on comic-only setups. Calibre-Web is the right answer if you're ebook-only.

Performance considerations

Kavita scans the library on a schedule and during file changes. Initial scan of 5,000+ items takes 10–20 minutes. Subsequent incremental scans (new files) finish in seconds. Storage IOPS matters more than CPU here — NVMe libraries scan dramatically faster than HDD.

Image-heavy file formats (uncompressed PNG inside CBZ) can be slow to load on the reader. Convert to WebP or JPEG inside the CBZ for faster page turns. Tools like KCC (Kindle Comic Converter) handle this conversion in bulk.

Per-plan capacity

Plan	Library size	Concurrent readers
Starter ($7.99, 100 GB)	~2,000 comic issues or 50 manga series	5+ simultaneous
Pro ($15.99, 500 GB)	~10,000 issues or 250 manga series	20+ simultaneous
Premium ($35.99, 2 TB HDD)	40,000+ issues or 500+ manga series	50+ simultaneous

OPDS support

Kavita exposes an OPDS (Open Publication Distribution System) feed at https://comics.example.com/api/opds/<api-key>/. Third-party reader apps that support OPDS (Chunky, Panels, Moon+ Reader Pro, Yomu) can pull your library and read offline. Useful for iOS where dedicated apps are sparse.

FAQ

Related posts

Tutorial

Self-Host Jellyfin Media Server

Comics and video belong on different servers, but on the same VPS works fine.

Concept

What is NVMe Storage?

Image-heavy libraries benefit hugely from NVMe — when it's worth the extra cost.

Pillar

The Complete Self-Hosting Guide

Where Kavita fits in a broader self-hosted media ecosystem.