Skip to content

HTTP API ​

The SDKs call a small HTTP API. This page documents that contract, so you can resolve streams from your own code. Most integrations don't need it: the Bring your own player mode keeps your player and still uses the SDK for resolution, license headers and refresh. Read Before you go SDK-less first.

Overview ​

MethodPathReturnsUse it to
GET/v1/catalogCatalogList tournaments and matches
GET/v1/matches/{matchUrn}MatchRead one match, poll its status
GET/v1/tournaments/{tournamentUrn}TournamentRead one tournament with its matches
GET/v1/playback/{matchUrn}PlaybackGet the manifest URL and DRM URLs
POSTdrm.widevine.licenseUrl, drm.fairplay.licenseUrlLicense bytesGet a DRM license
GET/v1/events/{matchUrn}StateEvent streamFollow one match's live state
GET/v1/eventsStateEvent streamFollow every match in your catalog

A typical player makes three calls:

  1. GET /v1/catalog to show the matches.
  2. GET /v1/playback/{matchUrn} when the viewer picks one.
  3. POST to the license URL from step 2, made by the player's DRM module.

Base URLs ​

EnvironmentAPILive-state events (SSE)
Integrationhttps://feed-dev.oddin-video.gghttps://events.feed-dev.oddin-video.gg
Productionhttps://feed.oddin-video.gghttps://events.feed.oddin-video.gg

Test keys (pk_test_…) work against integration, and production keys (pk_live_…) against production. Every other host you call comes from a response: the manifest URL, the DRM license URL and the analytics endpoint. Don't hard-code those.

Conventions ​

TopicRule
FormatJSON, UTF-8. Field names are camelCase
TimestampsStrings in RFC 3339, always UTC, to the second: "2026-05-07T18:00:00Z"
URNsStrings. Matches are od:match:<id>, tournaments od:tournament:<id>, teams od:competitor:<id>
Optional fieldLeft out of the object when it has no value. Never sent as null
ArraysAlways an array when present. Can be empty
New fieldsWe add fields without notice. Ignore fields you don't know
Enum valuesWe can add values. Handle a value you don't know as described for each field

In the type tables below, a field marked optional can be absent. Every other field is in every object of that type.

Authentication ​

Every /v1/ request carries the publishable api-key in a header:

HeaderRequiredValue
x-api-keyYesYour publishable key, pk_test_… or pk_live_…
OriginYesSet by the browser. It must be on the key's allow-list

Call the API from the viewer's browser, on an origin that is on your key's allow-list. A request with no Origin (curl, Postman, a backend proxy) is rejected. The license URL in a playback response is also bound to the key that fetched it. See Get your origins allow-listed. This page covers browsers. Native apps use the iOS and Android SDKs, which authenticate in a different way.

ts
const res = await fetch('https://feed-dev.oddin-video.gg/v1/catalog', {
  headers: { 'x-api-key': 'pk_test_…' },
});
Statuserror.codeMeaning
401UNAUTHORIZEDThe key is unknown, revoked, suspended, or used on the wrong environment
403FORBIDDENThe key is valid, but the request's origin is not on its allow-list
429RATE_LIMITEDToo many requests from your key or address. Wait Retry-After seconds
503UPSTREAM_UNAVAILABLEThe auth service is unreachable. Retry after Retry-After seconds

Every response carries an X-Request-ID header. Include it when you contact havik-support@oddin.gg. Error bodies are an ApiError.

GET /v1/catalog ​

Returns the tournaments and matches your key is entitled to, as a Catalog. The catalog carries metadata only. To play a match, call /v1/playback/{matchUrn}.

Request

http
GET /v1/catalog?sport=cs2,dota2&status=live,upcoming HTTP/1.1
Host: feed-dev.oddin-video.gg
x-api-key: pk_test_…
If-None-Match: W/"9f2c1a7e"
Query paramTypeValuesEffect
sportcomma-separated stringsAny Tournament.sport valueOnly tournaments of those sports
statuscomma-separated stringsAny MatchStatus valueOnly matches with one of those statuses
limitinteger1 to 1000Only the first N tournaments, by from

All parameters are optional. Filters combine with AND across parameters and OR within one parameter. The server ignores unknown values and unknown parameters.

Response 200: a Catalog.

json
{
  "tournaments": [
    {
      "name": "IEM Katowice 2026",
      "urn": "od:tournament:42",
      "description": "Intel Extreme Masters, Katowice",
      "liquipediaUrl": "https://liquipedia.net/counterstrike/IEM/2026/Katowice",
      "sport": "cs2",
      "from": "2026-02-01T10:00:00Z",
      "to": "2026-02-14T22:00:00Z",
      "isOffline": true,
      "matches": [
        {
          "matchUrn": "od:match:1234",
          "matchName": "Team A vs Team B",
          "datePlannedStart": "2026-02-08T18:00:00Z",
          "status": "live",
          "teams": [
            {
              "urn": "od:competitor:26406",
              "name": "Team A",
              "isHome": true,
              "logoUrl": "https://cdn.oddin.gg/assets/teams/icons/team_a.png"
            },
            { "urn": "od:competitor:20836", "name": "Team B", "isHome": false }
          ]
        }
      ]
    }
  ]
}
Response headerMeaning
ETagA version of this body. Send it back as If-None-Match to get 304 when unchanged
Cache-Controlpublic, max-age=10, stale-while-revalidate=30. max-age=0, must-revalidate while stale. Poll no faster than that
X-Catalog-Staletrue when the server answered from its cache because its source is degraded
X-Catalog-Truncatedtrue when limit cut the list

Response 304 Not Modified: sent when your If-None-Match equals the current ETag. It has no body: keep using the catalog you already hold. The ETag and Cache-Control headers are still set.

Statuserror.codeMeaning
200A Catalog
304Unchanged since your If-None-Match. No body

Errors are the auth errors in Authentication.

Tournaments are sorted by from, and matches by datePlannedStart. Tournaments with no matches left after filtering are omitted. There is no push channel for the catalog, so poll it. For an auto-updating lobby, use the catalog-wide event stream.

GET /v1/matches/{matchUrn} ​

Returns one Match. Use it for deep links, and to poll one match's status: the edge caches it, unlike /v1/playback.

Request

http
GET /v1/matches/od:match:1234 HTTP/1.1
Host: feed-dev.oddin-video.gg
x-api-key: pk_test_…
If-None-Match: W/"4b7e90d2"

Response 200: a Match.

json
{
  "matchUrn": "od:match:1234",
  "matchName": "Team A vs Team B",
  "datePlannedStart": "2026-02-08T18:00:00Z",
  "status": "upcoming",
  "teams": [
    { "urn": "od:competitor:26406", "name": "Team A", "isHome": true },
    { "urn": "od:competitor:20836", "name": "Team B", "isHome": false }
  ]
}
Response headerMeaning
ETagA version of this body. Send it back as If-None-Match to get 304 when unchanged
Cache-Controlpublic, max-age=10, stale-while-revalidate=30. Poll no faster than that
Statuserror.codeMeaning
200A Match
304Unchanged since your If-None-Match. No body
400INVALID_URNThe URN is malformed
404NOT_FOUNDThe match is not in your catalog, or has left it (after its end)

The auth errors in Authentication also apply.

GET /v1/tournaments/{tournamentUrn} ​

Returns one Tournament with its matches.

Request

http
GET /v1/tournaments/od:tournament:42 HTTP/1.1
Host: feed-dev.oddin-video.gg
x-api-key: pk_test_…

Response 200: a Tournament, in the same shape as one entry of Catalog.tournaments. See the catalog example.

Response headerMeaning
Cache-Controlpublic, max-age=10, stale-while-revalidate=30. Poll no faster than that

This endpoint sends no ETag and never answers 304.

Statuserror.codeMeaning
200A Tournament
400INVALID_URNThe URN is malformed
404NOT_FOUNDThe tournament is not in your catalog

The auth errors in Authentication also apply.

GET /v1/playback/{matchUrn} ​

Returns the Playback credential for one match: the manifest URL and the DRM license URLs. This is the entitlement gate. A match outside your key's tournaments returns the same 404 as an unknown match.

Request

http
GET /v1/playback/od:match:1234 HTTP/1.1
Host: feed-dev.oddin-video.gg
x-api-key: pk_test_…

Response 200: a Playback.

json
{
  "matchUrn": "od:match:1234",
  "protocol": "hls",
  "mediaType": "live",
  "drmEnabled": true,
  "manifestUrl": "https://<cdn-host>/<path>/main.m3u8",
  "drm": {
    "widevine": {
      "licenseUrl": "https://<drm-host>/v1/drm/license/widevine?<signature>"
    },
    "fairplay": {
      "licenseUrl": "https://<drm-host>/v1/drm/license/fairplay?<signature>",
      "certificateUrl": "https://<drm-host>/v1/drm/certificate/fairplay"
    }
  },
  "expiresAt": "2026-05-07T22:00:07Z",
  "serverTime": "2026-05-07T10:00:00Z",
  "analytics": {
    "sid": "3f1b9c52-6a0e-4d7b-9e43-2c8d1f0a7b61",
    "endpoint": "https://<beacons-host>"
  }
}

The <…> parts vary by viewer and by request. Use every URL exactly as you receive it.

Other responses

Statuserror.codeMeaningWhat to do
400INVALID_URNThe URN is malformedFix the URN
404NOT_FOUNDUnknown match, or not in your entitlementStop
410GONEThe tournament has ended and nothing is serving the matchStop
425TOO_EARLYNot playable yet: before kickoff, or packaging in progressRetry after Retry-After seconds
503UNAVAILABLENo stream right now: it dropped, or there is noneRetry with backoff, or wait for a live event

A 425 body is a TooEarlyError:

json
{
  "error": { "code": "TOO_EARLY", "message": "match has not started; retry in 60s" },
  "liveStartsAt": "2026-05-07T18:00:00Z"
}

Retry-After follows the time to kickoff: the exact delta inside 30 seconds, then a tenth of the delta, capped at 5 minutes. Add jitter to your retries, because every viewer of a match waits for the same kickoff.

Caching. Every playback response is sent with Cache-Control: private, no-store. It is per viewer: the hosts in it follow the viewer's region. Call it once per playback start, and again to refresh the license URL.

License requests ​

The player's DRM module POSTs the CDM's license challenge to drm.widevine.licenseUrl or drm.fairplay.licenseUrl. FairPlay players first GET the certificate from drm.fairplay.certificateUrl, with the x-api-key header. Send no api-key on manifest and segment requests: those go to a public CDN.

Request

http
POST /v1/drm/license/widevine?<signature> HTTP/1.1
Host: <drm-host>
x-api-key: pk_test_…
X-Device-Id: 8d4f2b1e-0c7a-4e59-b3d6-71a2e9f05c34
X-Match-Urn: od:match:1234
Content-Type: application/octet-stream

<challenge bytes from the CDM>
HeaderRequiredValue
x-api-keyYesThe same key that fetched the playback response
X-Device-IdYesA stable id per browser or device. Up to 256 characters A-Za-z0-9-_.@:
X-Match-UrnYesThe match URN
Content-TypeYesapplication/octet-stream
X-User-IdNoYour own viewer id, same character rules as X-Device-Id

The body is the raw challenge bytes from the CDM, at most 16 KiB. A 200 response body is the license bytes: hand them to the CDM unchanged.

Three rules cause most license failures:

  • POST the URL unchanged. Don't rewrite, re-encode or reorder its query string. The query string is the signature.
  • Use the same api-key for the playback request and the license request. The signature is bound to it.
  • Get your origin on the DRM allow-list too. A missing origin fails in the CORS preflight, and the viewer sees black video with no error.

Errors from the license and certificate endpoints are a DrmError. This is the complete list:

StatuserrorMeaningWhat to do
400missing_device_idNo X-Device-Id headerFix the request
400invalid_device_idX-Device-Id is too long or has a character outside A-Za-z0-9-_.@:Fix the request
400invalid_user_idSame rules, for X-User-IdFix the request
400missing_match_urnThe match could not be read from the requestFix the request
400invalid_match_urnThe match URN is malformedFix the request
400invalid_drm_systemThe path names a DRM system other than widevine or fairplayUse the URL unchanged
400invalid_request_bodyThe body could not be readFix the request
400empty_challengeThe body is emptySend the CDM's challenge bytes
401(no body)The api-key is unknown, revoked or on the wrong environmentCheck the key
403origin_not_allowedYour page's origin is not on the key's allow-listGet the origin allow-listed
403forbiddenThe license URL expired or was changed, or a different api-key was usedResolve again, then retry
403entitlement_deniedYour key is not entitled to this matchStop
403license_refusedThe license provider refused this requestStop. Retrying does not help
403cdm_revokedThe provider says this device's DRM module is revokedStop. Tell the viewer
404not_foundNo such pathUse the URL unchanged
405method_not_allowedWrong HTTP methodPOST licenses, GET the certificate
413request_too_largeThe challenge is larger than 16 KiBFix the request
429rate_limit_exceededToo many license requests from this addressBack off, then retry
500internal_errorAn error inside the DRM serviceRetry once
502drm_provider_errorThe upstream license provider failedRetry once
503entitlement_unavailableThe entitlement check could not runRetry with backoff

License URL lifetime ​

There are two lifetimes, and they are not the same:

WhatLifetimeWhat happens when it runs out
The signed license URL10 minutesA new license request with that URL gets 403
The license in the CDM4 hours by defaultPlayback stops with a DRM error. A new license is needed

The license lifetime is set per key, so yours can differ from the default. Ask havik-support@oddin.gg for the value on your key, and don't build a fixed 4-hour timer into your player.

The license URL only matters when the player makes a license request. That happens at start, and again whenever your player rebuilds its DRM session, for example after a recovery or a reload. A player that holds an old URL then fails with 403.

Re-resolve /v1/playback/{matchUrn} before the URL expires, and give the player the new license URL for its next request. The SDK does this every 8 minutes. Don't reload the manifest or the player when you refresh: only the license URL changes. A refresh can't extend a license that the CDM already holds.

GET /v1/events/{matchUrn} ​

A Server-Sent Events stream of StateEvent objects for one match. Use it to start playback the moment a match goes live, and to stop at the end without polling. It is served on the events host from Base URLs, with the same x-api-key and entitlement rules.

The browser's EventSource can't send an x-api-key header. Use a fetch-based SSE client, such as @microsoft/fetch-event-source.

text
event: state
data: {"matchUrn":"od:match:1234","state":"live","serverTime":"2026-06-25T12:00:00Z"}

: ping

event: state
data: {"matchUrn":"od:match:1234","state":"ended","reason":"interrupted","serverTime":"2026-06-25T13:41:09Z"}

Request

http
GET /v1/events/od:match:1234 HTTP/1.1
Host: events.feed-dev.oddin-video.gg
x-api-key: pk_test_…
Accept: text/event-stream

Response 200: a stream that stays open. The first line is retry: 3000, the reconnect delay in milliseconds.

Response headerValue
Content-Typetext/event-stream; charset=utf-8
Cache-Controlno-store
Statuserror.codeMeaningWhat to do
200The stream is openRead events
400INVALID_URNThe URN is malformedFix the URN
404NOT_FOUNDUnknown match, or not in your entitlementStop
503TOO_MANY_CONNECTIONSYour address has too many streams open. Sent with Retry-After: 10Close unused streams, then retry

Error responses have an ApiError body. The auth errors in Authentication also apply.

Each data: line is one StateEvent as JSON. On connect, the server sends the current state, then each change. Comment lines (: ping) keep the connection open, about every 20 seconds: ignore them. The server closes each connection after about 30 minutes. Reconnect, and you get the current state again.

stateMeaningMatching /v1/playbackWhat to do
upcomingBefore kickoff425Wait
pendingKickoff has passed and packaging is in progress425Wait
livePlayable200Fetch /v1/playback, then play
endedThe stream stopped. See reason503Stop loading, keep the connection open
goneNothing is coming: the tournament ended, or no stream410 or 503Stop, close the connection

An ended event with reason: "interrupted" means a stream that was playing has dropped. Show "reconnecting", not "this stream has ended". If the stream comes back, it often comes back under a new manifest URL, so fetch /v1/playback again on the next live. Treat any state you don't recognize as "wait".

At the end of a match, the HLS playlist does not get an #EXT-X-ENDLIST tag. It stops changing. Use this event stream as the end signal. As a fallback, treat a playlist that has not advanced for about 12 seconds as ended.

GET /v1/events ​

The same stream for every match in your catalog, for an auto-updating lobby. On connect, it sends one StateEvent for each match that is not gone, then each change. Use matchUrn to tell the matches apart.

The request, headers and errors are the same as for /v1/events/{matchUrn}, without the 400 and 404. Matches outside your entitlement are left out of the stream.

Data types ​

Each type is shown as a TypeScript definition, then field by field. A ? in the definition marks an optional field.

Catalog ​

The body of GET /v1/catalog.

ts
interface Catalog {
  tournaments: Tournament[];
}
FieldTypeDescription
tournamentsTournament[]Your entitled tournaments, sorted by from. Can be empty.

Tournament ​

ts
interface Tournament {
  urn: string;
  name: string;
  sport: string;
  description?: string;
  liquipediaUrl?: string;
  from?: string;
  to?: string;
  isOffline: boolean;
  matches: Match[];
}
FieldTypeDescription
urnstringThe tournament id. Example: "od:tournament:42".
namestringDisplay name. Example: "IEM Katowice 2026".
sportstringSport key. See the list below. Example: "cs2".
descriptionstring, optionalFree text. Example: "Intel Extreme Masters, …".
liquipediaUrlURL string, optionalThe tournament's Liquipedia page. Example: "https://liquipedia.net/…".
fromtimestamp string, optionalPlanned start of the tournament. Example: "2026-02-01T10:00:00Z".
totimestamp string, optionalPlanned end of the tournament. Example: "2026-02-14T22:00:00Z".
isOfflinebooleanThe offline flag from the data source, passed through unchanged. In esports, "offline" usually means an on-site (LAN) event, but we don't guarantee that meaning. Example: true.
matchesMatch[]Its matches, sorted by datePlannedStart.

sport is one of cs2, dota2, lol, valorant, cs2_duels, dota2_duels, rush_soccer, rush_basketball, rush_cricket, rush_hockey, rush_madden, table_tennis and virtual_soccer. It is unknown for a sport the server does not recognize yet. We add sports over time.

Match ​

Metadata for one match. It never carries a playback URL: call /v1/playback/{matchUrn} for that.

ts
interface Match {
  matchUrn: string;
  matchName: string;
  datePlannedStart?: string;
  status: MatchStatus;
  teams?: Team[];
}
FieldTypeDescription
matchUrnstringThe match id. Pass it to /v1/playback. Example: "od:match:1234".
matchNamestringDisplay name. Use teams to build your own layout. Example: "Team A vs Team B".
datePlannedStarttimestamp string, optionalScheduled kickoff. Absent when the match has no schedule. Example: "2026-02-08T18:00:00Z".
statusMatchStatusWhere the match is now. Example: "live".
teamsTeam[], optionalHome side first. In practice, two entries.

MatchStatus ​

ts
type MatchStatus = 'upcoming' | 'pending' | 'live' | 'ended';
ValueMeaning
upcomingBefore the planned start
pendingKickoff has passed and the stream is not playable yet, or it was playing and dropped
livePlayable now
endedReserved. Not sent today, because a finished match leaves the listing

A pending match can have a datePlannedStart in the past. That is normal: it covers the few seconds at every match start while packaging finishes. Treat a value you don't know as upcoming.

Team ​

ts
interface Team {
  urn: string;
  name: string;
  isHome: boolean;
  logoUrl?: string;
}
FieldTypeDescription
urnstringThe team id. Can be "" when the source sent a name only. Example: "od:competitor:26406".
namestringDisplay name. Example: "Team A".
isHomebooleantrue for the home side. Example: true.
logoUrlURL string, optionalAn https logo, about 150 px on the long side. Example: "https://cdn.oddin.gg/…".

Always render a fallback for a missing logo or one that fails to load. See Teams and logos.

Playback ​

The body of a 200 from GET /v1/playback/{matchUrn}.

ts
interface Playback {
  matchUrn: string;
  protocol: 'hls';
  mediaType: 'live' | 'vod';
  drmEnabled: boolean;
  manifestUrl: string;
  drm?: Drm;
  expiresAt?: string;
  serverTime: string;
  analytics?: PlaybackAnalytics;
}
FieldTypeDescription
matchUrnstringThe match you asked for. Example: "od:match:1234".
protocol"hls"Streaming protocol. Example: "hls".
mediaType"live" or "vod"Always live today. Treat an unknown value as live. Example: "live".
drmEnabledbooleantrue: set up DRM with drm. false: the stream is clear, skip DRM. Example: true.
manifestUrlURL stringThe HLS playlist to load. Use it unchanged. Example: "https://…/main.m3u8".
drmDrm, optionalThe DRM URLs. Present exactly when drmEnabled is true.
expiresAttimestamp string, optionalWhen a signed manifestUrl stops working. At least 12 hours, often days. Example: "2026-05-07T22:00:07Z".
serverTimetimestamp stringThe server clock, to correct for client clock skew. Example: "2026-05-07T10:00:00Z".
analyticsPlaybackAnalytics, optionalPresent only when playback analytics is enabled for your key.

A session that passes expiresAt gets 403 on its next playlist request. Before that time, resolve again and load the new manifestUrl. expiresAt is absent when the URL is not signed. Use the value from the response: don't compute it from serverTime.

Playback has no kickoff time. Before kickoff you get a 425 instead, and its TooEarlyError carries liveStartsAt.

Drm ​

ts
interface Drm {
  widevine: { licenseUrl: string };
  fairplay: { licenseUrl: string; certificateUrl: string };
}
FieldTypeDescription
widevine.licenseUrlURL stringPOST Widevine challenges here: Chrome, Firefox, Edge, Android.
fairplay.licenseUrlURL stringPOST FairPlay challenges here: Safari on macOS and iOS.
fairplay.certificateUrlURL stringGET the FairPlay certificate here, with your x-api-key.

Both license URLs end in a signed query string that is valid for 10 minutes. Each signature is bound to your key, the match and its own endpoint, so a Widevine URL does not work for FairPlay. See License URL lifetime.

PlaybackAnalytics ​

ts
interface PlaybackAnalytics {
  sid: string;
  endpoint?: string;
}
FieldTypeDescription
sidstringAn opaque session id. It is not a secret. Example: "3f1b9c52-6a0e-4d7b-9e43-2c8d1f0a7b61".
endpointURL string, optionalWhere the SDK sends playback quality metrics for this session. Example: "https://…".

The SDK uses this object to report playback quality. Without the SDK, you can ignore it: playback does not depend on it. Contact havik-support@oddin.gg if you want quality metrics from your own player.

StateEvent ​

The JSON in each data: line of the event streams.

ts
interface StateEvent {
  matchUrn: string;
  state: 'upcoming' | 'pending' | 'live' | 'ended' | 'gone';
  reason?: 'interrupted' | 'match_ended';
  serverTime: string;
}
FieldTypeDescription
matchUrnstringThe match this event is about. Example: "od:match:1234".
statestringThe match's state. See the table in the event stream. Example: "live".
reasonstring, optionalOnly on ended. interrupted: the stream dropped. match_ended is reserved. Example: "interrupted".
serverTimetimestamp stringWhen the server sent the event. Example: "2026-06-25T12:00:00Z".

ApiError ​

The body of every non-2xx response from the API, except 425.

ts
interface ApiError {
  error: { code: string; message: string };
}
FieldTypeDescription
error.codestringA stable code. Branch on it. Example: "NOT_FOUND".
error.messagestringA human-readable sentence. It can change, so don't parse it. Example: "match not found".

code is one of UNAUTHORIZED, FORBIDDEN, NOT_FOUND, INVALID_URN, TOO_EARLY, GONE, UNAVAILABLE, UPSTREAM_UNAVAILABLE, RATE_LIMITED, TOO_MANY_CONNECTIONS and INTERNAL. TOO_MANY_CONNECTIONS comes from the event streams, when one address opens too many at once.

TooEarlyError ​

The body of a 425 from /v1/playback. It is an ApiError with one more field.

ts
interface TooEarlyError {
  error: { code: 'TOO_EARLY'; message: string };
  liveStartsAt?: string;
}
FieldTypeDescription
error.code"TOO_EARLY"Always TOO_EARLY. Example: "TOO_EARLY".
error.messagestringA human-readable sentence with the retry delay. Don't parse it. Example: "match has not started; retry in 60s".
liveStartsAttimestamp string, optionalKickoff, for a countdown. Absent once kickoff has passed (pending). Example: "2026-05-07T18:00:00Z".

DrmError ​

The body of a non-2xx response from a license or certificate URL. It has a different shape from ApiError.

ts
interface DrmError {
  error: string;
}
FieldTypeDescription
errorstringA stable code. See License requests. Example: "forbidden".

Before you go SDK-less ​

An integration without the SDK is supported, but you then own all the work the SDK does:

  • the device id, the license headers and the license URL refresh
  • the 425 wait with jitter, and the go-live, end and rejoin handling
  • the player tuning in Tuning your own player

If you only want your own player, keep the SDK for resolution and DRM. That is the Bring your own player mode. It is a few lines of code, and it keeps up with API changes for you.

ISC licensed. Bundles hls.js (Apache-2.0).