# Kavita: Self-Hosted Reading Server for Manga, Comics, and ebooks

> Kavita is a C#/GPL-3.0 reading server that serves manga, webtoons, comics, epub, and PDF from a self-hosted instance, with responsive web readers, role-based user management, and an optional paid Kavita+ tier for metadata and scrobbling. The project is in active development and self-describes as beta software until the 1.0.0 release.

**Kareadita/Kavita** — Kavita is a fast, feature rich, cross platform reading server. Built with the goal of being a full solution for all your reading needs. Setup your own server and share your reading collection with your friends and family.

- Repository: https://github.com/Kareadita/Kavita
- Website: http://www.kavitareader.com
- Stars: 11,743 · Forks: 671
- Language: C#
- License: GPL-3.0
- Published: 2026-08-04 · Updated: 2026-08-18 · Language: en
- Canonical page: https://hysenlabs.com/projects/kareadita-kavita

## What Kavita Serves and Who It Is For

Kavita targets the person who has accumulated a collection of manga volumes, webtoon series, comics, or ebooks and wants a server-side application that organises, serves, and tracks reading progress for all of them from one interface. The reading happens in a browser, and the server runs on whatever machine hosts the files, from a home server to a Synology NAS to a cloud VM.

The project is written in C#, licensed under GPL-3.0, and the repository's develop branch received its last push on 24 September 2026. Version 0.9.1.4 was released on 2 September 2026. The README includes a public demo at demo.kavitareader.com with the following credentials:

```
Username: demouser
Password: Demouser64
```

The demo is the fastest way to evaluate the interface before installing. Kavita's homepage is kavitareader.com and the installation wiki is at wiki.kavitareader.com/getting-started.

## Supported File Formats: CBR, CBZ, EPUB, PDF, and More

Kavita's format coverage spans two categories: comics and manga on one side, and prose books on the other.

For comics and manga, the README lists CBR, CBZ, ZIP, RAR (including RAR5), 7zip archives, and raw image directories. These are the standard archive formats used by the comic book reader community for scanned and digital comic content.

For books, the server supports EPUB and PDF. The README notes epub-based annotation and highlight support, which is a meaningful distinction from basic PDF-only readers: the server maintains annotations at the book level rather than just tracking what page was last read.

Webtoons, which are long-form vertically-scrolling comics common in Korean digital publishing, are listed explicitly as a supported content type with a dedicated reading mode in the web readers.

The combination of manga archive formats and epub/PDF under one server is Kavita's core value over dedicated comic servers or dedicated ebook servers, which typically handle one category but not both.

## Installing Kavita via Docker

The README directs users to the wiki at wiki.kavitareader.com/getting-started for up-to-date installation instructions across platforms including Windows, Linux, macOS, and Synology. The repository includes a Dockerfile that shows the container structure.

The production image is built on Ubuntu Noble and installs these runtime dependencies:

```dockerfile
apt-get install -y libicu-dev libgdiplus curl tzdata libjemalloc2
```

The container exposes port 5000:

```dockerfile
EXPOSE 5000
```

The image includes a health check that queries the API endpoint:

```dockerfile
HEALTHCHECK --interval=30s --timeout=15s --start-period=30s --retries=3 CMD curl -fsS http://localhost:5000/api/health || exit 1
```

The DockerHub image is published as `jvmilazz0/kavita`. Users who do not own a server can use Zenith (zenith.hosting) or PikaPods, both of which the README names as managed hosting providers that contribute back to the project via OpenCollective.

The working directory inside the container is `/kavita`, and the app settings file is copied from `Kavita.Server/config/appsettings.json` to `/tmp/config/appsettings.json` during the build, so custom configuration requires mounting that path.

## Web Readers and Reading Modes

Kavita provides multiple reading modes through its browser-based readers. The README describes support for webtoon mode (vertical scrolling for long-form comics), continuous reading mode (which lets the reader continue into the next chapter without returning to the library view), and virtual pages for epub content.

The readers are described as responsive, working on phones, tablets, and desktops. The webtoon mode is specific to vertically-structured content, while the standard reader handles paginated manga and comic volumes.

Epub reading includes annotation and highlight support, which persists on the server and is associated with the user account rather than the browser. This means annotations are accessible from any device that can reach the Kavita instance.

The dashboard and side navigation are customisable: smart filters determine what content appears, and the order and visibility of nav items can be set per user. This customisation is a layer on top of the server's metadata system, which supports filtering and searching by the library's metadata fields.

Integration with Tachiyomi (the Android manga reader) is a documented use case in the related search data, though the README does not describe the API mechanism in the excerpt provided. Kavita exposes an API that compatible clients can connect to.

## User Management, OIDC, and Age Restrictions

Kavita includes a user management layer that goes beyond simple authentication. The README describes role-based management covering age restrictions, capability grants within the app, and OIDC (OpenID Connect) support.

Age restrictions let administrators configure what content categories each user account can access, which is relevant for shared family instances where younger users should not see all content in the library. The roles control which features each user can interact with.

OIDC support means Kavita can delegate authentication to an external identity provider such as Authentik, Keycloak, or any other OIDC-compatible service, which matters for home-lab setups that centralise authentication.

The Kavita+ subscription feature integrates user accounts with the external metadata services: scrobbling playback data (reading progress) to compatible tracking sites is a paid-tier feature that operates per user.

Kavita supports sharing a collection with friends and family, as the README states in its opening description. The combination of role-based access and age restrictions is what makes this multi-user scenario practical rather than just theoretically possible.

## Kavita+ Paid Tier: What It Adds and What It Costs

Kavita+ is an optional subscription that unlocks features the README describes as internet-facing capabilities that would not be feasible to include in the base GPL application. The README lists the additions as metadata download, reviews, ratings, recommendations, scrobbling, and smart collections.

The subscription is run by the primary developer (majora2007). The README mentions a promotional code `FIRSTTIME` for two dollars off the first payment and links to a Stripe checkout page for signup. Contributors already using OpenCollective are directed to contact majora2007 directly for a provisioned licence.

The base Kavita application without Kavita+ is fully functional for serving, reading, and organising a local collection. The metadata and scrobbling features are the core additions the paid tier provides. Teams evaluating Kavita for a shared server should assess whether they need external metadata enrichment or tracking integration before committing to the subscription cost.

## Beta Status, Komga, and Known Limitations

The README includes a notice that explicitly labels Kavita as beta software until version 1.0.0: the platform may change in ways that cause data loss and require a restart. The team says they strive to avoid data loss but do not guarantee it in the current development phase. The highest available version as of the most recent release is 0.9.1.4, indicating 1.0.0 is not yet reached.

Komga is the most direct alternative. It is a JVM-based self-hosted comics and manga server that also serves EPUB and PDF, supports CBZ/CBR archives, and provides a REST API and OPDS feed. The practical differences are in implementation language (Kotlin vs. C#), licence (MIT vs. GPL-3.0), and monetisation: Komga has no paid subscription tier, while Kavita offers metadata features only via Kavita+. Both run as server applications with browser-based access.

Kavita has no native mobile app. The related searches for Kavita Android, Kavita iOS, and Kavita APK reflect demand that the README does not fulfil directly. Mobile reading works through the browser, or through third-party clients that implement the relevant API. The lack of a dedicated mobile app is a concrete limitation compared to solutions like Jellyfin, which ships iOS and Android applications.

The smart filters and collections require metadata to be present. Libraries with poorly organised or incomplete metadata will get less from Kavita's filtering and grouping features than libraries where titles, series, and authors are consistently tagged.

## Conclusion

Kavita is the right choice for someone running their own manga or comic archive who wants a full reading interface accessible from a browser on any device, with user accounts and per-user age restrictions. The README explicitly labels it beta software until version 1.0.0, so operators should verify before relying on it for large collections that they can tolerate the occasional data loss scenario the project warns about. Teams who need a stable, production-ready reading server without a paid tier for metadata should check Komga, which covers a similar use case under the MIT licence without a subscription component.

## FAQ

### How do I install Kavita?

The README links to the installation wiki at wiki.kavitareader.com/getting-started for platform-specific instructions covering Docker, Windows, Linux, macOS, and Synology. The Docker image is published as jvmilazz0/kavita and runs on port 5000. Users without a server can use the managed hosting providers Zenith or PikaPods.

### How do I set up Kavita?

After installing, access the server in a browser on port 5000, create an admin account, and point Kavita at the directories holding your manga, comics, or ebook files. The wiki at wiki.kavitareader.com covers the full setup flow including library configuration and user management.

### Is Kavita good for ebooks?

Kavita serves EPUB and PDF files, and the web reader includes annotation and highlight support for epub content, with highlights stored per user account. Whether it suits a given ebook workflow depends on whether the browser reader matches your preferences, since there is no dedicated native mobile app.

### How do I use Kavita with Tachiyomi?

Kavita exposes an API that compatible clients can connect to. The search data shows users connecting Tachiyomi (the Android manga reader) to Kavita instances, but the README does not document the specific API configuration steps in the excerpt available.

### How do I access Kavita remotely?

Kavita runs as a web server on port 5000 and can be accessed from any device with a browser that can reach the host machine. For access outside the local network, you need to expose port 5000 through your router or a reverse proxy. The wiki at wiki.kavitareader.com covers remote access configuration.

## Sources

- [Official documentation](http://www.kavitareader.com)
- [Official README](https://github.com/Kareadita/Kavita#readme)
- [Project repository](https://github.com/Kareadita/Kavita)
- [Release notes](https://github.com/Kareadita/Kavita/releases)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/kareadita-kavita