How VideoCore works
The pipeline end to end: what happens to a file after you upload it, what the player is allowed to do, and exactly where the guarantees stop.
Overview
VideoCore is a multi-tenant platform for private video. You upload a source file, it is transcoded into an adaptive HLS ladder, and it is played back through a hosted iframe player that runs only on origins you have approved. There is no durable public URL for the media itself: the manifest, the decryption key and every segment are authorized individually, on the request that asks for them, against a playback session scoped to one account, one video and one origin.
Storage and transfer are metered by the platform in integer bytes — not by the payment processor. Stripe collects fixed subscriptions and add-on purchases; it is never told how many bytes moved.
Quick start
-
01
Sign in to the owner panel at
/appand upload a source video. Capacity is reserved before the transfer starts. - 02 Wait for transcoding to report ready. The video becomes playable only once every rendition has validated.
- 03 Open the embed drawer, add the origins allowed to frame this video, and copy the generated iframe.
- 04 Paste it into a page served from one of those origins. Nothing else needs configuring.
<iframe
src="https://your-host.example/embed/{video}"
width="960" height="540"
allowfullscreen></iframe>
Uploading
Uploads use S3 multipart directly from the browser. The application signs individual part URLs and never receives the media body, which is what makes multi-gigabyte sources practical: a dropped connection resumes from the last completed part instead of restarting.
Storage capacity is reserved before the first part is signed, and the reservation is reconciled against the object's actual size once the upload completes. An abandoned upload releases its reservation rather than silently consuming quota.
Transcoding
Each source is probed, then transcoded by FFmpeg in an isolated, low-concurrency worker into a multi-rendition H.264 / AAC HLS ladder, plus a poster image and thumbnails. Renditions are never upscaled beyond the source resolution — a 720p upload does not become a fictional 1080p stream.
Packaging is MPEG-TS with AES-128 encryption. Publication is atomic: the video flips to ready only after all outputs validate, so a viewer never reaches a half-written ladder.
Embedding and origins
Every video carries its own allowlist. An origin is normalized to scheme, host and effective port —
https://example.com and https://example.com:443 are the same entry, and
https://app.example.com is not.
Enforcement is two-sided. The player response carries a per-video
Content-Security-Policy: frame-ancestors header listing only that video's origins, so
the browser refuses to render the frame elsewhere — including inside a nested frame chain. The
server-side embed gate independently rejects the handshake.
That protects against other websites embedding the player. A script or tool that is not a browser can still ask for a playback session. Each session is therefore tied to the viewer's network and capped in the bytes it may fetch, which blocks most reuse of stream links elsewhere but does not stop a determined viewer from relaying or recording what they watch. Signed embeds are an opt-in, per-video control that stops other servers from starting a session at all.
Path rules are best-effort. An optional path restriction narrows an embed to particular pages, but it relies on the referrer the browser chooses to send. Treat it as tidying, not as a boundary. The allowed-website list is the stronger control. Browsers that send only the website and not the page — Safari and every iOS browser, Brave, Firefox private windows — are refused for a path-restricted embed rather than let through.
Playback sessions
When an allowed embed loads, the handshake mints a short-lived playback session scoped to account, video and origin. The session is reusable on purpose: an HLS player issues repeated manifest, key, segment, range and retry requests, and a one-time token would break legitimate playback on the first seek.
Reuse is safe because the session is not authority by itself — it is re-checked, along with live quota, on every media request it is presented with. Sessions expire, and a session issued for one origin is useless from another.
Authorized delivery
Media bytes never pass through the application. Nginx receives the media request and makes an
auth_request sub-request to an internal authorization endpoint, which returns a
decision and nothing else — no body. On approval, Nginx serves the object from private storage
itself.
Range requests pass through the same path, which matters for accounting: delivered bytes are reserved conservatively up front and reconciled afterwards against the durable delivery log, so seeking does not quietly under-count transfer.
Quotas and billing
Storage and transfer are accounted in integer bytes everywhere; gigabyte figures are display only. The hot path reserves transfer atomically in Redis, and those counters are reconciled against PostgreSQL delivery logs — Redis is the fast path, PostgreSQL is the durable truth. When quota state cannot be determined, enforcement fails closed.
Capacity comes from three configurable catalogs: subscription plans, prepaid transfer packs and recurring storage add-ons. Administrators can also record audited entitlement overrides. Actual tiers, limits and prices are per-deployment configuration — check the billing page in your panel rather than assuming numbers.
Entitlement changes only when a signature-verified Stripe webhook is processed. The redirect back from Checkout lands on a pending page that grants nothing; capacity appears when the webhook arrives.
Security model
- Obscurity is not access control
- Identifiers are opaque, but the authorization decision is what protects the object — a leaked path is not a working link.
- Tenant isolation is enforced in depth
- Every tenant row carries an account id, checked in policies, route binding, queries, queue jobs, scheduled commands and exports — not only in the panel.
- AES-128 is not DRM
- Encryption plus per-request key authorization defeats casual redistribution of URLs. It is not Widevine, FairPlay or PlayReady, and it cannot stop an authorized viewer from recording their own screen.
- Failure is closed
- If authorization or quota state is unavailable, the request is denied rather than served optimistically.
What this does not do
Stated plainly so nothing is inferred from silence. The current version does not provide:
- Commercial DRM (Widevine, FairPlay, PlayReady)
- Live streaming
- Guaranteed anti-screen-recording
- Native mobile applications
- Team accounts and per-user roles
- Captions and subtitles
- Custom player branding
- CDN integration