The usual way to protect a stream is to put the manifest behind a signed URL, make the token expire, and trust that anyone without a valid link gets turned away. That stops casual hotlinking, and it is the right place to start.
CDN leeching gets around it without breaking anything. A pirate service pays for one account, pulls a valid stream URL out of your app and hands it to thousands of its own viewers, who stream straight from your CDN while your token check keeps passing. Akamai's analysis for its customers found more than 40% of traffic being leeched in some cases, and Synamedia estimates pirates sit on 30 to 50% of some providers' bandwidth (DecodeTV).
So the job is bigger than signing URLs: a stolen link has to be short-lived and narrow, you have to notice when one is being shared, and you need a way to cut it off. Below, we walk through how leeching works, why signed URLs alone fall short, what it costs at your own numbers, how to detect it, and the layered setup that stops it.
What is CDN leeching?
CDN leeching is when someone serves your video to their own audience directly from your CDN, using links or tokens that your system considers valid. You pay for every byte, the viewers never touch your app, and nothing in your logs looks broken. That is what makes leeching so expensive: the traffic arrives through the front door, carrying credentials you issued.
It is often confused with two neighbouring problems, and each one needs a different fix:
| Hotlinking | CDN leeching | Restreaming | |
|---|---|---|---|
| What the pirate takes | A public file URL | A valid, signed stream URL or token from a real account | The decoded video itself |
| Whose bandwidth serves it | Yours | Yours | The pirate's own servers |
| What usually stops it | Domain restrictions | Short-lived, narrowly scoped tokens, detection and revocation | DRM, watermarks and takedown notices |
Of the three, a CDN leak through leeching is the hardest to see, because every request looks like one of your own subscribers.
How pirates leech a video stream, step by step
Leeching is usually automated, which is why it scales from one account to a whole pirate audience:
Nothing in that flow is an attack your CDN can recognise. Step 5 looks like your own viewers, the token is real, and if the URL lives for hours, the pirate only has to refresh it a few times a day. Rotating IP addresses and headless browsers make the source account look like one ordinary subscriber.
Live sports are hit hardest, because a match is worth the most in the hour it airs, and a leaked token only has to survive that long.
Why signed URLs alone don't stop CDN leeching
Signed URLs prove that your system issued a link. They say nothing about who is using it now, which leaves four gaps a pirate can work with:
- Long expiry. A token that lives for a day can be shared all day. Expiry is the main lever you control.
- Tokens that aren't scoped. A token that unlocks a whole library is worth far more to a pirate than one tied to a single video.
- Checks only on the manifest. If the CDN validates the token on the playlist but serves segments without checking, anyone holding the segment URLs can keep pulling them, including from cache.
- No link to the viewer. A bearer token works for whoever holds it, so unless something ties playback to a session, sharing it is invisible.
The industry's answer is richer tokens. The Common Access Token standard (CTA-5007-B, published by the Consumer Technology Association in April 2025) defines a "policy-bearing bearer token" that CDNs can verify consistently, so the rules travel with the token instead of living in one CDN's configuration (CTA).
What CDN leeching costs a streaming service
The bill is simple to estimate, and worth working out before you decide how much protection you need:
monthly leeching cost = leeched viewer-hours × GB per hour × your CDN price per GBGB per hour follows from bitrate. A 1080p stream at 5 Mbps moves about 2.25 GB an hour (5 megabits × 3,600 seconds ÷ 8 ÷ 1,000). As an illustrative example, with assumptions you should replace with your own: 1,500 pirate viewers watching 40 hours a month at 1080p is 60,000 viewer-hours, or 135,000 GB. At $0.02 per GB, that is $2,700 a month spent serving people who never paid.
Bandwidth is only the visible part. Leeched viewers also count against your capacity during a live peak, where they compete with paying users, and every one of them is a viewer your own player, ads and analytics never see. Synamedia's estimate that some providers' CDN bills could be doubling is what that looks like at scale (DecodeTV).
How to detect CDN leeching
Leeching hides inside normal-looking traffic, so detection means comparing numbers that should match and looking for the ones that don't:
- Delivery with no matching sessions. If your CDN served far more hours than your player recorded, someone is watching outside your player. Analytics that run inside your player, such as FastPix Video Data, only count your own viewers, which is exactly what makes the gap visible.
- Players you don't ship. A player name you never built, or a stream with no player session behind it, points to someone else's player.
- One token, many places. The same token or session requested from many IP addresses or countries within minutes is a shared credential, not a traveller.
- Unknown domains and user agents. Requests from origins that aren't your site, or from download tools, command-line clients and headless browsers.
- Spikes nobody planned. A jump in bandwidth that doesn't match a release, a campaign or a live event in your own calendar.
How to stop CDN leeching: a layered setup
No single control stops leeching, because the pirate holds a real credential. What works is making that credential short-lived and narrow, refusing it everywhere except your own app, and revoking it fast. Streams we serve at FastPix under a private playback policy already start from the first layer: your server signs a token for one video, we check it before serving any part of that video, and the token stops working when it expires (JWT docs).
| Layer | What it stops | What it doesn't | On FastPix |
|---|---|---|---|
| Short-lived tokens scoped to one video | Links shared for hours, tokens that unlock a whole library | A pirate refreshing tokens through a paid account | JWT with aud set to one playback ID and a short exp, signed on your server |
| Domain restrictions | Other sites embedding or hotlinking your player | Native apps and scripts that fake an origin | Allow and deny lists, up to 25 domains each, with wildcards (docs) |
| User agent restrictions | Download managers, command-line clients, headless browsers | Clients that spoof a browser user agent | Allow and deny lists of exact user agent strings, up to 25 each |
| Session and concurrency limits | One account feeding thousands of viewers | Leeching when tokens live for hours | Enforced in your app, against the account behind each token request |
| Revoking a leaked link | A URL that is already circulating | New links pulled from another account | Delete the playback ID and issue a new one |
| DRM | Copies of the file playing anywhere | A shared, valid license token | Widevine, FairPlay and PlayReady for on-demand video (DRM docs) |
On FastPix, both restriction lists can be set when a video is created or changed later on a live playback ID, and we fire a webhook on each change (video.playbackId.domains.updated and video.playbackId.user-agents.updated), so your own tooling knows the moment a rule moves. Our docs are also plain that user agents can be spoofed, which is why we put that layer behind a private playback policy rather than in place of it. One detail matters when a link leaks: switching a video to private does not revoke URLs that were already handed out, so replace the playback ID instead.
Lock down your video streams with FastPix
If your streams are paid, licensed or live sports, start with the layer pirates exploit most: tokens that expire quickly and unlock one video. Create a free account, which comes with $25 in credits, create a playback ID with a private access policy, and sign tokens on your server.
Then add your domains and block download tools with playback restrictions, and turn on DRM for the on-demand titles that need it.
FAQs
What is CDN leeching?
CDN leeching is when a pirate serves your video to their own viewers straight from your CDN, using a valid stream URL or token taken from a real account. You pay for the bandwidth and the viewers never use your app. On FastPix, private playback IDs limit the damage by requiring a short-lived token your server signs for one video.
How do I stop people from hotlinking my videos?
Restrict playback to your own domains and require a signed token, so a copied link fails on any other site. On FastPix you set allow and deny lists of up to 25 domains per playback ID, with wildcards such as *.example.com, and pair them with a private playback policy. Domain checks rely on the browser's origin, so the token is what stops scripts.
How do I stop someone from sharing my signed video URL?
Make the URL expire quickly and scope it to one video, so a shared link stops working soon and unlocks nothing else. On FastPix, your server signs a JWT whose audience is a single playback ID and whose expiry you choose, and FastPix rejects it after that. If a URL is already circulating, delete the playback ID and issue a new one.
Which video API lets me restrict playback to my own domain?
FastPix lets you restrict each playback ID to your own domains with allow and deny lists of up to 25 entries, including wildcards, and block user agents such as download managers and headless browsers. Restrictions can be set at upload or changed later through the API, and each change fires a webhook your systems can listen for.
How do I know if someone is stealing my video bandwidth?
Compare the hours your CDN delivered with the hours your player recorded: a large gap means people are watching outside your app. Player-side analytics such as FastPix Video Data only count your own viewers, so the gap shows up clearly. Also look for one token used from many IP addresses, players you don't ship, and unknown referring domains.
Does DRM stop CDN leeching?
DRM makes CDN leeching harder but does not stop it alone: every viewer needs a license, so a leaked stream URL plays nothing, yet a pirate who also shares a valid license token can still play. That is why DRM sits alongside short-lived tokens and revocation. FastPix offers Widevine, FairPlay and PlayReady for on-demand video, with a separate DRM token checked on every license request.
Can I revoke a video URL that has already leaked?
You can revoke a leaked video URL by replacing the playback ID it points to. On FastPix, delete the old playback ID and create a new one; changing a video to private does not cut off URLs that were already handed out. Signed tokens also expire on their own, so a short expiry limits how long any leak lasts.






