S3 Files pricing trips people up because it layers three separate cost components on top of each other. You pay standard S3 storage and request costs (which you already have), plus two new charges for the high-performance cache layer and data access. Most AWS pricing pages bury this, so the actual cost of mounting S3 as a file system is unclear until you do the math yourself.
This guide breaks down each pricing component with real cost scenarios so you can estimate what S3 Files will actually cost for your workload. If you haven’t set up S3 Files yet, start with our complete S3 Files setup and performance guide first.
Current as of April 2026. Pricing based on us-east-1 (N. Virginia) rates.
How S3 Files Pricing Works
S3 Files has three cost layers. Two of them are standard S3 charges you already pay. The third is new and specific to the high-performance cache that makes NFS-speed file access possible.
Layer 1: Standard S3 Storage and Request Costs
Every object in your S3 bucket incurs normal S3 charges regardless of whether S3 Files is enabled. These costs exist whether you access data through the S3 API, the AWS console, or an NFS mount point.
- S3 Standard storage: ~$0.023 per GB/month
- GET requests: $0.0004 per 1,000 requests
- PUT requests: $0.005 per 1,000 requests
- Data transfer out: standard S3 egress rates (free within the same region to EC2)
Nothing changes here when you enable S3 Files. A 1 TB bucket costs the same $23.55/month in S3 storage whether it has a mount target or not.
Layer 2: High-Performance Cache Storage
This is the new cost specific to S3 Files. When you read or write files through the NFS mount, S3 Files caches that data on a high-performance storage layer to deliver file system latency (single-digit milliseconds for metadata, streaming throughput for data). You pay a per-GB monthly rate for data sitting in this cache.
The key detail: you only pay for actively cached data, not the entire bucket. If your bucket holds 10 TB but only 200 GB is being actively read and written through the mount, cache charges apply to roughly that 200 GB.
- Rate: approximately $0.30 per GB/month (comparable to EFS Standard pricing)
- Cache expiration: configurable from 1 to 365 days (default 30 days)
- Billing scope: only active data in the cache, not total bucket size
Note: The exact per-GB rate for S3 Files high-performance storage may vary by region. Check the official AWS S3 pricing page for current rates, as the service is newly launched and pricing may be updated.
Layer 3: Data Access Charges
Every byte read from or written to the high-performance cache incurs a data access charge. This is separate from S3 GET/PUT request costs and separate from the cache storage charge.
- Reads from cache: per-GB charge for data served from the high-performance layer
- Writes to cache: per-GB charge for data written through the NFS mount
Here is where S3 Files gets clever with cost optimization. Large sequential reads (1 MB or larger) that can be satisfied directly from S3 object storage bypass the high-performance cache entirely. These reads incur only standard S3 GET costs, not S3 Files data access charges. This makes S3 Files surprisingly affordable for workloads that read large files sequentially, which covers most data analytics and ML training scenarios.
What S3 Files Does Not Charge For
Several operations that might seem billable are actually free:
- Large file reads (1 MB or larger) of data already stored in S3 cost only standard S3 GET rates
- Mount target creation has no charge
- File system creation on the bucket is free
- NFS mount connections from EC2 instances have no per-connection fee
- Metadata operations like
lsandstaton cached entries do not incur data access charges
The free large-read path is the most important cost feature. If your workload is primarily reading files over 1 MB (log files, datasets, model weights, media files), the S3 Files premium over plain S3 is minimal.
Cost Scenarios with Real Numbers
Abstract pricing tiers are useless without concrete numbers. Here are three workload profiles with estimated monthly costs. All estimates use us-east-1 pricing and assume same-region EC2 access (no data transfer charges).
Scenario 1: Development Team (Small Working Set)
A development team shares a 50 GB S3 bucket containing source code, build artifacts, and configuration files. About 5 GB is actively accessed through the NFS mount at any given time. Monthly activity: ~100 GB of reads and ~10 GB of writes, mostly small files (under 1 MB).
| Cost Component | Calculation | Monthly Cost |
|---|---|---|
| S3 Standard storage | 50 GB x $0.023 | $1.15 |
| S3 requests (est.) | ~50K GETs + ~5K PUTs | $0.05 |
| Cache storage | 5 GB x $0.30 | $1.50 |
| Data access (reads) | 100 GB x ~$0.01 | $1.00 |
| Data access (writes) | 10 GB x ~$0.01 | $0.10 |
| Total | ~$3.80 |
Compare this to EFS for the same 50 GB: approximately $15/month at EFS Standard rates. S3 Files costs roughly one quarter of what EFS would charge for this workload, and you get the added benefit of S3 durability and direct API access to the same data.
Scenario 2: Data Analytics Pipeline (Read-Heavy, Large Files)
An analytics team processes a 1 TB data lake stored in S3. Their Spark and Pandas jobs read ~500 GB/month, with most reads being large Parquet files (well over 1 MB each). Only about 50 GB of intermediate results and lookup tables stay in the active cache. Writes are ~20 GB/month of processed output.
| Cost Component | Calculation | Monthly Cost |
|---|---|---|
| S3 Standard storage | 1,024 GB x $0.023 | $23.55 |
| S3 requests (est.) | ~200K GETs + ~10K PUTs | $0.13 |
| Cache storage | 50 GB x $0.30 | $15.00 |
| Data access (reads) | ~50 GB cached reads x $0.01* | $0.50 |
| Data access (writes) | 20 GB x ~$0.01 | $0.20 |
| Total | ~$39.38 |
*Most of the 500 GB in reads are large files (over 1 MB) that stream directly from S3, bypassing the cache. Only the ~50 GB of small lookup table reads hit the high-performance layer.
This is where S3 Files shines. The bulk of read I/O goes straight to S3 at standard GET rates. Cache charges only apply to the small-file working set. Doing the same thing with EFS would cost ~$300/month for 1 TB of storage alone.
Scenario 3: ML Training (Large Dataset, Bursty Access)
A machine learning team stores 5 TB of training data in S3. During training runs, the active dataset (currently selected training splits and augmentation configs) occupies about 200 GB in the cache. Each training epoch re-reads the cached dataset, totaling ~2 TB/month in read volume. Writes are minimal because training checkpoints go directly to S3 via the API.
| Cost Component | Calculation | Monthly Cost |
|---|---|---|
| S3 Standard storage | 5,120 GB x $0.023 | $117.76 |
| S3 requests (est.) | ~500K GETs + ~20K PUTs | $0.30 |
| Cache storage | 200 GB x $0.30 | $60.00 |
| Data access (reads) | ~200 GB cached reads x $0.01* | $2.00 |
| Data access (writes) | 5 GB x ~$0.01 | $0.05 |
| Total | ~$180.11 |
*Training data files are typically large (images, TFRecords, Parquet shards), so most of the 2 TB in epoch reads stream from S3 directly. Cache access charges apply primarily to smaller config files and metadata.
The alternative here would be copying 5 TB to EBS gp3 volumes at ~$500/month, plus the time and orchestration overhead of keeping copies in sync. S3 Files eliminates the copy step entirely while costing roughly a third of EBS for this workload.
Cost Comparison: S3 Files vs Other Storage Options
The following table compares monthly cost estimates for a workload with 1 TB of total data and 50 GB of actively accessed files. All prices are us-east-1 and exclude data transfer.
| Storage Solution | Configuration | Monthly Estimate |
|---|---|---|
| S3 Files | 1 TB in S3 + 50 GB active cache | ~$40 |
| EFS Standard | 1 TB stored | ~$300 |
| FSx for Lustre | 1.2 TB minimum (linked to S3) | ~$175 |
| EBS gp3 | 1 TB volume | ~$80 |
| S3 only (no file mount) | 1 TB stored | ~$23 |
S3 Files sits between plain S3 (cheapest but no POSIX access) and EFS (full POSIX but charges for all stored data). The cost advantage grows as the ratio of total data to active working set increases. If you access 5% of your bucket regularly, S3 Files is dramatically cheaper than any solution that charges per-GB for the full dataset.
EBS is cheaper than EFS but requires you to copy data from S3, manage volume sizing, and handle the fact that EBS volumes attach to a single instance (or require io2 multi-attach with constraints). S3 Files gives you multi-instance concurrent access with no copy step.
For a deeper look at how S3 Files performance compares to these alternatives, see our S3 Files performance benchmarks and setup guide.
Cost Optimization Tips
The biggest lever you have is the cache expiration window. The default is 30 days, which means data stays in the high-performance layer (and incurs cache storage charges) for a full month after the last access. If your workload touches files once during a batch job and doesn’t revisit them, drop the expiration to 1 or 2 days. You’ll pay cache charges for hours instead of weeks.
Use access points to scope down which prefixes (directories) are exposed through the mount. If only /data/current/ needs NFS access, don’t mount the entire bucket. Fewer files in scope means less metadata cached and lower overall costs.
Monitor the CloudWatch cache hit ratio metric. A consistently high hit ratio means your expiration window is appropriately sized. A low hit ratio suggests data is evicting before it gets reused, which means you’re paying cache storage for data that doesn’t benefit from caching. Either extend the window or accept that the cache isn’t helping and consider whether S3 Files is the right choice for that particular workload.
For read-only large-file workloads (analytics, media processing, ML inference), S3 Files is almost free beyond standard S3 costs. Large reads bypass the cache entirely, so the only S3 Files premium is cache storage for directory metadata. This makes S3 Files a strong choice for mounting data lakes where applications expect a file system path.
For write-heavy workloads, evaluate whether the cache access charges justify the latency improvement over writing directly to S3 via the API. Small-file writes benefit significantly from the cache (batched flushes to S3), but if you’re writing large files sequentially, the AWS SDK with multipart upload may be cheaper and just as fast.
To mount S3 Files on your EC2 instances and test these cost patterns with your own data, follow our step-by-step EC2 mounting guide.
Frequently Asked Questions
Does S3 Files charge for the entire bucket?
No. S3 Files cache storage charges apply only to data actively cached on the high-performance layer. If you have a 10 TB bucket but only 100 GB is actively accessed through the NFS mount, you pay S3 Files cache charges on approximately 100 GB. The remaining 9.9 TB sits at standard S3 storage rates ($0.023/GB). This is the fundamental cost advantage over EFS and FSx, which charge per-GB for all stored data.
Are S3 Files charges in addition to regular S3 costs?
Yes. S3 Files charges are fully additive. You continue to pay standard S3 storage rates for every object in the bucket, plus standard S3 request costs for API calls. The cache storage and data access charges from S3 Files stack on top of those existing costs. Think of S3 Files pricing as an overlay: S3 costs stay the same, and you add cache costs for the performance tier.
How does S3 Files compare to EFS pricing?
S3 Files is significantly cheaper for datasets where only a fraction is actively used. EFS Standard charges ~$0.30/GB/month for all stored data. For 1 TB, that is $300/month regardless of how much you access. S3 Files charges $0.30/GB only for the cached working set, while cold data stays at $0.023/GB in S3. For a 1 TB dataset with 50 GB active, S3 Files costs around $40/month versus EFS at $300/month. The gap widens with larger datasets.
Can I control how much data gets cached?
Yes, through two mechanisms. The cache expiration setting (1 to 365 days) controls how long untouched data remains in the cache. Shorter expiration means less data cached at any point, which reduces cache storage costs. Access points let you restrict which bucket prefixes are visible through the mount, preventing applications from accidentally caching data they don’t need.
Do large file reads really bypass S3 Files charges?
Sequential reads of 1 MB or larger stream directly from S3 object storage and incur only standard S3 GET request costs. They do not pass through the high-performance cache and do not generate S3 Files data access charges. This design decision makes S3 Files cost-effective for data-intensive workloads (analytics, ML, media) where most I/O involves large files. Small random reads (under 1 MB) do go through the cache and incur data access charges, which is the expected trade-off for getting low-latency access to small files.
What happens to costs if I forget to set cache expiration?
The default cache expiration is 30 days. If your application reads 500 GB of data once during a monthly batch job, all 500 GB stays in the cache (and incurs $150/month in cache charges) until it expires 30 days later. Setting expiration to 1 day for batch workloads reduces that to roughly $5/month because data evicts within 24 hours of the last access. Always review the default expiration against your actual access patterns.
Estimating Your Own Costs
To estimate S3 Files costs for your workload, you need three numbers: total bucket size, active working set size, and monthly read/write volume split by file size (above or below 1 MB). Plug those into the three-layer model.
Use the AWS Cost Calculator or run this quick estimation:
# Quick S3 Files cost estimate (adjust values for your workload)
BUCKET_GB=1000
CACHE_GB=50
SMALL_READS_GB=50 # reads under 1MB (go through cache)
LARGE_READS_GB=450 # reads over 1MB (bypass cache, standard S3 only)
WRITES_GB=20
S3_STORAGE=$(echo "$BUCKET_GB * 0.023" | bc)
CACHE_STORAGE=$(echo "$CACHE_GB * 0.30" | bc)
ACCESS_READS=$(echo "$SMALL_READS_GB * 0.01" | bc)
ACCESS_WRITES=$(echo "$WRITES_GB * 0.01" | bc)
TOTAL=$(echo "$S3_STORAGE + $CACHE_STORAGE + $ACCESS_READS + $ACCESS_WRITES" | bc)
echo "S3 storage: \$$S3_STORAGE"
echo "Cache storage: \$$CACHE_STORAGE"
echo "Access (reads): \$$ACCESS_READS"
echo "Access (writes):\$$ACCESS_WRITES"
echo "---"
echo "Estimated total: \$$TOTAL/month"Adjust CACHE_GB to reflect your expected active working set, and split your read volume between small and large files. Large file reads cost only standard S3 GET rates, so the split matters significantly for total cost.
The three cost layers can feel complex at first, but the pricing model is actually straightforward once you understand the cache boundary. Standard S3 costs are a given. Cache storage scales with your active working set, not your total data. Data access charges are minimal for large-file workloads. For most use cases where total dataset size far exceeds the active working set, S3 Files delivers file system semantics at a fraction of what EFS or FSx would cost.
For the complete setup walkthrough including mount targets, access points, and performance tuning, see our Amazon S3 Files setup and performance guide.
