---
title: "Fastly Object Storage: Egress Costs and S3 Compatibility"
description: "See how Fastly Object Storage prices capacity, requests, and zero-egress delivery, where S3 compatibility stops, and what to test before you migrate data."
url: https://www.zerobuffer.io/blogs/fastly-object-storage
date_published: 2026-07-20
date_modified: 2026-07-20
topic: "S3-Compatible Object Storage (C2)"
keywords: ["fastly object storage"]
word_count: 2488
author: "Sahil Asopa"
author_url: https://www.zerobuffer.io/authors/sahil-asopa
author_profiles: ["https://www.linkedin.com/in/sahilasopa/","https://github.com/sahilasopa"]
publisher: ZeroBuffer
license: © 2026 Apexnova Private Limited
---
![Distributed object storage connected to edge delivery through an S3-compatible data path](https://www.zerobuffer.io/blogs/fastly-object-storage/thumbnail.png)

# Fastly Object Storage: Egress Costs and S3 Compatibility

You can move a media library to cheaper storage and still lose the savings through request charges, origin transfer, or an API mismatch. Fastly Object Storage addresses that problem with S3-compatible access and zero-fee transfer into Fastly’s own delivery stack—but the billing boundary matters.

**What is Fastly Object Storage?** Fastly Object Storage is a regional object-storage service for large, unstructured data that exposes an Amazon S3-compatible API and integrates with Fastly CDN and Compute. Its “zero egress” benefit applies only when data moves from storage through Fastly’s own network to those services; storage capacity, API operations, and CDN delivery remain separate cost lines.

That conditional is the whole product. Zero egress into your own CDN is a real saving and a real coupling: the price advantage exists exactly as long as Fastly also serves the traffic, which means the storage decision quietly becomes the delivery decision. Worth knowing before you move a library, not after.

We build a competing service, so read this accordingly — [ZeroBuffer](/pricing) offers S3-compatible storage at $0.01/GB per month per replica, half Fastly's entry rate, with delivery priced separately at a flat $0.0049/GB. The pricing and compatibility facts below are drawn from Fastly's own documentation and are accurate as published; the evaluation framework is one we would expect you to point back at us.

This guide breaks down the public pricing, shows where S3 compatibility helps and stops, and gives you a practical evaluation plan. If you need the category-level definition and a migration playbook, start with our [S3-compatible storage guide](/blogs/s3-compatible-storage).

## Fastly Object Storage at a glance

Fastly positions the service as storage for active, high-throughput objects such as video, images, application assets, software packages, datasets, and user-generated content. The product page advertises 11 nines of data durability and a familiar S3 API, while the delivery path is built around Fastly CDN and Compute rather than direct public object serving at scale. [Fastly’s current product overview](https://www.fastly.com/products/storage) describes that integrated storage-to-edge model.

The basic architecture has four parts:

1. Create a bucket in a specific Fastly Object Storage region.
2. Create an access key with the required scope and bucket access.
3. Send S3-compatible requests to that region’s Fastly endpoint.
4. Configure Fastly CDN or Compute to retrieve private objects and serve them to users.

Fastly currently documents nine storage endpoints across Oregon, Texas, Virginia, London, Paris, Amsterdam, Milan, Tokyo, and Sydney. These are Fastly regions, not AWS regions, so the endpoint, configured region, and region inside the AWS Signature Version 4 credential scope must agree. Otherwise, a client can return `InvalidRequest` before your workload reaches an object operation. See Fastly’s [regional endpoint and request-signing instructions](https://www.fastly.com/documentation/guides/platform/object-storage/working-with-object-storage/).

That makes the service attractive when Fastly already owns your content-delivery or edge-compute path. It is less automatic when storage must feed several CDNs, applications expect AWS-specific control-plane services, or users need high-volume access through the storage endpoint itself.

## Fastly Object Storage pricing and egress costs

Fastly publishes separate prices for stored capacity and two classes of API operations. The first 5 GB, 1,000 Class A operations, and 10,000 Class B operations are free; usage above those allowances is billed by tier.

| Cost component | Public list price after free allowance |
|---|---:|
| Storage from 5 GB to 50 TB | $0.020 per GB-month |
| Storage from 50 TB to 500 TB | $0.018 per GB-month |
| Storage beyond 500 TB | $0.017 per GB-month |
| Class A operations | $0.0025 per 1,000 |
| Class B operations | $0.0004 per 1,000 |
| Storage-to-Fastly CDN or Compute transfer | $0 egress fee |

These are public usage rates shown on [Fastly’s pricing page](https://www.fastly.com/pricing). Volume contracts, support, CDN traffic, Compute, image optimization, and other services can change the complete invoice, so treat this table as a starting point rather than a quote.

For a like-for-like reference point, the storage row is where the gap is widest:

| | Fastly Object Storage | ZeroBuffer |
|---|---:|---:|
| Storage (entry tier) | $0.020 / GB-month | **$0.010 / GB-month per replica** |
| Delivery | Regional CDN rates, $0.12–$0.28 / GB | **$0.0049 / GB, every region** |
| Storage→CDN transfer | $0 into Fastly only | $0 into ZeroBuffer only |

Both services zero-rate transfer into their own delivery network, so that line is a wash — the difference is what the two halves cost once you add them together, and whether the delivery rate moves when your audience does.

### What “zero egress” includes

Fastly defines zero egress narrowly and usefully: it does not charge a transfer or retrieval fee when Object Storage traffic stays within the Fastly network and is routed to Fastly CDN or Compute. It does **not** mean the entire path from bucket to end user is free. The CDN still has its own regional bandwidth and request pricing, and Compute has separate usage meters.

This distinction prevents a common comparison error. Putting $0 in an “egress” cell and comparing it with another provider’s per-GB delivery rate mixes origin transfer with end-user delivery. Model these layers separately:

```text
monthly cost = stored capacity
             + Class A operations
             + Class B operations
             + CDN or Compute usage
             + support and optional services
             + migration egress from the old provider
```

At public list rates, storing 10,000 GB for a full month costs about $199.90 after the 5 GB free allowance. One million billable Class A operations adds about $2.50, while 100 million Class B operations adds about $40 after its free allowance. The delivery bill depends on which Fastly service handles the object and where the user traffic lands.

### The migration bill is a separate event

Fastly does not control what your current storage provider charges to export data. A 100 TB library can therefore generate a one-time source-egress bill even if subsequent storage-to-Fastly delivery incurs no Fastly Object Storage egress fee.

Fastly’s [On-Demand Migration feature](https://www.fastly.com/documentation/guides/platform/object-storage/on-demand-migration-for-object-storage/) can move only the working set: on the first request, Fastly retrieves an absent object from a source URL, serves it, and asynchronously copies it into the destination bucket. This reduces unnecessary copying, but the documented path does not migrate objects larger than 250 MB, and the source still needs to answer with `200 OK` or `206 Partial Content`.

## Where Fastly Object Storage S3 compatibility ends

“S3-compatible” means existing S3-aware clients can use a familiar request model. It does not mean Fastly reproduces every Amazon S3 feature, IAM policy, endpoint behavior, or managed AWS integration.

Fastly documents use of the AWS CLI with custom regional endpoints, and common data-plane calls can be made through the S3-compatible API. That is valuable portability: uploaders, media pipelines, backup tools, and SDK clients may only need new credentials, an endpoint, and a signing region.

The safe interpretation is operation-level compatibility:

| Area | What is portable | What to verify or redesign |
|---|---|---|
| Object data plane | Common bucket and object requests through S3 clients | Exact supported operations, headers, checksums, errors, and retries |
| Authentication | Access-key and secret-key request signing | Key scopes, rotation, bucket limits, and secret handling |
| Endpoints | AWS CLI and SDK custom endpoints | Fastly region names, SigV4 scope, addressing style, and redirects |
| Large objects | Multipart upload | Part-size rules, 120-second upload timeout, abort and resume behavior |
| Access control | Read-only and read/write object permissions | No assumption of AWS IAM API or policy parity |
| Delivery | Private origin for Fastly CDN or Compute | Direct-endpoint throughput, public access pattern, and multi-CDN design |
| Automation | S3 tooling for supported data operations | Provider-specific bucket, key, billing, and service configuration APIs |

Fastly’s [access-key API](https://www.fastly.com/documentation/reference/api/services/resources/object-storage-access-keys/) currently offers administrative and object-only read/write variants, and object-only keys can be limited to selected buckets. Those controls are useful, but the [Fastly Terraform guide](https://www.fastly.com/documentation/guides/integrations/non-fastly-services/developer-guide-terraform/) explicitly notes that access-key and bucket-permission management is Fastly-specific rather than compatible with the AWS IAM API.

### Documented limits that can affect production

Fastly’s current Object Storage documentation lists boundaries that should be in your acceptance suite:

- Up to 100 buckets per region, with no documented capacity limit per bucket.
- Object keys up to 1,024 bytes and objects up to 5 TB.
- Single uploads up to 5 GB; larger transfers require multipart upload.
- Multipart uploads with at most 10,000 parts and a 5 MB minimum for every part except the last.
- Uploads must finish within 120 seconds or return a `408 Request Timeout`.
- Direct access through the public S3-compatible endpoints is limited to roughly 150 Mbps and 100 requests per second per bucket; access from inside Fastly’s network is not subject to those two limits.

Review the live [Fastly Object Storage limitations](https://www.fastly.com/documentation/guides/platform/object-storage/about-object-storage/) before a purchase because service limits can change. In particular, test large media uploads with the exact part size, concurrency, retry policy, and network path you plan to run in production.

### S3 tools can connect without making the platform identical to S3

The Fastly quick start configures an AWS CLI profile with a Fastly endpoint URL, region, access key, and secret key. That proves a useful interface contract, not feature completeness. Fastly’s own guide warns that credentials written into the standard AWS credentials file are plaintext and recommends environment variables or external credential tooling for production. See the [Object Storage quick start](https://www.fastly.com/documentation/guides/platform/object-storage/object-storage-quick-start/).

Build a call inventory from real application logs before migration. If the workload uses presigned uploads, byte-range reads, conditional requests, custom metadata, multipart copy, versioning, retention, lifecycle rules, CORS, or event notifications, verify each behavior instead of inferring it from a successful `aws s3 cp`.

## Who should choose Fastly Object Storage?

Fastly is a strong fit when storage is an origin for an existing Fastly CDN or Compute workload and the team wants one vendor for the internal data path. Media libraries, software artifacts, application assets, and datasets with repeated edge reads can benefit because origin transfer into those Fastly services does not create an additional egress line.

It can also fit a team that wants familiar S3 tooling without depending on AWS for the object data plane. Regional placement across North America, Europe, Japan, and Australia provides useful options, but residency, replication, recovery, and failover still need workload-specific review.

Look harder at alternatives when:

- Storage must serve multiple CDNs or non-Fastly compute platforms.
- Your architecture depends on AWS IAM, KMS, S3 events, Object Lock, lifecycle behavior, or another feature not confirmed in Fastly’s supported-operation list.
- Direct storage-endpoint throughput must exceed the documented public limits.
- You need a region outside the current storage footprint.
- You want storage and delivery bills to remain portable and independently replaceable.

If your workload needs S3-compatible storage but you want storage and CDN pricing to stay independently visible, [ZeroBuffer](/pricing) prices storage at $0.01 per GB-month per replica and global CDN delivery at a flat $0.0049 per GB.

"Zero egress" into a single vendor's CDN is a real benefit until it becomes the reason you cannot leave. Two visible numbers make the storage-to-viewer path priceable on its own terms, and priceable against anyone else. The same rule still applies in both directions: verify required S3 operations, resilience, and measured delivery performance before moving production data.

For a deeper named-provider migration example, see the [IDrive E2 alternative guide](/blogs/idrive-e2-alternative). It covers checksum validation, dual-running, and rollback without repeating those mechanics here.

![Storage and delivery candidates passing cost, API, performance, and migration test gates](https://www.zerobuffer.io/blogs/fastly-object-storage/mid-article.png)

## How to evaluate a Fastly Object Storage alternative

Do not start with a generic feature grid. Start with the traffic path and the operations your workload actually performs, then run the same evidence pack against Fastly and every alternative.

The realistic shortlist is short. **Cloudflare R2** if you are already on Cloudflare and want the same zero-egress-into-our-own-CDN bargain from a different vendor. **Backblaze B2** for cold or archival data where reads are rare. **ZeroBuffer** when the objects are read often and delivery dominates the bill — storage at $0.01/GB per month per replica and delivery at a flat $0.0049/GB in every region, priced as two visible numbers rather than one bundled rate. Each is a different bet about where your money goes, which is exactly what the modelling below is meant to settle.

### 1. Normalize the full monthly bill

Use the same decimal or binary unit convention for every candidate. Include average and peak stored volume, replication, writes, reads, lists, deletes, CDN requests, end-user delivery by region, support, and optional processing.

Model three scenarios:

- A normal month with the expected cache-hit ratio.
- A launch or traffic spike with lower cache efficiency.
- A recovery or migration month with unusually high reads and outbound transfer.

For Fastly, keep storage-to-Fastly transfer at $0 only when the documented internal path applies. Put CDN or Compute usage on its own row.

### 2. Test the exact S3 call set

Create a disposable bucket and least-privilege key. Run the production SDK and CLI versions against representative small objects, large multipart files, metadata, range reads, listings, deletes, and interrupted transfers.

Record request IDs, status codes, error bodies, retry counts, p50 and p95 latency, and sustained throughput. A client connecting successfully is not enough; the test passes only when every required operation and failure mode behaves within your threshold.

### 3. Benchmark both the private-origin and direct paths

If Fastly CDN or Compute will serve objects, benchmark through that service with realistic cache-control headers, ranges, purges, and miss traffic. Separately test direct S3-compatible access for administrative jobs, ingest, and any application reads that bypass the edge.

This reveals which limit belongs to storage, origin access, cache behavior, or final delivery. It also makes a multi-CDN comparison fair: every candidate should be measured through the path users will actually take.

### 4. Rehearse migration and rollback

Inventory object counts, bytes, metadata, checksums, largest objects, multipart uploads, active writers, and dependent services. Copy a representative prefix, validate it, shift a small read cohort, and define the exact errors or latency thresholds that trigger rollback.

If on-demand migration is part of the design, split out objects above Fastly’s documented 250 MB limit and estimate source egress for every first fetch. Keep the old origin readable until a final delta copy, checksum sampling, application validation, and recovery test have passed.

### 5. Confirm the operational contract

Before signing, document durability and availability commitments, incident support, data residency, delete and recovery behavior, key rotation, audit evidence, usage alerts, export mechanics, and any negotiated limits. Public product language answers what the service is; the operational contract answers how your team will run it during a failure.

## Frequently asked questions

### Does Fastly have object storage?

Yes. Fastly Object Storage is a regional, S3-compatible service designed to store large unstructured objects and work with Fastly CDN and Compute.

### Is Fastly Object Storage S3 compatible?

Yes, for the S3-compatible operations Fastly documents. You can use tools such as the AWS CLI with Fastly endpoints and credentials, but you should not assume parity with every Amazon S3 feature or the AWS IAM control plane.

### Does Fastly Object Storage charge egress fees?

Fastly says it charges no egress fee when Object Storage data is routed within Fastly’s network to its CDN or Compute layers. CDN delivery, Compute usage, storage capacity, API operations, and export fees charged by a previous provider are separate costs.

### How much does Fastly Object Storage cost?

After a 5 GB free allowance, public storage pricing begins at $0.02 per GB-month, falls to $0.018 above 50 TB, and reaches $0.017 beyond 500 TB. Class A and Class B operations have separate prices after their free allowances.

### Can I use the AWS CLI with Fastly Object Storage?

Yes. Configure a profile with the matching Fastly endpoint and region plus a Fastly Object Storage access key and secret, then test the commands your workload needs.

### Can Fastly Object Storage serve files directly?

The S3-compatible endpoint can retrieve objects, but Fastly documents throughput and request-rate limits for that public path. The intended high-volume delivery architecture connects a private bucket to Fastly CDN or Compute.

### Is there a cheaper alternative to Fastly Object Storage?

On the storage line alone, yes: Backblaze B2 and ZeroBuffer both list rates below Fastly's $0.020/GB-month entry tier, with ZeroBuffer at $0.010/GB-month per replica. But storage is usually the smaller half of the bill for media. The comparison that decides it is storage plus delivery together — Fastly's regional CDN rates run $0.12–$0.28/GB, against ZeroBuffer's flat $0.0049/GB worldwide. Model both rows for your own read volume before treating any single rate as cheaper.

## Choose the storage-to-user path, not one price cell

Fastly Object Storage is a reasonable choice with a narrow condition attached: it is compelling when your delivery stack already lives on Fastly and intends to stay there. The zero-egress benefit is real, and it is also the thing that makes the storage decision hard to reverse later.

So price the whole path, not the cell that says $0. Model storage, requests, delivery, and migration separately; validate every required S3 behavior; benchmark both the origin and direct access; and keep a rollback route until the destination proves itself under real traffic.

If your objects are read far more often than they are written, the delivery row will dominate that model — and that is the row where a regional rate card costs you most. [ZeroBuffer prices the two halves separately and visibly](/pricing): $0.01/GB per month per replica for S3-compatible NVMe storage, $0.0049/GB flat for delivery to any region. Free to start with no card, so you can run the same call-set test above against it before moving a single production object.