Every CDN sells itself with a map covered in dots and a number next to it. The number is the count of points of presence, and it is close to useless as a selection criterion. A provider with dots on six continents can still be slower for your users than one with fewer, because what matters is not how many locations exist but whether there is a well-connected one near the people who actually load your site, and whether your content is in its cache when they ask.
The second thing the marketing does not tell you is that a CDN is a configuration product, not a bandwidth product. Any of these will serve a static file fast. The differences appear when you need a cache key that ignores a tracking parameter, a stale response served while a revalidation happens in the background, a purge that propagates before your deploy finishes, or a rule that varies caching by device class. Those capabilities differ enormously, and they are what decide whether your cache hit ratio is high or embarrassing.
The third thing is the bill. CDN pricing has at least four shapes in this list, and the cheapest one for a video library is not the cheapest one for an API with small dynamic responses. Bandwidth-metered, request-metered, committed-volume and flat-rate models reward completely different traffic profiles.
This is the evaluation I would run: understand what the caching protocol actually guarantees, work out where your users are, then compare providers on cache control expressiveness, purge behaviour and the meter that matches your traffic.
Key takeaways
- Point of presence count does not predict performance. Network quality and peering near your actual users do, and that is measurable from real user traffic rather than from a map.
- Cache hit ratio is mostly determined by your cache key and your headers, not by the provider. Getting the key right is worth more than switching vendors.
- Purge propagation is a distributed invalidation problem. Tag-based and surrogate-key purging is what makes cache invalidation practical for dynamic sites.
- The four CDN billing shapes reward different traffic profiles. Match the meter to your object size distribution and request rate rather than comparing headline rates.
HTTP caching semantics: a standard, not a product
Every CDN in this list is implementing the same specification, and most cache problems are misunderstandings of it rather than provider limitations.
The mechanism has three moving parts. Freshness determines how long a response can be reused without asking the origin, set by Cache-Control directives such as max-age and s-maxage, where the second applies specifically to shared caches like a CDN and overrides the first for them. Validation determines what happens when a response is stale: the cache sends a conditional request carrying an ETag or a Last-Modified value, and the origin either returns a small not-modified response or a full new one. Variation determines how many separate cached copies exist, via the Vary header naming request headers that change the response.
Two directives matter more than most teams realise. stale-while-revalidate lets a cache serve a stale response immediately while it refreshes in the background, which converts a slow cache miss into a fast hit for the user who triggered the refresh. stale-if-error lets a cache keep serving stale content when the origin is failing, which is a genuine availability feature that costs one header.
The cache key is the other half, and it is where the standard stops and provider configuration starts. By default a cache key is roughly the method plus the full URL including query string, extended by whatever Vary names. That default is why analytics parameters destroy cache hit ratios: two requests for the same image with different campaign tags are two distinct objects to the cache. Every serious CDN lets you normalise the key, and doing so is usually the single largest hit ratio improvement available.
What it gives you
A shared vocabulary that works across every cache between your origin and the user, including browser caches and corporate proxies you have never heard of. Conditional revalidation, which means a stale object costs a small request rather than a full transfer. Explicit control over what may be cached by a shared cache versus only by the user’s own browser, via the private and public directives. Background revalidation and stale-on-error behaviour, which give you both faster tails and better availability from headers alone. And immutability signalling for fingerprinted assets, so a content-hashed filename never needs revalidating at all.
What it does not do
It does not give you a way to invalidate content already in a cache. There is no “forget this object” in the protocol, which is exactly why purge is a proprietary API on every provider and why implementations differ so much. It does not define the cache key beyond the URL, so key normalisation, cookie handling and header stripping are provider features with no portable configuration. It says nothing about how quickly a directive change propagates through a distributed cache network. It has no concept of tags or groups, which is why surrogate keys are a vendor extension. And it does not cover origin shielding, tiered caching, or what happens when a thousand edges all miss on the same object at once, which is a real failure mode the protocol is silent about.
Point of presence count is the wrong number
A map with more dots is not a faster CDN, for several reasons that compound.
Cache dilution. Content is cached where it is requested. Spreading the same traffic over more locations means each location sees fewer requests for each object, which means more of those requests are cache misses that travel to the origin. A provider with fewer, larger locations can have a higher hit ratio on the same traffic than one with more, smaller ones. Providers mitigate this with tiered caching, where an edge miss goes to a regional parent cache rather than to your origin, and whether a provider does this well matters more than the dot count.
Peering quality. A location near your users is only useful if it has good connectivity to the networks those users are on. A point of presence in a city that reaches the local mobile carrier through three transit hops is worse than a more distant one with direct peering. This is invisible from outside and is the main reason two CDNs with similar maps perform differently in the same market.
Relevance. Dots in markets you have no users in contribute nothing. If ninety percent of your traffic comes from three countries, what matters is the provider’s performance in those three countries, which is a much narrower question than global coverage and a much easier one to answer with your own data.
Origin distance for misses. Every cache miss travels to your origin. If your origin is in one region and your traffic is global, miss latency is dominated by that distance no matter how close the edge is. Origin shielding, where one designated location fetches from the origin on behalf of the rest, is what limits this, and it is a feature to check for rather than assume.
The way to actually answer the question is with real user measurements from your own traffic, segmented by country and network. Synthetic tests from cloud regions measure the path from a data centre to a CDN, which is not the path your users take. A real user monitoring tool segmented by geography will tell you where your users are and how badly served they currently are, which is the input to this decision.
Needs first-hand data: From your real user monitoring, produce a table of your top ten countries by traffic volume with p75 time to first byte for each. That table is your requirements document. Then run a trial of each candidate serving a representative asset and compare p75 time to first byte for those same ten countries, weighted by your traffic share rather than averaged.
Cache control granularity is where providers actually differ
Once the protocol is understood, the provider differences are about how much of the request and response you can manipulate, and where.
Cache key control. Can you strip or allowlist query parameters, ignore or include specific cookies, include a device class or a country, and normalise case and trailing slashes? Query parameter handling alone decides hit ratio on most consumer sites, because marketing tools append parameters to every shared link.
Rule expressiveness. Some providers give you a list of match-and-action rules in a console. Others give you a full programming environment that runs at the edge on every request, which lets you rewrite requests, synthesise responses, implement authentication at the edge and do anything else you can express in code. The gap between those two models is enormous and is the main axis this category splits on. The programmable end overlaps directly with edge compute platforms, and several of these providers are both.
Origin behaviour on miss. Tiered caching, origin shielding, request collapsing so that a thousand simultaneous misses on the same object become one origin fetch, and configurable retry and failover between origins. Request collapsing is the feature that prevents a cache stampede taking down your origin when a popular object expires, and its absence is felt exactly once, badly.
Negative caching and error handling. Whether error responses are cached and for how long, and whether stale content is served when the origin fails. A CDN that caches a 500 response for an hour is a self-inflicted outage.
Header and response manipulation. Adding security headers, rewriting redirects, and stripping internal headers before they reach users. Doing this at the edge means it applies uniformly regardless of which origin served the request.
Purge propagation is a distributed invalidation problem
Purging is the operation people assume is instant and it never quite is. Understanding why sets expectations correctly and changes how you design deploys.
A purge is an instruction that has to reach every cache node holding the object. The provider must fan that instruction out across its network, and the time this takes is a property of the control plane rather than the data plane. Different providers have architecturally different approaches, and the practical differences are these.
What you can purge by. Purging a single URL is universal. Purging by prefix or path pattern is common. Purging by tag or surrogate key, where the origin attaches labels to responses and you later invalidate everything carrying a label, is the capability that makes cache invalidation practical for a content-driven site. Without it, invalidating everything affected by a changed article means enumerating every URL that embedded it, which is a problem nobody solves properly.
Whether it is a real purge or a soft purge. A hard purge evicts the object. A soft purge marks it stale, so the next request serves the stale copy immediately and revalidates in the background. Soft purge is almost always what you want for a busy site, because a hard purge on popular content sends a burst of traffic straight to your origin.
Rate limits. Purge APIs are rate limited, and a deploy that purges thousands of URLs individually will hit those limits. This is another argument for tags.
The design conclusion: prefer never purging. Content-hashed filenames for assets mean a new deploy publishes new URLs and the old ones simply age out, with no invalidation needed at all. Reserve purge for content you cannot fingerprint, such as HTML pages and API responses, and use tags there. A deploy pipeline that depends on a global purge completing before traffic shifts is a pipeline with a race condition in it.
Needs first-hand data: Time your own purge propagation. Publish an object, cache it in at least three geographically distant locations by requesting it from each, issue a purge, then poll all three locations and record when each starts returning the new content. Do this for a single-URL purge and for a tag purge, at least ten times each, and record the maximum rather than the average.
Image optimization at the edge, and whether you want it there
Most CDNs now offer image transformation: resize, crop, re-encode to a modern format, and adjust quality, all driven by query parameters or by negotiation on the request headers. The appeal is obvious, since images dominate page weight on most sites and serving a correctly sized modern-format image is the single largest payload reduction available.
The mechanics worth understanding before enabling it. Each distinct transformation is a distinct cached object, so a permissive transformation API multiplies your cache footprint and dilutes hit ratio; constrain the allowed parameter combinations. Format negotiation based on the request’s accept header requires the cache key to vary on it, or you will serve modern formats to browsers that cannot display them. Transformation on a cache miss costs time, so the first request for each variant is slow, which argues for pre-warming the variants your layouts actually use. And the pricing is usually a separate meter counting unique transformations rather than requests, which behaves very differently from bandwidth.
The alternative is transforming at build time or on upload and storing the variants. That is more work up front, cheaper to serve, and gives you full control over encoder settings. Edge transformation wins when your images are user-generated and their display sizes are numerous or change with design iterations; build-time wins when your image set is curated and stable.
Cloudflare

Cloudflare is a global network that sells a CDN as one product on top of it, with DNS, security, edge compute and object storage on the same platform. Its defining commercial position is that bandwidth on the standard plans is not metered, which moves the pricing conversation from per-gigabyte rates to plan tiers and feature gating. For most web workloads that is a significant simplification, and the integration with its own object storage removes origin egress entirely.
Pros
- Bandwidth is not metered on the standard web plans, which removes the variable that dominates most CDN bills
- Same platform provides DNS, WAF, edge compute, object storage and image handling under one configuration and one identity model
- Programmable edge runtime allows arbitrary request and response logic rather than a fixed rule list
- Origin egress from its own object storage is not charged, which makes the origin side free as well
Cons
- Plan tiers gate meaningful capabilities, and the jump to the tier that includes what you need can be substantial
- Non-web traffic and very large file distribution fall outside the standard terms and require different products
- Strong platform gravity, since the cheapest configuration assumes DNS, storage and compute all live there too, and the resulting configuration surface becomes its own skill
Best for: Web applications that want predictable bandwidth costs and are willing to consolidate DNS, security and edge logic on one platform.
Pricing: Plan-tier subscription with unmetered bandwidth for standard web traffic on those plans, plus separate per-usage metering for edge compute, image transformations and some add-on products.
Fastly

Fastly is the developer-controlled end of the market. Its configuration is a real configuration language compiled and deployed to the edge, giving fine-grained control over caching, request routing and response synthesis, and it pioneered instant purging by surrogate key, which is the mechanism that makes CDN caching viable for genuinely dynamic content. The trade is that this control assumes you want it.
Pros
- Surrogate key purging with very fast propagation, which makes caching dynamic HTML practical rather than theoretical
- Edge configuration is a real language with version control and staged deploys, so cache logic is reviewable code
- Soft purge support lets you invalidate without sending a thundering herd at the origin
- Detailed real-time log streaming to your own destinations, which makes cache behaviour observable rather than inferred
Cons
- The configuration language is a genuine learning investment, misconfiguration at the edge is a production incident, and a team without appetite for it will underuse the product entirely
- Priced on metered bandwidth and requests, so high-volume delivery is a real line item rather than a flat fee
- Smaller network footprint than the largest providers, concentrated in well-connected locations by design
Best for: Engineering teams who want to cache dynamic content aggressively and are willing to write and own edge configuration to do it.
Pricing: Metered on bandwidth and requests by region, with committed-volume contracts and separate metering for edge compute and image optimization.
Bunny

Bunny is a CDN built around being inexpensive and comprehensible, with per-region bandwidth pricing, two network tiers at different price points, and a set of adjacent products covering video streaming, storage and image optimization. It has become a common answer for teams who found the large providers overpriced for straightforward asset delivery and overcomplicated for what they needed.
Pros
- Transparent per-region bandwidth pricing with no committed contract, so the bill is predictable and small at moderate volume
- Two network tiers let you trade a lower price for a smaller footprint where that is acceptable
- Integrated origin storage and a video delivery product, so an asset pipeline can live entirely on one platform
- Rule engine and edge scripting cover most real caching requirements without a full configuration language
Cons
- Smaller network and less peering depth than the largest providers, and less battle-tested at very large scale, which shows in some markets and on high-stakes launches
- Enterprise features such as advanced security, compliance attestations and contractual support are thinner
- Edge programmability is more limited than the providers built around a full runtime
Best for: Small and mid-sized teams delivering static assets, media or video who want low, predictable bandwidth costs without an enterprise contract.
Pricing: Metered per gigabyte of bandwidth with rates varying by region and by network tier, with separate metering for storage, video and image optimization.
AWS CloudFront
CloudFront is the CDN for content that already lives on AWS. Its argument is not that it is the fastest or cheapest, but that origin fetches from AWS services in the same account do not cross a billed boundary, that access control integrates with the platform identity model, and that it is configured with the same tooling as everything else you run there. Edge function support covers both lightweight header manipulation and heavier request processing.
Pros
- Origin transfer from AWS services is not billed as internet egress, which removes a meter that applies when using an external CDN
- Integrates with platform identity, certificate management, WAF and logging, so there is no second control plane
- Two tiers of edge function, one for cheap header-level logic and one for fuller request processing
- Origin access controls let a bucket stay private and be served only through the distribution
Cons
- Configuration is verbose, less expressive than the programmable providers beyond straightforward rules, and distribution changes propagate slowly enough to be annoying during development
- Pricing varies by geographic region of delivery and includes separate request charges, making forecasts harder than a flat rate
- Purge is slower and coarser than the providers that built around surrogate keys
Best for: Applications whose origin is already on AWS, where avoiding internet egress from the origin outweighs the configuration overhead.
Pricing: Metered per gigabyte of data transfer out with rates varying by delivery region, plus per-request charges and separate metering for edge functions, with committed-volume discounts available.
Akamai
Akamai is the oldest and largest network in the category, and it is sold and operated as an enterprise product. The network footprint, including deep deployment inside carrier networks, is genuinely unmatched, and the security and media delivery capabilities are mature. It is not a self-service product, and the evaluation process reflects that.
Pros
- The largest and most deeply embedded network, including presence inside carrier infrastructure that others reach over transit
- Mature media delivery, large file distribution and live streaming capabilities built over a long period
- Deep security product line covering application firewall, bot management and DDoS as an integrated offering
- Enterprise support model with named contacts and contractual commitments that regulated buyers require
Cons
- Procurement and onboarding are an enterprise sales process, not a signup form, which rules it out for small teams
- Configuration is powerful but complex, changes typically route through a professional services relationship, and developer self-service trails the providers built for that audience
- Pricing is contract-negotiated and opaque, making comparison against published rates difficult
Best for: Large organisations with contractual, compliance or carrier-reach requirements, and high-volume media delivery where network depth is the deciding factor.
Pricing: Negotiated enterprise contracts based on committed traffic volume, with products and support levels priced as part of the agreement rather than published rates.
KeyCDN
KeyCDN is a straightforward pull-zone CDN with usage-based pricing and no contract, aimed squarely at teams who want asset delivery configured in minutes. It does the core job, including origin shielding, real-time analytics, custom certificates and a rule set covering common caching needs, without trying to be a platform.
Pros
- Simple pull-zone model that takes minutes to configure and requires no platform commitment
- Pay-as-you-go pricing with no contract or minimum, including a credit-based prepayment model
- Origin shielding and real-time analytics included rather than gated behind a tier
- Small enough surface that the configuration is fully comprehensible in one sitting
Cons
- Limited edge programmability, so anything beyond rule-based caching has to happen at the origin
- Smaller network than the major providers, with correspondingly variable performance outside its strongest regions
- Fewer adjacent products and no enterprise compliance or support posture, so security, storage and compute come from elsewhere and regulated buyers are out
Best for: Small teams and side projects that need competent static asset delivery quickly without evaluating a platform.
Pricing: Usage-based per gigabyte of traffic with regional rate variation and a prepaid credit model, with no contract or minimum commitment.
Google Cloud CDN
Google Cloud CDN is the caching layer in front of Google Cloud load balancers, which shapes both its strengths and its constraints. It is not a standalone CDN you point at an arbitrary origin as a first-class use case; it is the delivery tier of the platform’s load balancing stack, and it inherits that stack’s global anycast front end and its configuration model.
Pros
- Uses the platform global load balancer, so a single anycast address fronts backends in multiple regions
- Origin fetches from platform storage and compute stay inside the provider network
- Cache modes and signed URL support are configured alongside the rest of the load balancer, with one identity model
- Negative caching and configurable cache keys cover the common tuning needs without custom code
Cons
- Effectively coupled to the platform load balancer, so it is an awkward fit for origins hosted elsewhere
- Edge programmability is limited compared with providers built around an edge runtime, and cache invalidation is coarser and slower than the surrogate-key providers
- Pricing includes cache egress, cache fill and request meters together, which complicates forecasting
Best for: Applications already served through Google Cloud load balancing that want caching configured as part of the same stack.
Pricing: Metered on cache egress by delivery region, on cache fill transfer from the origin, and on lookup requests, with the load balancer itself billed separately.
How to choose
Answer these in order.
Where are your users, measured rather than assumed? Segment real traffic by country and network. Weight everything that follows by those shares. A provider that is excellent in markets you do not serve is not excellent for you.
Is your content static or dynamic? Fingerprinted static assets cache trivially anywhere and the provider matters least. Dynamic HTML and API responses need surrogate keys, fast purging, request collapsing and expressive cache keys, which narrows the field sharply.
Do you need to run code at the edge? If your caching logic is a rule list, most providers work. If you need authentication, A/B assignment, request rewriting or response synthesis at the edge, you are choosing among the programmable providers and the decision overlaps with edge compute.
Where is your origin? Origin egress into your CDN is a real cost. If your origin is on a cloud that does not charge transfer to its own CDN, or on object storage that waives egress to a partner network, that arrangement may outweigh a lower published bandwidth rate elsewhere. The object storage decision and the CDN decision should be made together.
What is your object size distribution? Large media files make bandwidth the dominant meter. Many small responses make request count the dominant meter. Compare candidates on the meter your traffic actually loads, not on the headline rate.
Whatever you pick, do four things in week one: normalise the cache key to strip analytics parameters, add stale-while-revalidate and stale-if-error to your cacheable responses, switch static assets to content-hashed filenames so you never purge them, and set up surrogate key tagging for anything you will need to invalidate.
| Provider | Control model | Strongest when | Main risk |
|---|---|---|---|
| Cloudflare | Programmable runtime | Predictable bandwidth cost, consolidated platform | Feature gating by plan tier |
| Fastly | Edge configuration language | Caching dynamic content aggressively | Learning curve and metered volume |
| Bunny | Rules plus light scripting | Low-cost asset and media delivery | Network depth in some markets |
| AWS CloudFront | Rules plus edge functions | Origin already on AWS | Configuration verbosity, slow purge |
| Akamai | Enterprise configuration | Carrier reach and contractual requirements | Procurement weight and opacity |
| KeyCDN | Simple rules | Quick static delivery, no commitment | Limited programmability |
| Google Cloud CDN | Load balancer config | Already behind Google Cloud load balancing | Coupled to that load balancer |
| HTTP caching semantics (standard, not a product) | — | Always, it is the layer under all of these | No invalidation primitive at all |
Frequently asked questions
Does a CDN with more points of presence perform better?
Not reliably. More locations spread the same traffic thinner, which lowers the hit ratio at each one and sends more requests to your origin. What actually predicts performance is peering quality near your users, the provider’s tiered caching design, and whether your content is popular enough at each location to stay cached. Measure with real user data from your own traffic segmented by country, because that is the only version of the question that concerns you.
How do I improve cache hit ratio without changing provider?
Fix the cache key first. Strip query parameters that do not change the response, especially analytics and campaign tags. Remove unnecessary Vary headers, since each one multiplies the number of cached variants. Set explicit s-maxage rather than relying on defaults. Add stale-while-revalidate so refreshes happen in the background. These changes usually move hit ratio more than any provider switch, and they are portable if you do switch later.
Why is my purge not instant?
Because purging is not part of the caching protocol. There is no invalidation primitive in the specification, so every provider built its own, and propagating an instruction to every cache node in a global network takes real time that varies by architecture. The practical answer is to avoid needing purge: content-hash your static assets so new deploys publish new URLs, and reserve purge for HTML and API responses using tags rather than URL lists.
Should I do image optimization at the edge or at build time?
Build time when your image set is curated and the display sizes are stable, because you control the encoder settings and serving is pure cache hits. Edge transformation when images are user-generated or your layouts change often enough that pre-generating every variant is impractical. If you enable edge transformation, constrain the allowed parameters, because an open transformation API multiplies your cached object count and dilutes hit ratio across every location.
Can a CDN replace my origin entirely?
For static sites, effectively yes, which is what static site hosting platforms are. For dynamic applications, no, but the boundary has moved: with edge compute, a meaningful share of request handling can happen at the CDN layer, with only data access reaching an origin. That architecture is worth considering explicitly rather than arriving at by accident, and it is covered in the broader hosting platform comparison.
Related reading
- Best hosting platforms for developers — where the origin behind the CDN runs and how the two interact.
- Best edge compute platforms — running application logic at the same locations that serve your cache.
- Best S3 alternatives and object storage providers — the origin side, and why egress to your CDN is the meter that matters.
- Best DNS providers for developers — the resolution step that happens before any CDN edge is reached.
- Best RUM tools — measuring where your users actually are and what they actually experience.
- Best static site hosting platforms — the case where the CDN and the host are the same product.