# Kinesis Data Streams shard limits

AWS limits and quotas · Updated 17 November 2026

**Short answer:** In provisioned mode each shard accepts up to 1 MB per second or 1,000 records per second of writes, and serves up to 2 MB per second of reads through at most 5 GetRecords calls per second (each returning up to 10 MB or 10,000 records). Records can be up to 10 MiB, handled with burst capacity. The account shard quota is 20,000 in us-east-1, us-west-2 and eu-west-1 and 1,000 or 6,000 elsewhere, adjustable. On-demand streams start at 4 MB/s write and 8 MB/s read and scale automatically.

## Per-shard limits (provisioned mode)

| Direction | Limit |
|---|---|
| Writes (PutRecord / PutRecords) | 1 MB/s or 1,000 records/s per shard, whichever comes first |
| PutRecords request | Up to 500 records, 10 MiB per request including partition keys |
| Record payload | Up to 10 MiB before base64 encoding (large records use burst capacity) |
| Reads (shared, GetRecords) | 2 MB/s per shard; 5 GetRecords calls/s per shard |
| One GetRecords call | Up to 10 MB or 10,000 records |
| Enhanced fan-out consumers | 2 MB/s per consumer per shard; 20 registered consumers per stream (50 with On-demand Advantage) |
| Shard iterator lifetime | 5 minutes |

The 2 MB/s read limit is shared by every standard (polling) consumer of the shard. Three Lambda functions and a Firehose stream polling the same stream compete for those 5 calls and 2 MB per second; enhanced fan-out gives each registered consumer its own 2 MB/s. If a GetRecords call returns 10 MB, the next calls within 5 seconds throw an exception, so a burst read effectively consumes the shard's budget for that window.

## Stream and account limits

| Quota | Default | Adjustable |
|---|---|---|
| Shards per account per Region | 20,000 in us-east-1, us-west-2, eu-west-1; 1,000 or 6,000 elsewhere | Yes |
| On-demand stream throughput | Starts at 4 MB/s write, 8 MB/s read; scales to 10 GB/s write in the largest Regions (200 MB/s elsewhere unless raised) | Via Support |
| Capacity mode switches | Twice per 24 hours per stream | No |
| Retention | 24 hours (default) to 8,760 hours (365 days) | Per stream setting |
| Streams in CREATING state at once | 5 | No |
| UpdateShardCount | Default limit of 10,000 shards per stream, with call-rate limits | Partly |

## Recognising throttling

Producers get `ProvisionedThroughputExceededException` (or failed entries in a `PutRecords` response, which returns 200 with `FailedRecordCount` above zero, so always check it). Consumers get the same exception on `GetRecords`, and their `IteratorAgeMilliseconds` climbs.

The usual cause is not total throughput but a **hot shard**: a partition key with a lot of traffic maps every record to one shard, so that shard hits 1 MB/s while the stream as a whole is far below capacity. Enable shard-level metrics to see it:

```
aws kinesis enable-enhanced-monitoring --stream-name clicks \
  --shard-level-metrics IncomingBytes IncomingRecords WriteProvisionedThroughputExceeded ReadProvisionedThroughputExceeded

aws kinesis describe-stream-summary --stream-name clicks \
  --query 'StreamDescriptionSummary.{shards:OpenShardCount,mode:StreamModeDetails.StreamMode,retention:RetentionPeriodHours}'
```

Alarm on [WriteProvisionedThroughputExceeded](https://cloudconsole.dev/alarms/kinesis-writeprovisionedthroughputexceeded) and [iterator age](https://cloudconsole.dev/alarms/kinesis-getrecords-iteratoragemilliseconds) at stream level first; drill into shard metrics when they fire.

## Fixes

- **Spread partition keys:** use a high-cardinality key (user ID, request ID) or add a random suffix to hot keys.
- **Add shards** with `UpdateShardCount` (uniform scaling) or split the hot shard; scaling takes time, so do it before a known peak.
- **Switch to on-demand** for spiky or unpredictable traffic, remembering the two-switches-per-day limit.
- **Use enhanced fan-out** when several consumers read the same stream.
- **Aggregate small records** with the KPL so you hit the 1 MB/s limit rather than the 1,000 records/s one.

## Questions

### How many records per second can a Kinesis shard handle?

1,000 records per second for writes (or 1 MB/s, whichever comes first), and 2 MB/s for reads shared across standard consumers.

### What is the maximum record size in Kinesis Data Streams?

Up to 10 MiB of data per record before base64 encoding, though sustained throughput per shard is still about 1 MB/s.

### How many shards can I have in Kinesis?

20,000 per account in us-east-1, us-west-2 and eu-west-1 by default, and 1,000 or 6,000 in other Regions. The quota is adjustable.

## When this happens away from your desk

Shard throttling shows up as rising iterator age, which means your consumers are falling behind. CloudConsole, a phone app for AWS, is being built to show iterator-age and throttling alarms on your phone.

[About the CloudConsole app](https://cloudconsole.dev/aws-console-app) · [Download on the App Store](https://apps.apple.com/app/cloudconsole-for-aws/id6835419710)

## Sources

- [Quotas and limits (Amazon Kinesis Data Streams)](https://docs.aws.amazon.com/streams/latest/dev/service-sizes-and-limits.html)

## Related

- [CloudWatch alarm: Kinesis WriteProvisionedThroughputExceeded](https://cloudconsole.dev/alarms/kinesis-writeprovisionedthroughputexceeded)
- [CloudWatch alarm: Kinesis ReadProvisionedThroughputExceeded](https://cloudconsole.dev/alarms/kinesis-readprovisionedthroughputexceeded)
- [CloudWatch alarm: Kinesis GetRecords.IteratorAgeMilliseconds](https://cloudconsole.dev/alarms/kinesis-getrecords-iteratoragemilliseconds)
- [CloudWatch alarm: Kinesis PutRecords.FailedRecords](https://cloudconsole.dev/alarms/kinesis-putrecords-failedrecords)
- [How to request an AWS service quota increase](https://cloudconsole.dev/limits/service-quotas-increase)
- [Amazon SQS limits and quotas](https://cloudconsole.dev/limits/sqs-limits)

---

Source: https://cloudconsole.dev/limits/kinesis-shard-limits

CloudConsole is an independent iPhone and Android app for Amazon Web Services by Cloudconcur Ltd. It is not affiliated with Amazon Web Services.
