Kometa

Plex library automation, honestly reviewed. No fluff — just what happens when you point a YAML-configured Python script at 5,000 movies.

TL;DR

• What it is: Open-source (MIT) Python script that automates metadata, collections, and overlays for Plex media servers — connecting to TMDb, Trakt, IMDb, Sonarr, Radarr, and more [README].
• Who it’s for: Plex power users who want their library to look like a curated streaming service instead of a folder dump. This is explicitly a technical tool — the official docs say “if the idea of editing YAML files by hand is daunting, this may not be the tool for you” [1][4].
• Cost savings: Kometa itself is free (MIT). Plex Pass — which gives you some basic collection features — runs $4.99/month or $119.99 lifetime. Kometa’s capabilities exceed anything Plex Pass offers for organization, at zero additional cost [README].
• Key strength: Pre-made “Kometa Defaults” — a curated library of ready-to-use collection and overlay templates that give you a professional-looking library without building everything from scratch [README].
• Key weakness: All configuration is YAML files. There is no graphical config editor in the main product (a Quickstart tool exists but is explicitly labeled as early development and incomplete) [2][5]. If you don’t know what a YAML file is, start somewhere else.

---

What is Kometa

Kometa is a Python script that runs on a schedule (or on demand) and modifies your Plex library: creating smart collections, applying visual overlays to posters, and syncing metadata from external databases. You write a configuration file in YAML describing what you want — “create a collection of all trending movies from Trakt, apply an ‘Awards’ overlay to anything that won an Oscar” — and Kometa executes it against your Plex server.

The project started as “Plex Meta Manager” before being renamed to Kometa, which is why you’ll see both names in older community posts. It sits at 3,225 GitHub stars with an active Discord server and a community configs repository where users share their setups [README].

What makes it different from manually curating collections inside Plex is automation and persistence. Kometa runs on a schedule — hourly, daily, weekly — and your collections stay current. Add a new movie to your library on Tuesday, and by Wednesday morning it’s in your “4K Sci-Fi from the 90s” collection without you touching anything. When a movie wins a BAFTA, the overlay appears. More importantly: because all the configuration lives in YAML files you control, you can move your entire library customization to a new server in minutes. Plex’s own database doesn’t store your custom logic — Kometa does [README].

The tool connects to third-party services to populate collections: TMDb for general metadata and popularity rankings, Trakt for curated lists and user ratings, IMDb for award histories and charts, and Letterboxd via Trakt integration. On the automation side, it integrates with Sonarr and Radarr to feed discovered content back into your download automation pipeline [README][website].

---

Why people choose it

The use case is narrower than something like Activepieces — Kometa does one thing and does it for one platform. You’re here because you have Plex, you have a lot of media, and the built-in Plex collections are either too manual or not flexible enough.

The three reasons that pull people toward Kometa consistently:

1. The Defaults library eliminates 90% of the manual work. Building collections by hand — one filter, one poster, one at a time — is tedious. Kometa ships pre-built collection and overlay files for virtually every common use case: streaming service collections (Netflix, HBO, Disney+), genre collections, decade collections, award collections, resolution overlays, audio codec overlays, status overlays for ongoing shows. You enable the ones you want in your config and Kometa handles the rest [README][website].

2. Overlays that Plex can’t do natively. Plex doesn’t put “4K HDR Dolby Vision” badges on your posters. Kometa does. It doesn’t mark which shows are “Returning” vs “Ended” on the poster thumbnail. Kometa does. These visual overlays are baked directly onto the poster images and visible in any Plex client — Apple TV, Roku, phone — without any plugin [README].

3. Your configuration is portable. The moment you store your library customization as YAML files in a git repository, you’ve future-proofed against Plex database corruption, server migrations, and hardware changes. Reset your server, clone your repo, run Kometa — your library looks the same in 20 minutes [README].

---

Features

Collection building:

• Pull from TMDb trending, popular, top-rated lists [README]
• Pull from Trakt lists, watchlists, user ratings [README]
• Pull from IMDb charts (Top 250, Most Popular, award winners) [README]
• Filter by genre, decade, studio, network, actor, director [README]
• Build collections from your own watched history, ratings, or custom criteria [README]
• Schedule automatic updates so collections stay current [README]

Overlays:

• Resolution badges (4K, 1080p, 720p) on poster thumbnails [README]
• Audio codec overlays (Dolby Atmos, DTS-X, TrueHD) [README]
• Status overlays for TV shows (Returning, Ended, Cancelled, Airing) [README]
• Award badges (Oscars, BAFTA, Emmys, etc.) [README]
• Custom artwork support — bring your own overlay images [README]
• Real-time preview generator in Quickstart [2][5]

Metadata management:

• Override titles, summaries, artwork at the library level [README]
• Sync ratings from external services [README]
• Apply season and episode-level ratings from services that support them (with caveats — some services only provide show-level data) [website]
• Metadata changes stored in config files, not in Plex’s database — survives server resets [README]

Integrations:

• Plex (required — this is a Plex-only tool) [README]
• TMDb (required for most collection builders) [1][4]
• Trakt, IMDb, Letterboxd, Radarr, Sonarr [README]
• MDBList, AniDB, AniList for anime libraries [README]

Quickstart (experimental): A web-based config generator and runner — the closest thing to a GUI. Runs locally as a Python script or Docker container. Generates your config.yml, connects to Plex to validate settings, and can run Kometa directly from the interface [2][5]. The project’s own documentation flags it as early development, incomplete (no template variable support for default collections), and missing support for external YAML files [2][5]. It’s useful for getting the initial config file right, but not a replacement for understanding the YAML format.

---

Pricing: free tool, real infrastructure costs

There is no SaaS version of Kometa to compare against. The software is MIT-licensed and costs nothing [README].

What you actually spend:

• Kometa software: $0
• A server to run it on: $0 if you already run Plex on a home server or NAS; $5–10/month on a VPS if you need separate infrastructure
• TMDb API key: free (required) [1][4]
• Trakt API key: free (required for Trakt integrations)
• Your time: the honest variable

The Plex Pass comparison:

Plex Pass ($4.99/month, $39.99/year, $119.99 lifetime) gives you basic collection tools, mobile sync, and hardware transcoding. Kometa adds collection automation, overlays, and metadata management on top of that — it doesn’t replace Plex Pass if you need the other features, but for library organization specifically, Kometa’s capabilities go substantially beyond what Plex Pass offers natively.

The honest cost is setup time, not money. Kometa is free. The investment is the 2–6 hours to understand the config structure, set up the YAML files, get your API keys, and tune your first run. After that, it runs unattended.

---

Deployment reality check

The official documentation is explicit about the complexity level, which is a good sign: “Note that running a Python script is inherently a pretty technical process. If you are unable or unwilling to learn the rudiments of using tools like python and git, you should probably strongly consider running Kometa in Docker.” [1][4]

Option 1: Docker (recommended for most people) The Docker path removes Python version management and dependency hell. You mount a /config volume, pass environment variables for your Plex URL and token, and the container handles the rest. Works on unRAID, Synology, QNAP, and Kubernetes with platform-specific walkthroughs in the documentation [website].

Option 2: Local Python Requires Python 3.10–3.13, Git, and running pip install for dependencies. The documentation walks through this step-by-step, including intentionally triggering errors so you understand what they mean. Realistic time for a technical user: 30–45 minutes to a working first run [1][4].

What you need regardless of method:

• A running Plex server with a library that has content
• Plex URL and Plex authentication token (findable in Plex’s “Get Info” menu on any item)
• TMDb API key (free registration at themoviedb.org)
• A text editor comfortable with YAML indentation — a single tab vs. spaces mistake breaks the config

What can go sideways:

• Large libraries (1,000+ items) make the first run slow. The docs recommend creating a test library with 10–20 movies before running against your full library [1][3][4].
• The Quickstart tool is flagged as incomplete — it doesn’t expose template variables for default collections, so you can’t fully customize defaults through it [2][5]. You’ll need to learn some raw YAML regardless.
• The three separate branches (master/develop/nightly) with active commits in each mean behavior can differ based on which branch you’re running. Stick to master unless you specifically want bleeding-edge features.

Realistic setup timeline:

• Technical user with Docker experience: 1–2 hours to working collections
• Non-Docker technical user: 2–3 hours including troubleshooting Python environment
• Non-technical user: this tool is not designed for you; the documentation says so directly [1][4]

---

Pros and cons

Pros

• MIT license, genuinely free. No “community edition” limitations, no commercial tier required, no per-execution pricing [README].
• Kometa Defaults remove most of the work. You can get a professionally organized library — streaming service collections, genre collections, resolution overlays — by enabling pre-made files rather than configuring everything from scratch [README][website].
• Configuration is portable and version-controllable. Your YAML files are your library configuration. Git them. Back them up. Move servers without losing your setup [README].
• Overlay system is genuinely unique. Plex has no native way to put codec or resolution badges on poster thumbnails across all clients. Kometa does this at the image level, universally [README].
• Active community. Discord server, community configs repository, subreddit, active development with nightly/develop/master branches [README][website].
• Supports multiple media server types. Primarily Plex, but the documentation also covers Jellyfin and Emby support [website].
• Docker-native. The recommended deployment path is clean and maintainable [README][website].

Cons

• YAML configuration is the entire interface. There is no working GUI. Quickstart exists but the project itself says it’s incomplete and doesn’t cover external YAML files [2][5]. You are editing text files.
• Plex-first, everything else secondary. If you’ve moved from Plex to Jellyfin, the feature parity isn’t the same. The documentation, defaults, and community configs are all Plex-centric.
• Initial setup complexity is real. The documentation’s own local walkthrough says it’s “pedantic” and “assumes you’ve never run a Python script before” — which means it’s designed for people who find this difficult [1][4]. Getting API keys, writing your first config, understanding YAML nesting, waiting for a 30-minute first run — it’s not quick.
• Requires external API keys to unlock most value. TMDb is free but required. Trakt is free but required for Trakt lists. Each integration is one more credential to manage [1][4].
• Run times on large libraries are long. Scanning, fetching, and applying changes to 5,000+ items takes time. The docs explicitly warn about this and recommend test libraries [1][3][4].
• Quickstart is in early development. The flagship “beginner-friendly” path has a danger banner on it in the official docs [2][5]. Not a confidence-inspiring signal for new users.

---

Who should use this / who shouldn’t

Use Kometa if:

• You run Plex and want your library to look curated without manually maintaining every collection.
• You’re comfortable editing YAML files and running Docker containers (or willing to learn).
• You want your collection configuration in version control and portable between servers.
• You want overlays — resolution badges, audio codec indicators, show status — that Plex doesn’t provide natively.
• You have a media library large enough that manual curation is genuinely time-consuming.

Skip it if:

• You’re not running Plex (limited benefit for Jellyfin/Emby users).
• The words “YAML configuration file” make you close browser tabs. The documentation is explicit: this tool requires you to edit text files [1][4].
• Your library is small enough that manual Plex collections take 20 minutes per year to maintain.
• You were expecting a dashboard with a GUI — Quickstart is incomplete and covers only the initial config [2][5].
• You want a set-and-forget installation in 15 minutes. The first setup requires a few hours and some technical patience.

---

Alternatives worth considering

• Plex’s built-in collections — Manual, no overlays, no automation. Fine for small libraries. Doesn’t require any setup beyond Plex itself.
• Plex Meta Manager — This was the previous name of Kometa. If you’re finding documentation under that name, it’s the same project.
• Jellyfin with plugins — If you’ve moved away from Plex, Jellyfin has plugins that handle some of this functionality natively, with varying community quality.
• Radarr/Sonarr lists — These manage what you download, not how it’s displayed. Complementary to Kometa rather than competitive. Kometa integrates with both [README].
• Manual Plex curation + Plex Pass — The fallback. Costs $4.99/month, requires ongoing manual maintenance, no overlay support.

---

Bottom line

Kometa is a genuinely useful automation tool for a specific audience: Plex users who have enough media that manual curation becomes a chore, and enough technical comfort that a YAML config file doesn’t cause paralysis. For that audience, it delivers — a scheduled script that keeps your collections current, pulls from real external databases, and applies visual overlays that Plex itself can’t do. The MIT license means no fees, no tier limits, no eventual price hike.

The honest caveat is the audience fit. The official documentation explicitly warns non-technical users away from the local Python install path, and the “beginner-friendly” Quickstart tool ships with a danger banner noting it’s incomplete [1][2][4][5]. This is not the tool for a founder who wants to escape SaaS complexity — it adds a different kind of complexity in exchange for zero licensing cost. For the Plex power user who already lives in Docker Compose files and YAML configs, it’s one of the more useful scripts in the self-hosted space.

---

Sources

1. Local Walkthrough (nightly) — Kometa Wiki (Windows/Mac/Linux installation guide). https://kometa.wiki/en/nightly/kometa/install/walkthroughs/local/
2. Quickstart — Kometa Wiki (nightly build documentation for the Quickstart web interface). https://kometa.wiki/en/nightly/kometa/scripts/quickstart/
3. Local Walkthrough (develop) — Kometa Wiki (develop-branch installation guide). https://kometa.wiki/en/develop/kometa/install/walkthroughs/local/
4. Local Walkthrough (latest) — Kometa Wiki (stable release installation guide). https://kometa.wiki/en/latest/kometa/install/walkthroughs/local/
5. Quickstart (latest) — Kometa Wiki (stable release Quickstart documentation). https://kometa.wiki/en/latest/kometa/scripts/quickstart/

Primary sources:

• GitHub repository: https://github.com/kometa-team/kometa (3,225 stars, MIT license)
• Official website and wiki: https://kometa.wiki