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.
- 0 ms GET /embed/{video} origin checked against this video’s allowlist
- +1 CSP: frame-ancestors … browser refuses the frame anywhere else
- +2 POST …/handshake mints a session: account + video + origin
- +3 GET …/segment-004.ts player asks for the next six seconds
- +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-ancestorspolicy 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_requestsub-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.