theintrodb.org

TheIntroDB is a community-verified timestamp database for TV shows and movies. It provides exact start and end times for intros, recaps, credits, and previews, so media players can skip those segments automatically or on demand. It is aimed at people who watch through a self-hosted or configurable player and want episode playback to jump straight to the content. The site also offers a free API and plugins for players such as Jellyfin, Emby, and Kodi, which is what makes the timestamps usable without manual seeking.

What problem it solves

Streaming services often mark intros and credits themselves, but that metadata usually stays inside the service. If you watch files from your own library, the player has no idea where the opening sequence ends or where the credits begin. TheIntroDB fills that gap by storing per-episode and per-movie time ranges that a compatible player can read and act on.

The four segment types it covers are:

• Intros — opening titles and theme sequences
• Recaps — "previously on" summaries at the start of an episode
• Credits — end credits, including the point where they begin
• Previews — next-episode or trailer segments

How the pieces fit together

TheIntroDB works as a data layer, not a player. The flow looks like this:

1. A title in your library is matched to an entry in the database.
2. The player retrieves the timestamp range for the relevant segment.
3. The player skips that range, either automatically or via a skip button.

The "community-verified" part matters here: timestamps are contributed and checked by users rather than generated from a single source, which is how the database covers shows across different releases and edits. Because episode timing can vary between cuts, the accuracy of any single entry depends on the community having matched the right version.

Ways to use it

The plugin route is the lowest-effort option for most home-server users, since the player handles matching and skipping. The API route makes sense if you want skip behavior inside a custom tool or a player that isn't on the supported list.

What to check before relying on it

• Coverage for your specific titles. A community database is strongest on popular shows and weaker on obscure or regional content. Look up a few episodes you actually watch before committing.
• Version matching. If your file is a different cut, an extended edition, or from a release with a different cold open, the stored timestamps may be off. Verify on one episode first.
• Player support. Confirm your player has a plugin or an integration path; the timestamps are only useful if something on your side reads them.
• Login and pricing details. The site describes the API as free, but check the current terms on the site itself before building anything dependent on it.

A concrete example

Say you run Jellyfin and watch a drama series where every episode opens with a 90-second recap followed by a 60-second title sequence. Without metadata, you skip forward by hand each time. With TheIntroDB connected through the Jellyfin plugin, the player looks up the episode, finds the recap and intro ranges, and offers to skip them. The result is that playback starts at the episode's actual cold open, and you only intervene if an entry is wrong.

Bottom line

TheIntroDB is worth knowing about if you watch TV and movies from your own library and want intro, recap, credit, and preview skipping without manual seeking. Start by checking whether your player has a plugin and whether your most-watched titles have entries; if both hold, the setup is mostly a one-time configuration. If you need skipping inside custom software, the free API is the path to evaluate.

OpenAPI-generated API documentation is reference documentation that is produced automatically from an OpenAPI description file rather than written by hand. You write (or generate) a machine-readable specification of your API — endpoints, parameters, request bodies, responses, schemas, and auth — and a documentation tool reads that file and renders a browsable, often interactive reference site. The spec becomes the single source of truth; the docs become a build artifact.

This differs from manually written docs in one fundamental way: with hand-written docs, the prose is the source of truth and the API is described separately. With spec-driven docs, the API description is the source, and every page, table, and code sample is derived from it.

How the workflow actually runs

A typical spec-driven documentation pipeline has five stages:

1. Author or generate the spec. You either write an OpenAPI document by hand (YAML or JSON), or generate it from code annotations, framework metadata, or a design-first editor. Design-first means the spec is written before implementation; code-first means it is extracted from existing code.
2. Validate and lint. The spec is checked against the OpenAPI schema and against style rules — consistent naming, required descriptions, no undocumented 4xx responses, no orphaned schemas.
3. Bundle and transform. Multi-file specs are combined, $ref pointers are resolved, and the document is optionally split into per-tag or per-version outputs.
4. Render. A documentation tool converts the spec into HTML: an endpoint list, a sidebar of operations, parameter tables, response schemas, and a "try it" console.
5. Publish and version. The rendered site is deployed, and each API version gets its own snapshot so consumers can read docs matching the version they call.

Steps 2 through 5 are usually automated in CI. If the spec fails validation, the docs build fails — which is the point.

Spec-driven vs. hand-written documentation

The practical conclusion most teams reach: generate the reference, write the guides. Reference material is repetitive and mechanical, which is exactly what generation is good at. Conceptual explanations, migration notes, and tutorials carry judgment that a spec cannot express.

What you get out of the box

Generated reference pages commonly include:

• An operation list grouped by tag or path, with HTTP method and path.
• Parameter tables showing name, location (path, query, header, cookie), type, required flag, and description.
• Request and response schemas rendered as expandable trees, including nested objects and arrays.
• Authentication details pulled from the securitySchemes section.
• Interactive request consoles that let a reader send a real call from the browser.
• Generated code samples in several languages, derived from the same schemas.
• Multiple output formats, such as a static site, a single HTML file, or a mock server.

Because all of these come from one document, changing a field name in the spec updates the parameter table, the schema tree, and every code sample at once.

Where spec-driven documentation breaks down

Generation is not free. The trade-offs are real:

Spec quality becomes documentation quality. A field with no description produces a table row with an empty cell. A vague summary produces a vague heading. Tools can enforce presence of descriptions via linting, but they cannot enforce that the description is useful.

Customization has limits. If you need a page that does not map to an OpenAPI concept — a conceptual overview, a pricing explanation, a comparison of two endpoints — you write it outside the generator and link to it.

Not everything is expressible. Webhooks, streaming responses, long-polling behavior, and complex multi-step flows are awkward or impossible to describe fully in OpenAPI. Those need prose.

The spec can go stale. If the spec is maintained separately from the implementation, it drifts just like hand-written docs. The mitigation is to generate the spec from code, or to test the implementation against the spec in CI.

Interactive consoles need care. A "try it" button that hits a production API with real credentials is a security and rate-limit problem. Point it at a sandbox, or disable it.

Deciding whether to adopt it

Adopt spec-driven reference documentation if most of these are true:

• Your API has more than a handful of endpoints, or changes frequently.
• You ship client SDKs or code samples in more than one language.
• Multiple teams consume the API and need a consistent, always-current reference.
• You already have, or are willing to maintain, an OpenAPI description.

Stay with hand-written docs, or a hybrid, if:

• Your API is small and stable, and the reference fits on one page.
• Your documentation is mostly conceptual and contains little endpoint-level detail.
• You cannot commit to keeping the spec in sync with the implementation.

A reasonable middle path: generate the reference from the spec, and hand-write the getting-started guide, authentication walkthrough, and error-handling page. Link the two directions so readers can move from concept to endpoint and back.

A minimal starting checklist

1. Produce one valid OpenAPI document for a single API version.
2. Add a linter with rules for descriptions, operation IDs, and error responses.
3. Wire the docs build into CI so a failing spec fails the build.
4. Render the reference and review it as a reader, not as the author.
5. Write the two or three conceptual pages the generator cannot produce.
6. Version the published docs alongside the API version.

The core idea is simple: describe the API once, in a format both machines and humans can read, and let the reference documentation fall out of that description. Everything else — tooling, hosting, interactivity — is a detail on top of that decision.

TheIntroDB verifies skip timestamps through community contribution and confirmation rather than a single editorial team: users submit timestamps for intros, recaps, credits, and previews, and the data is described on the site as "community-verified." The practical takeaway is that trust comes from multiple people converging on the same markers for a given episode or film — so the more popular a title, the more reliable its timestamps tend to be. If you need a skip point for an obscure release, expect to verify it yourself or contribute it.

What "community-verified" means in practice

The site's own framing is the key detail: it advertises "community-verified timestamps" for skipping intros, recaps, credits, and previews in TV shows and movies. That phrasing tells you the verification model is social, not automated:

• Submission: someone watches a title, notes where the intro, recap, credits, or preview begins and ends, and records those points.
• Confirmation: other viewers of the same title encounter the same markers. When their observations match, the timestamp is effectively corroborated.
• Correction: a wrong or drifted timestamp gets flagged by viewers who hit the skip point at the wrong moment, and the community's data improves as a result.

This is the same logic behind crowd-sourced metadata generally: accuracy is a function of how many independent people have checked the same entry. A timestamp confirmed by many viewers of a widely watched show carries more weight than one submitted once for a niche title.

Why this model suits skip data

Skip markers are a good fit for community verification because they are objective and easy to check. An intro either starts at a given second or it doesn't; a viewer who lands mid-scene knows immediately that the marker is off. That gives the community a fast, low-effort error signal — unlike subjective metadata such as genre tags or ratings, where disagreement is expected.

It also means coverage scales with viewership. Popular series accumulate many confirmations quickly; new or obscure titles may have thin or missing data until someone contributes.

How the data reaches your player

TheIntroDB's stated purpose is to supply exact timestamps that players can act on, and the site lists plugins for Jellyfin, Emby, Kodi, and more, plus a free API. The verification question matters here because the plugin or API is only as good as the underlying entries:

1. Your media server or player queries TheIntroDB for the title you're watching.
2. If a verified entry exists, the player offers a skip action at the recorded points.
3. If the entry is missing or wrong, you can adjust manually — and that gap is exactly what a contribution fills.

Deciding whether to rely on it

The honest summary: "community-verified" is a meaningful signal of crowd confirmation, not a formal audit. For everyday viewing of popular titles it's a reasonable convenience; for anything unusual, plan to check the skip point yourself.

TheIntroDB is a good fit if you run a self-hosted media server such as Jellyfin, Emby, or Kodi and want automatic or one-click skipping of intros, recaps, credits, and previews in TV shows and movies. It supplies community-verified timestamps through plugins for those players and a free API. It is not a streaming service or a player itself, so it only helps if your setup can load its data through a supported plugin or your own API integration.

What TheIntroDB actually provides

TheIntroDB is a timestamp database, not a media player. Its stated purpose is to help you "skip intros, recaps, credits, and previews with community-verified timestamps." The data covers both TV shows and movies, and it is exposed in two ways:

• Plugins for Jellyfin, Emby, Kodi, and similar players, which use the timestamps to offer skip buttons or automatic skipping.
• A free API, for tools and scripts that want to query the same timestamp data directly.

That split matters for your decision. If you use one of the supported players, the plugin path is the low-effort option. If you use something else, the API is the realistic route, and you will need to build or configure the integration yourself.

Match the tool to your setup

The deciding factor is almost always the player, not the content. A large, well-covered library is useless if your player has no way to read the timestamps.

Why "community-verified" is the key selection factor

TheIntroDB describes its timestamps as community-verified, which is the right thing to scrutinize before committing. Crowd-sourced skip points can be accurate and fast to appear for popular titles, but they depend on contributors getting the start and end of each segment right. Before relying on it, test a handful of episodes you know well and confirm the skip points land where you expect. If a timestamp is off, the fix is usually a community correction rather than a setting on your side.

Coverage is the other variable. Popular shows and films are the most likely to have entries; obscure or very new titles may lag. Check your most-watched titles rather than assuming full coverage.

A practical way to decide

1. Confirm your player. If you use Jellyfin, Emby, or Kodi, look for the TheIntroDB plugin for that player. If you use anything else, plan on the API.
2. Test on known content. Install the plugin or make one API query, then play two or three episodes whose intro timing you already know. Verify the skip points match.
3. Check your library's weak spots. Look up a few of your less mainstream titles to see whether timestamps exist.
4. Decide based on the result. If the plugin works and your common titles are covered, TheIntroDB fits your setup. If your player is unsupported and you do not want to build an API integration, it does not.

Where it falls short

TheIntroDB will not skip intros inside Netflix, Disney+, or other commercial streaming apps, because those players do not load third-party timestamp plugins. It also does not replace your media server; it is an add-on to one. And because the data is community-maintained, accuracy and coverage vary by title, so a quick test on your own library is more informative than any general claim about how well it works.

TheIntroDB works with media players through plugins and a free API. The site names plugins for Jellyfin, Emby, and Kodi, and says "and more" without listing the rest on the page. If your player isn't named, the API is the path to integration: it exposes the same community-verified timestamp data so other tools can fetch skip points for intros, recaps, credits, and previews.

What TheIntroDB provides

TheIntroDB is a database of exact timestamps for segments viewers usually skip in TV shows and movies: intros, recaps, credits, and previews. The data is community-verified, and the site offers a free API plus plugins for supported players. The benefit in a supported player is automatic skipping — playback jumps past the segment instead of you scrubbing manually.

Players with named plugins

These three are the only players the site explicitly names. "And more" signals additional integrations exist, but the page doesn't identify them, so check TheIntroDB's site for the current list before assuming your player is covered.

Tools that can use the API

The free API is the general-purpose route. Any tool that can make HTTP requests and act on timestamps — a custom player front end, a home-theater script, or an automation tool — can query TheIntroDB and use the returned segment times to skip or flag intros, recaps, credits, and previews. The site describes the API as free; it doesn't state rate limits, authentication requirements, or terms on the page, so confirm those before building on it.

Choosing between plugin and API

• Use a plugin if you run Jellyfin, Emby, or Kodi and want skipping without writing code. This is the lowest-effort path.
• Use the API if your player or tool isn't in the named list, or if you want skip data inside your own application or automation.

What to check before relying on it

1. Confirm your player appears in the current plugin list on the site — the page's "and more" isn't a guarantee for any specific player.
2. If you're integrating via API, review the API documentation for request format, response fields, and any usage conditions, since the landing page doesn't cover them.
3. Expect coverage to depend on community submissions: a title needs verified timestamps before any player or tool can skip its segments.