.png)
DynamoDB Streams pricing is $0.02 per 100,000 GetRecords API calls for non-Lambda consumers, with the first 2.5 million reads per month free per AWS account per region. Lambda-based consumers read DynamoDB Streams for free, making Lambda the cheapest processing option for most event-driven architectures.
Streams have no idle cost: enabling Streams on a table without reading from it costs nothing. Each GetRecords call returns up to 1 MB of data or 1,000 stream records, whichever limit is reached first. Stream records are retained for 24 hours before automatic deletion.
What Are the Exact DynamoDB Streams Pricing Components?
DynamoDB Streams cost has two layers: the Streams read charges and (optionally) the Kinesis Data Streams CDC charges if you route changes to Kinesis. Here is the complete pricing model.
| Component | Rate (US East) | Free Tier | Billing Unit | Key Detail |
| Streams Read (non-Lambda) | $0.02 per 100,000 | 2.5M reads/month/region | GetRecords API call | Up to 1 MB or 1,000 records per call |
| Streams Read (Lambda) | $0.00 (free) | Unlimited | N/A | Lambda execution costs still apply |
| Streams Read (Global Tables replication) | $0.00 (free) | Unlimited | N/A | Internal replication reads not charged |
| Kinesis CDC Units (if enabled) | $0.10 per million CDU | None | 1 CDU per 1 KB write | Charged on top of Kinesis shard fees |
| Kinesis Data Streams (if enabled) | $0.015/shard-hour (provisioned) or $0.08/GB written (on-demand) | None | Shard-hour or GB | Separate Kinesis service charge |
| Streams idle (enabled but unread) | $0.00 | N/A | N/A | No charge for enabling without reading |
How Does DynamoDB Streams Cost Scale from Thousands to Billions of Writes?
Each table write creates one stream record. The number of GetRecords calls your consumers make depends on their polling frequency and the volume of records. Here is the DynamoDB Streams cost at six scale tiers for a non-Lambda consumer polling once per second per shard.
| Monthly Writes | Approx. GetRecords Calls | Free Tier Offset | Billable Reads | Streams Cost | Lambda Alternative |
| 100,000 | ~2.6M | -2.5M | 100K | $0.02 | $0.00 (free reads) |
| 1 million | ~2.7M | -2.5M | 200K | $0.04 | $0.00 |
| 10 million | ~3.6M | -2.5M | 1.1M | $0.22 | $0.00 |
| 100 million | ~12.6M | -2.5M | 10.1M | $2.02 | $0.00 |
| 500 million | ~52.6M | -2.5M | 50.1M | $10.02 | $0.00 |
| 1 billion | ~102.6M | -2.5M | 100.1M | $20.02 | $0.00 |
The headline: DynamoDB Streams cost for non-Lambda consumers is modest at most scales. Even at 1 billion writes/month, the Streams read cost is only $20.02/month. The real cost question is not the Streams reads themselves but the Lambda execution cost or the Kinesis infrastructure cost that sits behind the consumer.
Why Is Lambda the Cheapest Way to Consume DynamoDB Streams?
AWS does not charge for GetRecords API calls made by Lambda functions consuming DynamoDB Streams. This eliminates the $0.02/100K Streams read fee entirely, regardless of volume. You still pay for Lambda execution (duration x memory) and Lambda invocations ($0.20 per million invocations after the 1M free tier), but these are typically far less than the combination of Streams read charges plus custom consumer infrastructure.
Worked example at 100 million writes/month: A Lambda function processing 100M stream records at 128 MB memory with an average duration of 50 ms per batch of 100 records. Invocations: 100M / 100 records per batch = 1M invocations. Cost: 1M invocations x $0.20/M = $0.20. Compute: 1M x 0.05 sec x 128 MB / 1024 MB = 6,250 GB-seconds. Cost: 6,250 x $0.0000166667 = $0.10. Total Lambda cost: $0.30/month. Compare that to the $2.02 Streams read cost for a custom consumer at the same scale. Lambda is 6.7x cheaper at 100M writes/month, and the gap widens at higher volumes.
Lambda event source mapping also supports filtering at the stream level. You can define filter criteria that discard irrelevant records before they invoke your function. This prevents Lambda from processing (and charging for) records your application does not need, such as specific entity types in a single-table design or records from TTL deletions you want to ignore.
Also read: How AWS Savings Plans Share Across Consolidated Billing Accounts
How Do DynamoDB Stream TTL Deletions Affect Streams Cost?
When DynamoDB Time to Live (TTL) deletes an expired item, that deletion appears as a stream record in DynamoDB Streams. This is a common source of unexpected Streams volume: a table with millions of TTL expirations per month generates millions of additional stream records that your consumers must process.
DynamoDB stream TTL interactions matter for cost in two ways. First, every TTL deletion creates a stream record that a non-Lambda consumer must read (at $0.02/100K). For 10 million TTL expirations/month, that adds approximately 10 million extra GetRecords data records. Second, if your Lambda consumer processes TTL deletions, each deletion triggers a Lambda invocation (or adds to a batch), consuming Lambda execution time and memory.
The TTL deletion stream record includes a special attribute (userIdentity.type = “Service” and userIdentity.principalId = “dynamodb.amazonaws.com”) that identifies it as a system-initiated delete. You can use Lambda event source mapping filters to exclude TTL deletions from triggering your function:
Filter pattern: {“eventName”: [“INSERT”, “MODIFY”]} excludes all DELETE events, including TTL. If you need application-initiated deletes but not TTL deletes, filter on the userIdentity.principalId field instead.
For tables using DynamoDB TTL streams heavily (session stores, temporary tokens, time-series data), filtering TTL deletions can reduce Lambda invocations by 30-70% depending on the ratio of TTL expirations to application writes.
How Does DynamoDB Streams Cost Compare to Kinesis Data Streams for CDC?
DynamoDB offers two CDC mechanisms: native DynamoDB Streams and Kinesis Data Streams integration. They have different cost structures and capabilities.
| Dimension | DynamoDB Streams | Kinesis Data Streams CDC | Cost Difference | When to Choose |
| DynamoDB charge | $0.02/100K reads | $0.10/M CDC units (1 CDU per 1 KB write) | Kinesis adds CDC fee | Streams: simpler, cheaper |
| Infrastructure charge | None (serverless) | $0.015/shard-hr (prov.) or $0.08/GB (OD) | Kinesis adds shard fees | Streams: no extra infra |
| Lambda reads | Free | Standard Kinesis Lambda charges | Streams cheaper | Streams: Lambda-optimized |
| Data retention | 24 hours | Up to 365 days | Kinesis wins | Kinesis: long retention |
| Max consumers | 2 simultaneous | Unlimited (enhanced fan-out) | Kinesis wins | Kinesis: multi-consumer |
| Worked cost: 42.5M writes/mo | $0.02 (Lambda) or ~$8 (custom) | $4.22 CDC + $10.95 shard fees = $15.17 | Streams 2-750x cheaper | Streams unless you need retention/fan-out |
DynamoDB Streams with Lambda is 50x cheaper than Kinesis CDC for this workload. Choose Kinesis only when you need data retention beyond 24 hours, more than 2 simultaneous consumers, or integration with Kinesis Analytics/Firehose downstream.
How Does Single-Table Design Affect DynamoDB Streams Cost?
A single-table design funnels all entity type changes into one DynamoDB Stream. If your Lambda consumer only cares about Order entity changes but the stream contains User, Product, and Order records, the consumer is invoked for all record types. Without filtering, you pay for Lambda invocations on records you immediately discard.
Solution: Use Lambda event source mapping filter expressions. Filter on the stream record’s SK attribute prefix (e.g., SK begins_with “ORDER#”) to invoke the function only for Order entity changes. This can reduce Lambda invocations by 50-80% on a single-table with 3-5 entity types, directly reducing both Lambda execution cost and processing latency.
Multi-table design avoids this entirely: each table has its own stream containing only one entity type. Consumers process every record without filtering overhead.
What Are the Best Practices for Reducing DynamoDB Streams Cost?
Use Lambda as Your Primary Consumer
Lambda reads from DynamoDB Streams for free. This alone eliminates the $0.02/100K Streams read charge. For most event-driven architectures, Lambda is the recommended consumer. Use batch sizes of 100-1,000 records and batch windows of 1-5 seconds to optimize Lambda invocation count versus latency.
Apply Event Source Mapping Filters
Lambda event source mapping filters discard records at the stream level before invoking your function. Filter on event type (INSERT, MODIFY, DELETE), attribute values, or entity type prefixes. Filtering reduces Lambda invocations, execution time, and downstream processing costs.
Filter Out DynamoDB TTL Stream Deletions When Not Needed
If your consumer does not need to process TTL-initiated deletes, add a filter excluding DELETE events or filtering on the userIdentity field. For tables with high TTL expiration rates, this can eliminate 30-70% of unnecessary stream processing.
Also read: AWS Savings Plan Buying Strategy
Monitor GetRecords Volume with CloudWatch
The SuccessfulRequestLatency metric with SampleCount statistic shows the number of GetRecords calls per stream. This metric includes free reads (Lambda, Global Tables) and charged reads. To isolate charged reads, subtract Lambda and Global Tables calls. Set CloudWatch alarms when billable reads exceed your expected threshold.
Evaluate Whether You Actually Need Streams Enabled
Streams have no idle cost, so enabling them is free. But the downstream consumers you build to process those streams cost money. If you enabled Streams for a one-time migration and forgot to disable the consumer, you may be paying for Lambda invocations processing records your application no longer uses. Audit active Streams consumers quarterly.
How Does DynamoDB Streams Cost Fit into the Total DynamoDB Bill?
For most DynamoDB deployments, Streams cost is a small fraction of the total bill. The AWS worked example shows Streams costing $0.02/month on a table with $68.42 total monthly charges, roughly 0.03% of the bill. Even at 1 billion writes/month with a custom consumer, the $20.02 Streams cost is dwarfed by the write throughput cost (on-demand: $1,250/month).
The real cost optimization levers remain capacity mode selection (5-6x impact), reserved capacity (53-77% savings), and item size management. Streams cost is worth optimizing at scale, but it should not distract from the first-order decisions that drive 80-90% of your DynamoDB bill.
Usage.ai Flex Reserved Instances automate the reserved capacity purchasing for DynamoDB provisioned throughput, capturing 30-40% savings on the read and write capacity that constitutes the bulk of your DynamoDB spend. The platform refreshes its analysis every 24 hours versus AWS Cost Explorer’s 72+ hour cycle. If a reservation becomes underutilized, Usage.ai provides cashback and credits. The fee is a percentage of realized savings only.
See how much you can save on DynamoDB with Usage.ai
Frequently Asked Questions
1. How much does AWS DynamoDB Streams cost?
DynamoDB Streams costs $0.02 per 100,000 GetRecords API calls for non-Lambda consumers. Lambda consumers read for free. Global Tables replication reads are free. The first 2.5 million non-Lambda reads per month per region are included in the free tier. Idle streams cost nothing (verify at aws.amazon.com/dynamodb/pricing — rates change).
2. Is DynamoDB Streams free?
Partially. Enabling Streams is free. Lambda-based reads are free. The first 2.5M non-Lambda reads per month are free. After the free tier, non-Lambda consumers pay $0.02 per 100,000 reads. You also pay for downstream processing costs (Lambda execution, Kinesis infrastructure) regardless of the Streams read charge.
3. How much is DynamoDB write cost vs read cost?
On-demand: writes cost $1.25 per million WRU, reads cost $0.25 per million RRU (5:1 ratio). Provisioned: writes cost $0.00065/WCU-hour, reads cost $0.00013/RCU-hour (also 5:1). Streams reads are separate at $0.02/100K for non-Lambda consumers. Writes always cost 5x more than reads on DynamoDB (verify at aws.amazon.com/dynamodb/pricing — rates change).
4. How many DynamoDB Streams per table?
One. Each DynamoDB table supports exactly one stream. The stream captures all item-level changes (inserts, updates, deletes) in time order. You can configure the stream view type to capture keys only, new image, old image, or both new and old images. You cannot have multiple streams with different view types on the same table.
5. Do DynamoDB TTL deletions appear in Streams?
Yes. Every TTL-initiated item deletion generates a stream record marked with userIdentity.type = Service and principalId = dynamodb.amazonaws.com. These records trigger Lambda consumers and count toward non-Lambda GetRecords calls. Use event source mapping filters to exclude TTL deletions when your consumer does not need them.
6. Should I use DynamoDB Streams or Kinesis Data Streams for CDC?
Use DynamoDB Streams for most workloads: it is serverless, Lambda reads are free, and the cost is minimal. Choose Kinesis Data Streams only when you need retention beyond 24 hours, more than 2 simultaneous consumers, or integration with Kinesis Analytics and Firehose. Kinesis CDC adds $0.10/M CDU plus shard fees on top of DynamoDB Streams cost.
7. Does DynamoDB Streams consume table read capacity?
No. Streams read request units are completely separate from table read capacity units (RCU). Reading from a DynamoDB Stream does not consume any provisioned or on-demand RCU on your table. The two billing dimensions are independent. Stream reads are billed exclusively through the Streams pricing ($0.02/100K for non-Lambda consumers).
8. How long does DynamoDB Streams retain data?
DynamoDB Streams retains records for 24 hours. After 24 hours, records are automatically deleted from the stream. If your consumer falls behind by more than 24 hours, you will lose records. Kinesis Data Streams integration offers retention up to 365 days for workloads requiring longer replay windows.
