Skip to content

Every segment asks permission first.

VideoCore takes your source file, transcodes it into an adaptive HLS ladder, and then refuses to serve a single byte of it without re-checking who is asking, which page they are asking from, and whether you still have transfer left. There is no durable media URL to leak, because there is no URL that works twice on its own.

<iframe src="https://your-host/embed/{video}" allowfullscreen>
that is the whole integration. No media URLs in your markup.

one playback request p95 < 50 ms target
  1. 0 ms GET /embed/{video} origin checked against this video’s allowlist
  2. +1 CSP: frame-ancestors … browser refuses the frame anywhere else
  3. +2 POST …/handshake mints a session: account + video + origin
  4. +3 GET …/segment-004.ts player asks for the next six seconds
  5. +4 auth_request → /media-authorize session re-checked, transfer reserved

200 · bytes from private storage

Nginx serves the segment itself. The application returned a decision, never a body.

403 · origin not on the list

The same markup, copied to a site you did not approve, never reaches this line.

The guarantees, and what each one is actually made of

origin

A browser shows the player only on the sites you allowed

Origins normalize to scheme, host and effective port. The player answers with a per-video frame-ancestors policy listing only that video’s origins, and the server-side embed gate rejects the handshake independently. Two mechanisms, neither relying on the other.

session

A playback session is reusable, and re-checked anyway

HLS players retry, seek and range-request constantly, so a one-time token would break the first seek. The session is instead scoped to one account, one video and one origin, tied to the viewer’s network, capped in the bytes it may fetch, expires quickly, and is verified again on every media request it is presented with.

delivery

Media never passes through the application

Nginx makes an auth_request sub-request that returns a decision and no body, then serves the object from private storage itself. Range requests take the same path, and delivered bytes are reserved up front and reconciled afterwards so seeking cannot under-count.

quota

The platform owns the accounting, not the payment processor

Storage and transfer are counted in integer bytes, reserved atomically in Redis on the hot path and reconciled against durable PostgreSQL delivery logs. When quota state cannot be determined, the request is denied rather than served optimistically.

entitlement

Capacity moves on a verified webhook, never on a redirect

The browser coming back from Checkout grants nothing at all. Entitlement changes only when a signature-verified Stripe webhook is processed idempotently, and no usage is ever reported to Stripe as metered billing.

From a file on your disk to a frame on their screen

upload

Straight to private storage

S3 multipart from the browser. The application signs part URLs and never receives the body, so a dropped connection resumes from the last completed part instead of starting over. Capacity is reserved before the first part is signed.

transcode

Isolated FFmpeg worker

Probe, then an H.264 / AAC ladder with poster and thumbnails, packaged as MPEG-TS with AES-128. Renditions are never upscaled past the source. Publication is atomic — a viewer cannot reach a half-written ladder.

approve

Your list of origins

Add the sites allowed to frame this video and copy the generated iframe. Optional path rules narrow it further, and the interface says plainly that those are best-effort.

play

Authorized per request

The embed gate checks entitlement, origin and quota, mints a session, and every manifest, key and segment after that is authorized on its own before Nginx serves it.

Where the guarantees stop

Access control is only worth trusting if it is honest about its edges. Six statements we will not let marketing round up.

Path rules are best-effort
A path restriction depends on the referrer the browser chooses to send. It usefully narrows where an embed works. It is not a boundary — the allowed-website list is the stronger control.
Where the guarantees stop
The allowed-website list is enforced by the browser, so it governs browsers. A script or tool that is not a browser can ask for a playback session itself; the network binding and the per-session byte cap limit what that session can fetch, but they do not make a stream impossible to copy. Signed embeds, an opt-in per video, stop other servers from starting a session at all.
A viewer can relay or record what they watch
A person who may watch can still pass the stream through their own connection or keep a copy of what they download. We limit and measure this; we do not claim to prevent it.
AES-128 is not DRM
Encryption plus per-request key authorization defeats URL sharing. It is not Widevine, FairPlay or PlayReady, and it cannot stop an authorized viewer from recording their own screen.
Obscurity is not access control
Identifiers are opaque, but that is not what protects the object. The authorization decision is. A leaked path is not a working link.
No live streaming, captions, team roles or CDN
Stated so silence is not read as a claim. Also absent: native apps, custom player branding, and any promise about screen recording.

Put a video somewhere only your sites can reach it