Your app sends a single authenticated request. Provider and content ID are resolved server-side. Nothing about the source is exposed to the caller.
GET /api/streams/:provider/:id
Authorization: Bearer <jwt>01 / Infrastructure
Streamingproxy infrastructureready to integrate.
A production-grade streaming proxy with source aggregation, encrypted delivery and residential egress built in. Drop it behind your app and skip the months of infrastructure work. One endpoint, multiple sources, nodes already running.
02 / Surface
What you get out of the box
- 001
Kernel splice
Segments never enter userspace. Bytes move socket-to-socket, so a 4 GB file costs no more resident memory than a 40 KB one. Only concurrent connections move the number.
- 002
Opaque transport
Every request carries an AES-256-GCM payload holding the target, headers and expiry. No plaintext parameter is ever on the wire. Without the key the node returns 403.
- 003
Residential egress
Sources that block datacenter IPs are served from a residential address instead, routed over a local SOCKS5 hop. Bulk segments bypass it entirely to keep costs down.
- 004
Playlist rewriting
Manifests are fetched, every variant and segment URI rewritten through the node, and the first twelve segments prefetched before the player requests them.
- 005
Source aggregation
One endpoint fans out to multiple upstream providers, ranks results by quality, and fails over silently. The caller never sees a provider failure.
- 006
Persistent counters
Request and byte totals flush to disk every sixty seconds using atomic renames. A container rebuild costs at most one minute of telemetry, nothing more.
03 / Transit
One request, four hops
Your request goes in, a playable stream comes out. Here is what happens between those two points.
The target URL, upstream headers and an expiry timestamp are sealed into an AES-256-GCM payload. No readable parameter leaves the worker at any point.
seal({ url, h: { Referer }, exp })
→ ?d=hOKZn8LnvI6BBsZBit7Mqy…The nearest node opens the payload, fetches the upstream over a pooled keepalive connection, and rewrites the manifest so every segment returns through it.
open(d) → fetch(url, h)
rewrite(m3u8) · prefetch(12)Segments move at the kernel level, straight from upstream socket to your client. Cached on NVMe on the way through, so repeat requests cost nothing.
splice(upstream → client)
cache_store(seg, ttl=6h)04 / Fleet
Nodes in rotation
Every node runs the same image. Region determines latency. You get all of them from day one, no setup required.
NodeLocationComputeMemoryCacheRTT
AMSRAmsterdamNL2× EPYC4 GB DDR560 GB NVMe11ms
LDNLondonUK2 vCPU2 GB40 GB SSD14ms
YULRMontréalCA2 vCPU4 GB80 GB NVMe82ms
SINSingaporeSG1 vCPU2 GB50 GB SSD176ms
RResidential egress available on this node.Interested in using this?
If you are building a streaming app and want this infrastructure behind it, get in touch. Tell us what you are building and we will let you know if it is a good fit.