What are the Pricing Tiers for Fastly CDN?

Fastly CDN pricing comes in two main forms: pay-as-you-go (usage-based, starting at $50/month) and flat-rate packages (starting at $1,500/month). The packages bundle bandwidth, requests, and features like TLS, WebSockets, and image optimization into predictable monthly prices. 

‍

Larger tiers like Advantage and Ultimate require you to contact sales. For edge computing and security features like Fastly’s WAF, separate tiers and add-ons apply.

‍

If you’re trying to figure out what Fastly CDN will actually cost you, here’s the whole deal:

‍

Usage-Based Pricing (aka Pay-As-You-Go)

‍

This is Fastly’s entry-level pricing model. It’s what you get if you just sign up, add a credit card, and start pushing traffic.

‍

• $50 monthly minimum: Even if you use less than $50 worth of bandwidth/requests, they’ll still charge you $50. This is the base commitment for paid usage accounts.
• Two cost components:
  
  • Bandwidth (per GB) – based on where your users are located.
  • Requests (per 10,000) – also regional.

‍

Here’s what that looks like:

‍

Bandwidth Pricing (per GB)

‍

Request Pricing (per 10K requests)

‍

So if you’re delivering assets to Europe and the US, the combo of $0.12/GB and $0.0075/10k requests isn’t too bad. But if you’re global, especially heavy in India or South Korea; this gets expensive fast.

‍

This model works well for small-scale or bursty projects. But once you’re consistently pushing a lot of traffic, flat-rate pricing becomes the smarter move.

‍

Flat-Rate Packages (Predictable Monthly Billing)

‍

This is where Fastly’s pricing becomes easier to manage, but also harder to calculate unless you talk to sales. They introduced flat-rate packages to give customers more predictability. 

‍

I’ve used both Starter and Advantage packages for client projects, and here’s how they break down.

‍

Network Services Packages (CDN)

‍

These bundles include bandwidth, requests, TLS, image optimization, and more. And unlike many CDNs, 

Fastly includes a lot of power at each tier.

‍

‍

These tiers include mTLS, instant purging, multiple services, and full-featured TLS, no extra fees for those. I’ve never had to manually pay for purges or image optimization once I moved to these.

‍

This is ideal when you’re scaling and don’t want to track every GB or API call. Just make sure you’re not underutilizing your tier. If your usage is 30% of a Starter package, you're likely overpaying.

‍

Free Tier (Yes, It’s Legit)

‍

If you're still prototyping or running a super-light service, Fastly gives you $50/month in recurring credit, no expiration.

‍

• Covers both CDN and Compute
• Includes 2 TLS domains (Fastly-managed)
• No caps on redirects, caching rules, or purging
• Zero request throttling
• Not a one-off trial, this is recurring every month

‍

If your usage stays under that $50 value, you’ll likely never see a bill.

‍

Fastly WAF Pricing (Next-Gen Web Application Firewall)

‍

When someone asks about Fastly WAF pricing, they’re talking about Fastly’s Next-Gen WAF, which comes from Signal Sciences. It’s powerful, flexible, and priced as a separate product.

‍

Like the CDN tiers, it comes in flat-rate bundles:

‍

‍

You also get:

• OWASP protection
• Custom rate limiting
• Penalty boxes
• Bot detection (add-on)

‍

For most startups, the Starter plan is overkill unless you're already handling sensitive user data. But if you’re facing real threats or running public APIs - it’s very worth it. I've seen companies go from massive attack exposure to airtight visibility within days of setting this up.

‍

Add-Ons and Optional Services

‍

Some things are included depending on your package; others are separate charges. Here’s what stood out to me:

‍

TLS Domains

‍

• 5 are free in paid usage accounts
• Extra domains: $20/month
• Commercial CA certs: $275/month per domain
• mTLS: Unlimited in most packages, or $500/month if standalone

‍

Fanout (Real-Time Messaging)

‍

• $5 per million messages
• $2.50 per million connection minutes
• Good for WebSocket or SSE-style messaging

‍

Compute@Edge (Edge Functions)

‍

• $0.50 per million requests
• $0.000035 per GB-second (RAM x time)
• vCPU time beyond 20ms/request: $0.000045 per vCPU-second

‍

You get a $50/month free credit for Compute too, so you can run small edge functions for free.

‍

Observability Packages (Monitoring, Logs, Alerts)

‍

This is a newer pricing category Fastly introduced. If you want to go beyond basic real-time stats, here’s how it works:

‍

‍

You don’t need this unless you’re running mission-critical apps with high uptime expectations. 

‍

Fastly Object Store

‍

This one’s great if you don’t want to deal with S3 egress charges.

‍

• First 5 GB: Free
• $0.020/GB up to 50 TB
• $0.018/GB for 50–500 TB
• Reads: $0.0004 per 1,000
• Writes: $0.0025 per 1,000

‍

No egress fees. I’ve used this with Compute@Edge to serve assets and avoid paying AWS for pulling images out every time.

‍

Making a Bill Model for Fastly

‍

Here’s how you can draft a “bill of materials” when sizing Fastly for a new project. 

‍

Plug numbers into the variables and you should get an accurate cost estimate; leave them symbolic and you can see which term dominates. I split it into five blocks:

‍

1. Core pay-as-you-go CDN
2. TLS add-ons
3. Compute @ Edge
4. Real-time messaging (Fanout)
5. Object Store

‍

(If you buy a flat-rate package, most of Block 1 and the TLS fees disappear and are replaced by a constant: $1 500, $6 000, or “Adv/Ult via sales.” The algebra below shows where that substitution happens.)

‍

1 ▸ Core PAYG CDN

‍

‍

Let

‍

• b₁, b₂, b₃ = GB delivered this month in the three region groups
• r₁, r₂, r₃ = HTTP/HTTPS requests this month (in units of 10 000) in the same three groups

‍

Then

‍

BandwidthCost =

       min(b₁, 10 240) * c₁  +  max(b₁−10 240, 0) * c₂

     + min(b₂, 10 240) * c₃  +  max(b₂−10 240, 0) * c₄

     + min(b₃, 10 240) * c₅  +  max(b₃−10 240, 0) * c₆

‍

RequestCost =  r₁·p₁  +  r₂·p₂  +  r₃·p₃

‍

CDN_PAYG = max(BandwidthCost + RequestCost, $50)

‍

(that max enforces Fastly’s $50 monthly minimum.)

‍

2 ▸ TLS / mTLS Add-Ons

‍

Let

• d₁ = extra Fastly-managed TLS domains beyond the free allowance (2 on Free Tier, 5 on PAYG, package counts vary).
• d₂ = Fastly-managed commercial-CA domains.
• d₃ = extra BYO-cert (self-managed) TLS domains beyond the 5 included in PAYG.
• m = 1 if you buy the “unlimited mTLS” option outside a package, else 0.

‍

TLSCost = (d₁ + d₃) · $20  +  d₂ · $275  +  m · $500

‍

(Packages already bundle unlimited mTLS and a bigger block of domains, so in that case set TLSCost = 0.)

‍

3 ▸ Compute @ Edge (Usage Plan)

‍

Let

• q = millions of function invocations
• g = total GB-seconds of memory time
• v = vCPU-seconds beyond the free 20 ms/window

‍

ComputeCost =  q · $0.50  +  g · 0.000035  +  v · 0.000045

‍

Remember your first $50 of Compute is covered by the same recurring credit used for CDN if you’re on the Free Tier.

‍

4 ▸ Fanout (Real-Time Messaging)

‍

Let

• m₁ = millions of messages
• m₂ = millions of client-connection minutes

‍

FanoutCost =  m₁ · $5  +  m₂ · $2.50

‍

5 ▸ Object Store

‍

Let

• s₁, s₂, s₃ = GB-months in the three storage tiers
• w = thousands of Class-A ops (PUT/LIST) after the first 1 k
• r = thousands of Class-B ops (GET/HEAD) after the first 10 k

‍

StorageCost =  s₁ · 0.020  +  s₂ · 0.018  +  s₃ · 0.017

‍

OpsCost     =  w · 0.0025 + r · 0.0004

‍

ObjectStore = StorageCost + OpsCost

‍

Putting It All Together

‍

Total_PAYG =

      CDN_PAYG

    + TLSCost

    + ComputeCost

    + FanoutCost

    + ObjectStore

‍

Switching to a Package

‍

For any Network Services package, swap the entire CDN_PAYG + TLSCost block for the flat fee P:

‍

Total_Package =

      P                        # 1 500, 6 000, or sales-quoted

‍

    + ComputeCost              # unless you also buy a Compute package

    + FanoutCost

    + ObjectStore

‍

(If you choose a Compute package the ComputeCost term also collapses to its own flat fee, and Observability or WAF packages do the same for their domains. The algebra stays additive, only the fixed constants change.)

‍

That’s the whole pricing story in algebra: every Fastly line item is just a rate × volume term, except for the guard-clause max(_, 50) and any package constants you drop in to flatten the curve.

‍