Twitch Helix API – Live Streaming & Creator Economy Data

The live pulse of the largest streaming platform on earth, in rows. Twitch's official interface spans 29 endpoint families - Ads, Analytics, Bits, Channels, Channel Points, Charity, Chat, Clips, Conduits, Entitlements, Extensions, EventSub, Games, Goals, Guest Star, Hype Train, Moderation, Polls, Predictions, Raids, Schedule, Search, Streams, Subscriptions, Tags, Teams, Users, Videos and Whispers - and the analytical heart of it is four list surfaces: Get Streams (every current live broadcast with viewer counts), Get Top Games and Get Games (categories ranked by viewer popularity, with box art and IGDB crosswalk IDs), Get Clips, and the channel-information, followers, videos, schedule and analytics surfaces.

Structure is the selling point. Each stream row carries its broadcaster triple (user_id, user_login, user_name), its category pair (game_id, game_name), the title as filed, applied tags, an ISO 639-1 language code, the UTC RFC3339 moment the broadcast began, and the viewer count standing at capture. List responses paginate through an opaque cursor at up to 100 items per page (default 20), which is how millions of streams and channels resolve into complete sets rather than front-page samples.

Inside Datadory's interactive-media-services shelf this is a 10 out of 10 - one of only 144 such scores across roughly 1,750 cataloged datasets, and one of five perfect grades in this eighteen-dataset industry. Get a sample of this dataset and the rows arrive typed, decoded and join-ready.

The two core response shapes, flat, exactly as fields arrive:

# Get Streams response shape - one row per current live broadcast
id           : stream-id-string
user_id      : broadcaster-user-id
user_login   : login-name
user_name    : Display Name
game_id      : category-id
game_name    : Just Chatting
type         : live
title        : stream title
viewer_count : <integer>
started_at   : 2026-08-21T12:00:00Z        <- UTC RFC3339
language     : en                          <- ISO 639-1, or 'other'
thumbnail_url: .../{width}x{height}.jpg

# Get Top Games response shape - one row per category, ranked by viewers
id          : category-id
name        : Just Chatting
box_art_url : .../{width}x{height}.jpg
igdb_id     : igdb-identifier-or-empty

# every list response carries an opaque continuation handle
pagination.cursor: eyJiIjpudWxsLCJhIjp7Ik9mZnNldCI6NX19

Three things worth reading out of fourteen lines. First, the broadcaster triple travels on the row - ID, login and display name together - so a delivery needs no second lookup to become a watchlist. Second, the category arrives twice, as machine ID and human name, with the games surface adding an IGDB crosswalk ID that joins straight into game databases. Third, started_at in UTC RFC3339 beside capture time yields session length by subtraction, which is how broadcast-hours get computed honestly. Multiply the stream row by every current broadcast and vary the capture time, and you have Twitch viewership as a dataset.

Nineteen verified fields carry the analytical weight: the fourteen-field stream record, the four-field category record from the games surface, and the pagination cursor that binds every list response into a walkable sequence. They group cleanly - broadcaster identity (user_id, user_login, user_name), categorization (game_id, game_name, with box art and IGDB crosswalk on the category side), content (title, tags, thumbnail_url), state and timing (type, viewer_count, started_at), and market signal (language). Every definition was checked against Twitch's own endpoint documentation during the August 2026 research pass.

Beyond Streams and Games, the remaining twenty-seven endpoint families - Clips, Users, Videos, followers, schedules, moderation events, polls, predictions, analytics - are enumerated but not individually field-verified this pass, so they fold under additional fields on request and get pinned against live records when your sample is prepared.

• Geography - the whole platform in one frame, on every continent Twitch reaches. Place arrives as the ISO 639-1 language code each stream carries (or 'other' for unsupported languages), so language-market cuts are native and country-level attribution comes from joining elsewhere.
• Temporal - this is the rare dataset whose subject is now: live broadcasts and viewer counts constitute the current state, refreshed continuously by the platform itself. Videos and clips retain historical content, and analytics endpoints report over date ranges, but longitudinal viewership history is what scheduled deliveries accumulate.
• Granularity - five native levels: per stream, per channel/broadcaster, per category, per clip, per user - plus per-event granularity in real time from the event layer.

Set against the wider catalog, where the average quality score is 7.81 and only about one dataset in eleven carries real-time state, this slice scores 10/10: fully verified definitions, shipped sample shapes, and a subject nothing else in the industry can substitute for.

API, files, or your warehouse. Daily, weekly, or hourly.

You pick the channel and the cadence; cursor chaining, category-name resolution and deprecated-field handling stay our problem. Rows arrive normalized - stream, category and broadcaster levels separated but keyed, so a viewer-count series joins to a channel profile without string surgery.

Every delivery ships the full field dictionary and sample rows for validation, and a scoped sample comes first either way.

• Creator-partnership monitoring - track a named roster of streamers for live status, category shifts and audience movement as rows in a table instead of tabs in a browser.
• Category trend panels - scheduled pulls of the ranked category ladder turn today's snapshot into a panel of which games and non-game formats gain and lose audience, the input behind most creator-economy decks that hold up.
• Language-market sizing - ISO 639-1 codes on every stream make audience splits by language a group-by rather than an estimation exercise.
• Engagement modeling - viewer counts, session starts and category mix per broadcaster give demand-side features to sponsorship-pricing and churn models.
• Clip virality research - the clip family pairs creators with games and view-count metadata, the raw material of spread studies once its fields are pinned at sample time.

Developers and builders lead fit - one normalized schema across twenty-nine families is precisely what a discovery, alerting or co-watching product wants handed to it. Data scientists accumulate scheduled captures into balanced broadcaster and category panels with dead fields already flagged. Competitive-intelligence teams watch rival-sponsored streamers and category movements week over week. Market researchers size audiences by category and language with the platform's own live-state numbers. Investors and quants reconstruct aggregate engagement from scheduled pulls and feed it to creator-economy theses. Persona workflows live at developers builders x interactive media services, data scientists x interactive media services, competitive intel product teams x interactive media services and market researchers x interactive media services.

YouTube Data API v3 is the natural rival and the subject of our side-by-side comparison: video-centric where Twitch is broadcast-centric, with comment threads and search where Twitch offers live viewer counts and a ranked category ladder. Spotify Web API catalogs audio and playlist state with no audience-size signal attached. TwitchTracker Game & Channel Rankings compiles historical leaderboards - useful for retrospection, but derived and lagging where this is primary and current. Wayback Machine CDX Server API archives snapshots after the fact; nothing archived beats asking the platform who is live this minute. On the infrastructure side, PeeringDB Global Interconnection Database describes the pipes beneath all streaming platforms and pairs with this one for network-economy work.

Four things, all knowable upfront.

First, this is a live-state dataset. Streams and viewer counts describe the present; the past exists only as VODs, clips and dated analytics ranges. A viewership time series is built by scheduling deliveries, which is a decision to make once rather than improvise later.

Second, two documented deprecations: tag_ids and is_mature are retired on stream records - the latter always returning false now - so maturity filtering needs another route and tag-based taxonomies need pinning down at sample time.

Third, depth requires cursor walks. Pages run up to 100 items through an opaque cursor, so a complete sweep of a busy moment is a chained operation; deliveries hand you completed sets rather than first pages.

Fourth, field verification concentrates on Streams and Games. The other twenty-seven families are enumerated and deliverable, but their field-level detail folds under additional fields on request and gets confirmed against live records before your pipeline commits.

Because the artifact underneath is an interface designed for application backends checking one thing at a time, and every interesting question wants many moments, many channels and many categories in one frame. Datadory normalizes the endpoint families into warehouse tables keyed on stable IDs, resolves category IDs to names and IGDB crosswalks so joins stop being string surgery, chains cursors into complete sets, flags the deprecated fields instead of passing them through silently, and schedules the pulls that turn live state into longitudinal record. Browse the rest of the shelf on the interactive media services data hub, the best interactive media services datasets ranking, the interactive media services data guide, or the full catalog.