Storage: zero egress fees explained

The provider delivers 20-faster response times than Amazon S3 at the 95th percentile, proving that zero egress fees do not require sacrificing speed. The era of paying premiums for data extraction is ending, replaced by architectures where global data storage operates on a utility model free from punitive transfer costs.

Readers will examine the specific mechanics of zero-egress cloud architectures and how they use serverless storage to reduce operational overhead. We analyze the technical underpinnings of R2 architecture and its smooth Cloudflare Workers integration, which allows compute to occur directly adjacent to stored data. This proximity eliminates the latency penalties historically associated with object storage retrieval across distributed networks.

The discussion extends to practical data migration storage techniques, including progressive data migration paths from legacy systems. You will learn to implement an Iceberg data catalog for querying structured data and understand how to store AI datasets without transfer fees. By adopting an S3 compatible API, organizations can ensure their cloud storage remains portable and cost-effective, avoiding the traps of proprietary ecosystems while accessing workers API access for real-time processing.

The provider operates as a globally distributed object storage service built on the same infrastructure Cloudflare uses, which powers a significant portion of the Internet. The service distinguishes itself through an egress-free storage model, charging $0 for data transfer out to the public internet. Developers access buckets using a standard S3 compatible API, allowing existing tools and SDKs to function without code changes. Such compatibility ensures that applications designed for other providers can migrate with minimal friction. Removing egress fees fundamentally alters the economics of data-heavy workloads like media streaming or AI training sets. R2 excels at delivery and standard storage yet currently lacks the extensive array of specialized storage classes and server-side compute options available elsewhere. Organizations must evaluate whether their workflows require deep archival tiers or if the cost savings of zero egress fees outweigh the need for niche platform services. This architecture suits teams prioritizing data accessibility and budget control over proprietary vendor lock-in features.

Building Global Data Systems with Workers and R2 Buckets

Deploying serverless storage across a global network enables stateful applications to process data adjacent to users. This architecture uses Cloudflare Workers integration to execute logic at the edge while persisting results directly to local buckets. Eliminating egress fees fundamentally alters how architects design log aggregation pipelines, favoring high-volume telemetry retention over aggressive sampling. Traditional systems often discard data to save money; this model retains everything for later analysis. This pattern is particularly effective for media streaming backends where origin shielding reduces load on primary assets. Global data storage becomes economically viable when retrieval costs do not penalize access frequency.

R2 Versus Amazon S3: Egress Fees and Latency

The provider delivers zero egress fees to remove financial penalties on data retrieval that constrain traditional architectures. Some legacy tools may need configuration updates to fully exploit edge proximity benefits. Network operators must weigh these performance gains against the operational effort of refactoring client-side retry logic. This architecture is well-suited for AI training datasets where repeated reads increases transfer costs. Eliminating egress charges fundamentally changes the total cost of ownership for media streaming and backup archives. Teams can now iterate on large models without monitoring data exit points or negotiating transit contracts. This shift enables cost-effective scaling that was previously impossible under per-byte billing models. Strategic adoption depends on aligning application read patterns with the distributed nature of the storage layer. Organizations should audit current egress spend to quantify potential savings before committing to migration. The absence of transfer fees allows for more aggressive data replication strategies across global regions. Such flexibility supports strong disaster recovery postures without doubling storage expenditure. Performance consistency ensures user experiences remain smooth even during traffic spikes. Engineers gain predictable pricing while maintaining the throughput required for modern data-intensive applications.

Inside R2 Architecture and S3-Compatible Data Flow

S3-Compatible API Endpoints and Boto3 Configuration Mechanics

R2 exposes S3-compatible APIs that allow teams to apply existing tools without rewriting code. Developers switch the Boto3 `endpoint_url` parameter to `{your-account-id}.r2.cloudflarestorage.com` to route traffic. This configuration preserves standard SDK workflows while bypassing traditional egress constraints.

The Python example demonstrates connecting to this specific endpoint URL to initialize the client session. Such direct compatibility means organizations can query structured data in R2 using familiar libraries like DuckDB. The data migration storage process avoids complex gateway layers often required for hybrid clouds. Precise configuration of the custom URL remains necessary for successful routing.

Integrating with Cloudflare Workers enables serverless compute to access this storage directly via the Workers API. Applications achieve low-latency access without provisioning separate compute instances near the data. This pattern proves particularly effective for AI datasets where transfer fees typically erode project margins. Teams gain flexibility but must manage credential scope carefully across the new boundary.

Querying Iceberg Data Catalogs with DuckDB and Spark

Teams access Iceberg data catalogs by attaching R2 buckets directly to SQL engines like DuckDB and Spark. This workflow bypasses complex ETL pipelines, allowing analysts to query structured tables such as `prod_analytics_data.default.user_events` using standard SQL syntax.

Developers integrate these tools with the Workers API access model to build serverless analytics functions that scale on demand. Unlike traditional setups requiring data movement, this architecture supports progressive data migration where queries hit the source directly until performance thresholds dictate otherwise. Local compute resources compete against network latency. Unoptimized scans across the network introduce lag despite cheap compute costs.

Data portability remains the strongest architectural guarantee, ensuring S3 compatible storage investments do not result in vendor lock-in. Users switch query engines or move workloads without rewriting application logic or reformatting underlying parquet files. This approach benefits AI startups needing to train models on massive datasets without incurring transfer penalties. The zero egress fee model fundamentally changes how organizations approach cloud storage economics for analytics workloads. Operators treat object storage as a compute-native layer rather than a static archive. This shift enables real-time dashboarding directly on cold data tiers.

Progressive Migration Strategy Using R2 as a Proxy Layer

This progressive data migration pattern captures zero egress fees immediately for active datasets while leaving cold data untouched on the origin. The mechanism relies on Cloudflare Workers integration to intercept `GET` requests, fetch missing objects from the legacy endpoint, write them to the new bucket, and return the payload to the client. The migration timeline correlates with user traffic patterns, as objects are copied only when accessed. Immediate cost savings conflict with the unpredictability of origin load. A sudden spike in historical data access could throttle the legacy system before the proxy cache warms up. This approach fits workloads where a small fraction of files generates most requests. The method suits AI training pipelines where dataset subsets are iteratively refined. The strategy transforms a risky big-bang cutover into a gradual, traffic-driven evolution.

R2 Versus S3 Performance and Cost Trade-offs

R2 Class A and B Operation Pricing Mechanics

This pricing tier covers write, list, and delete actions that modify the object storage namespace state. This asymmetric cost model fundamentally shifts economic incentives for read-heavy workloads like media streaming. Read optimization arrives alongside higher write operation fees compared to some competitors. Organizations should model list operation frequency specifically when migrating AI training datasets. Enterprises must evaluate whether their access patterns favor the generous read allowances or suffer from frequent metadata updates. Understanding these distinct cloud storage mechanics prevents unexpected billing shocks during scale-out phases.

Character.AI Multi-Cloud Training Data Architecture

This deployment model stores massive AI datasets in a single namespace to eliminate egress fees when compute clusters on competing clouds access the data. The approach directly addresses the question of whether to use R2 for AI data by prioritizing data gravity over compute locality.

Operators gain use in price negotiations by decoupling storage from compute resources. The architectural constraint requires careful selection of bucket regions to minimize read latency during model training epochs. Experts recommend this topology for organizations seeking to avoid cloud vendor lock-in while maintaining high throughput for machine learning pipelines. The strategy transforms storage from a fixed cost center into a flexible asset accessible by any compute environment.

R2 Latency Advantages Versus S3 High-Throughput Gaps

Independent benchmarks record R2 latency at 171.58 ms, a figure six times higher than Amazon S3 yet competitive for read-once workloads. This disparity highlights a tension between raw access speed and architectural flexibility in cloud storage design. S3 dominates high-frequency transactional scenarios. R2 targets workloads where data gravity outweighs nanosecond precision.

High-throughput requirements expose a different performance profile entirely. Such gaps suggest that AI/ML training pipelines requiring massive parallel reads may face bottlenecks unless the architecture buffers data locally before processing. Operators must distinguish between latency-sensitive interactive applications and batch-oriented throughput tasks when selecting object storage.

The strategic advantage lies not in beating S3 on raw speed but in eliminating egress fees that penalize data movement across cloud boundaries. This economic shift enables multi-cloud architectures where compute can spin up near the data without financial penalty, a capability necessary for modern data migration strategies. Choosing infrequent access storage models becomes a deliberate cost consideration favoring budget certainty over peak performance.

Fit Use Case : : : : Latency 171.58 ms 28 ms Batch processing, archives Throughput 4

Migrating Workloads with Progressive Strategies

Proxy Migration Mechanics for Zero-Downtime Shifts

S3-compatible object storage supports progressive migration by sitting in front of legacy providers and copying objects as they are requested. This proxy pattern eliminates bulk transfer risks while enabling immediate access to zero egress fees for new data flows. Operators avoid the downtime associated with large-scale data moves by handling requests dynamically at the edge.

1. Configure the application to point to the new bucket endpoint instead of the legacy storage URL.
2. Deploy a worker script that checks object existence and fetches missing data from the origin on demand.
3. Write the fetched object to the new storage asynchronously to cache it for future requests. 4.

Operators initiate analytics workflows by installing the Iceberg extension to enable table format compatibility within DuckDB. Modern data catalogs provide native support for Apache Iceberg, allowing clients to query structured datasets without moving data from object storage. This architecture uses the S3-compatible API to read Parquet files directly from the bucket while maintaining metadata consistency through the catalog service.

1. Install the Iceberg extension using the DuckDB CLI to enable metadata handling capabilities.
2. Create a secret containing access credentials to authorize bucket operations securely.
3. Attach the data catalog by specifying the account ID and bucket name in the configuration. 4.

Correct endpoint formatting prevents authentication failures during migration to S3-compatible storage. Operators must configure the `endpoint_url` parameter in Boto3 to match the specific bucket address rather than the default AWS global string. This distinction ensures the SDK routes requests to the intended object storage location without relying on implicit assumptions.

1. Define the bucket endpoint explicitly in the client configuration to override default routing logic.
2. Set the `region_name` to `auto` or a placeholder value, as S3-compatible APIs often ignore traditional region constraints.
3. Verify operation class awareness to distinguish between standard writes and Infrequent Access reads.

Misclassifying requests can trigger unexpected billing, particularly since costs vary by operation class and provider tier. Developers frequently overlook this distinction when porting legacy scripts that assume a single flat rate for all API calls. Validating these parameters against reproducible benchmarks before scaling production traffic is critical. Properly configured clients avoid these pitfalls by enforcing strict separation between compute logic and storage location details.

References

• Best S3-Compatible Object Storage Providers in 2026 - Tested
• The provider Pricing vs S3 vs B2: $0 Egress
• Unlike Amazon S3 , R2 offers zero egress fees