Are AWS-service events on the default event bus really free?

Yes. Events emitted by AWS services (EC2 state changes, S3 object events, CodePipeline transitions, etc.) to the default event bus are free for both publish and rule evaluation. The free tier covers the entire AWS-native event-driven architecture for AWS-service events. The $1/million rate applies only to custom events published by your applications to a custom event bus or to the default bus. This split is the single most useful EventBridge pricing fact: build AWS-service-driven automation freely; budget carefully for custom-event-driven workflows.

How does EventBridge compare cost-wise to SNS-to-SQS fanout?

For pure internal fanout to known consumers, SNS-to-SQS is roughly 50% cheaper. SNS publishes at $0.50/M with free SQS delivery; EventBridge publishes at $1/M plus the consumer-side cost. The premium pays for EventBridge features: rule-based routing on event content, schema discovery, archive and replay, cross-account event sharing, and the partner-events ecosystem. Use EventBridge when you need those features; use SNS-to-SQS for predictable high-volume fanout where the routing is "every event to every subscriber."

What is Schema Discovery and why does it add $0.10/M?

Schema Discovery is an opt-in feature on an event bus that inspects every event passing through and generates a JSON Schema or OpenAPI definition for each unique event shape. It is useful during development to discover what events look like without manual inspection. It is metered at $0.10/M events evaluated. On high-volume event buses, this adds a real line item. The right pattern: enable Schema Discovery on dev/staging buses during development, then disable it on production buses where the schemas are already known. Leaving it on production is a common bill leak.

How does EventBridge Pipes pricing differ from event bus pricing?

Pipes is a separate primitive — it connects a source (SQS, Kinesis, DynamoDB Streams, etc.) to a target (Lambda, Step Functions, an event bus) with optional filtering and enrichment in between. Pipes is billed at $0.40/M events processed, regardless of source or target. The source and target services bill normally on their own rates. Pipes is a "Lambda replacement for simple plumbing" — for source-to-target integrations that previously needed a Lambda function, Pipes can be cheaper (no cold starts, no per-invocation Lambda cost) and operationally simpler.

What does the Archive feature actually cost?

EventBridge Archive stores events that passed through an event bus at $0.10/GB-month. Replay (re-running archived events through the bus rules) is free for the replay action but the replayed events re-incur the standard publish rate ($1/M for custom buses). Archive is useful for two patterns: debugging (replay events from a specific time window to test a new rule) and disaster recovery (replay missed events after a downstream system outage). Archive bills indefinitely if not configured with a retention period; set a retention (90–365 days for most use cases) when creating the archive.

When is EventBridge Scheduler cheaper than CloudWatch Events scheduled rules?

EventBridge Scheduler is the modern replacement for CloudWatch Events scheduled rules, with a more flexible scheduling model (one-time schedules, time-zone-aware cron, flexible time windows). It bills $1/M invocations after a 14M-per-month free tier. CloudWatch Events scheduled rules bill the standard EventBridge rule rate. For typical scheduling workloads (under 14M invocations/month), Scheduler is free and is the right choice; above 14M, the per-invocation rate is the same as standard custom events. The migration is non-controversial; Scheduler is feature-positive and free at typical workload sizes.

Do cross-region event bus replications double the cost?

Essentially yes. Cross-region event bus replication is configured via a rule that targets an event bus in another region; the source bus bills the $1/M publish, the target bus bills $1/M for the inbound event, and inter-region data transfer ($0.02/GB) applies to the event payload. For a 100M-events-per-month bus replicated to one secondary region, the cost roughly doubles. Replicate only when there are consumers in the secondary region; many teams enable cross-region replication for "DR" and never have a consumer that uses it.

Amazon EventBridge Pricing: Events, Pipes, Schema, Archive

EventBridge looks like a single-line-item service: $1 per million events. The line item is half the story. EventBridge actually bills across six distinct dimensions — custom events, Pipes, API Destinations, Schema Discovery, Archive, and cross-region replication — and the most common bill surprise is leaving one of the optional features (Schema Discovery, Archive without retention) running across production traffic.

Amazon EventBridge pricing covers custom events, Pipes, API Destinations, Schema Discovery, Archive storage, and cross-region replication. In us-east-1 (June 2026), AWS-service events are free while custom events cost $1 per million. Most surprises come from leaving Schema Discovery or Archive running on production traffic without retention limits.

Feature	us-east-1	Trap
AWS service events	Free	Build on these first
Custom events	$1/M	Default bus traffic
Pipes	$0.40/M	Lambda-plumbing replacement
Archive	$0.10/GB-month	Set retention

This post is the bill story. For event-driven architecture patterns and how EventBridge fits into the broader async ecosystem, see our EventBridge architecture patterns guide. For the SNS-to-SQS comparison angle, the SNS pricing post covers when each is cheaper.

The Six EventBridge Billing Dimensions

EventBridge pricing breakdown — us-east-1, June 2026

Prices in us-east-1

Six independent dimensions. The custom-events line is the easy number; the optional features (Schema, Archive, cross-region) are where bills go sideways.

Dimension	Unit price	Example workload	Monthly cost
AWS-service events (default bus) Includes rule evaluation and target invocation	Free	EC2 state changes, S3 object events	$0.00
Custom events (any bus) Both publish and rule evaluation per event	$1.00 / million	50M custom events / month	$50.00
EventBridge Pipes Plus source and target service costs	$0.40 / million events	SQS-to-Lambda via Pipes, 20M/mo	$8.00
API Destinations Plus the standard event-publish cost	$0.20 / million invocations	External webhook delivery, 10M/mo	$2.00
Schema Discovery Disable on production after dev complete	$0.10 / million events	Enabled on prod bus with 50M/mo	$5.00
Archive storage Set retention period; can grow forever otherwise	$0.10 / GB / month	100 GB archived events	$10.00
Replay The replay action is free; replayed events bill	Free + replayed events at $1/M	Replay 1M events to test new rule	$1.00
Cross-region replication Doubles the publish cost; budget carefully	$1/M source + $1/M target + $0.02/GB transfer	100M events replicated to 1 region	~$200 + payload transfer
EventBridge Scheduler Replaces CloudWatch Events scheduled rules	Free for 14M / month then $1/M	Cron-style triggers	$0 typically
Partner events (received) Standard $1/M applies on downstream rule evaluation	Free to receive	Datadog, Auth0, etc. → EventBridge	$0.00

AWS-service events (default bus)

$0.00

Includes rule evaluation and target invocation

Unit price: Free
Example workload: EC2 state changes, S3 object events

Custom events (any bus)

$50.00

Both publish and rule evaluation per event

Unit price: $1.00 / million
Example workload: 50M custom events / month

EventBridge Pipes

$8.00

Plus source and target service costs

Unit price: $0.40 / million events
Example workload: SQS-to-Lambda via Pipes, 20M/mo

API Destinations

$2.00

Plus the standard event-publish cost

Unit price: $0.20 / million invocations
Example workload: External webhook delivery, 10M/mo

Schema Discovery

$5.00

Disable on production after dev complete

Unit price: $0.10 / million events
Example workload: Enabled on prod bus with 50M/mo

Archive storage

$10.00

Set retention period; can grow forever otherwise

Unit price: $0.10 / GB / month
Example workload: 100 GB archived events

Replay

$1.00

The replay action is free; replayed events bill

Unit price: Free + replayed events at $1/M
Example workload: Replay 1M events to test new rule

Cross-region replication

~$200 + payload transfer

Doubles the publish cost; budget carefully

Unit price: $1/M source + $1/M target + $0.02/GB transfer
Example workload: 100M events replicated to 1 region

EventBridge Scheduler

$0 typically

Replaces CloudWatch Events scheduled rules

Unit price: Free for 14M / month then $1/M
Example workload: Cron-style triggers

Partner events (received)

$0.00

Standard $1/M applies on downstream rule evaluation

Unit price: Free to receive
Example workload: Datadog, Auth0, etc. → EventBridge

The AWS-service-events-are-free fact is the single most leverage-able detail in the EventBridge pricing page. Build heavily on it.

If you only audit one dimension first, confirm Schema Discovery is off in production — it bills per ingested event.

Free AWS-Service Events vs $1/M Custom Events

The most important EventBridge pricing fact: AWS-service events on the default event bus are free for both publish and rule evaluation. EC2 state changes, S3 object events, CodePipeline transitions, RDS snapshot completion, IAM events — all free. The $1/million rate kicks in only on:

Events you publish via PutEvents from your application code (custom events).
Events on custom event buses (named buses other than default).
Events forwarded across regions or accounts.

This split makes EventBridge the cheapest event-driven automation primitive on AWS for AWS-service-triggered workflows. Build CodeBuild-triggered pipelines, S3-triggered processing, EC2-state-driven remediation — all of it free on the publish side. The cost shows up only on the target-invocation side (Lambda invocations, Step Functions state transitions, etc.) which would bill regardless of trigger source.

For one-to-many event distribution, the choice between EventBridge custom events and SNS-to-SQS fanout has clear economic trade-offs.

EventBridge vs SNS-to-SQS — 100M monthly events to 5 internal consumers

Prices in us-east-1

The same workload modeled both ways. Choose based on whether you need EventBridge's routing features.

Dimension	Unit price	Example workload	Monthly cost
EventBridge custom events Each rule evaluation per event counts	$1/M publish + $1/M rule eval	100M publishes, 5 rules match each	~$100 + $500 = $600
SNS-to-SQS fanout 58% cheaper than EventBridge	$0.50/M publish + free SQS delivery + SQS receive	100M publishes × 5 SQS receives	~$50 + $200 SQS = $250
EventBridge with filter rules (only relevant deliveries) Filtering reduces target invocations not rule evals	Same as above	Filtered to 1 consumer per event	~$200
When EventBridge wins Worth the premium when features are needed	Feature-driven	Cross-account, archive, partner events	N/A

EventBridge custom events

~$100 + $500 = $600

Each rule evaluation per event counts

Unit price: $1/M publish + $1/M rule eval
Example workload: 100M publishes, 5 rules match each

SNS-to-SQS fanout

~$50 + $200 SQS = $250

58% cheaper than EventBridge

Unit price: $0.50/M publish + free SQS delivery + SQS receive
Example workload: 100M publishes × 5 SQS receives

EventBridge with filter rules (only relevant deliveries)

~$200

Filtering reduces target invocations not rule evals

Unit price: Same as above
Example workload: Filtered to 1 consumer per event

When EventBridge wins

N/A

Worth the premium when features are needed

Unit price: Feature-driven
Example workload: Cross-account, archive, partner events

The 50% cost premium on EventBridge pays for rule-based routing, archive, cross-account sharing, and the partner event ecosystem.

EventBridge Pipes: The Lambda-Plumbing Replacement

EventBridge Pipes is a separate primitive from event buses. It directly connects a source (SQS, Kinesis, DynamoDB Streams, Kafka) to a target (Lambda, Step Functions, an event bus, an API destination) with optional filtering and enrichment.

The economic appeal: for plumbing-style integrations that previously needed a Lambda function to read from one service and write to another, Pipes can be both cheaper and operationally simpler. A Lambda function consuming SQS and forwarding to Step Functions bills:

Lambda invocations + duration
SQS receives
Step Functions starts

A Pipe between the same source and target bills:

$0.40/M events processed
SQS receives
Step Functions starts

For high-volume, low-logic plumbing, Pipes typically beats Lambda by removing the per-invocation overhead and cold starts. For workflows where the “function” actually does meaningful transformation (calling other APIs, enriching from a database), Lambda remains the right answer.

Schema Discovery: Useful During Dev, Expensive in Production

Schema Discovery is an opt-in feature that inspects every event on an event bus and generates a JSON Schema or OpenAPI definition for each unique shape. It is useful during development: you don’t need to manually document event structures, the Schema Registry auto-generates them as events flow.

The cost line: $0.10 per million events evaluated. On a 50M-event-per-month production bus, that is $5/month — small. On a 5B-event bus, it is $500/month for a feature that primarily serves development. Leaving Schema Discovery on across production buses is a common bill leak.

Archive and Replay: Useful, but Set Retention

EventBridge Archive stores events that passed through an event bus, with an optional event-pattern filter to archive only matching events. Storage bills at $0.10/GB-month. Without a retention period, the archive grows forever.

Replay is free for the replay action itself; the replayed events re-bill at the standard $1/M rate as they flow through bus rules again. Two common use cases:

Debugging. Archive failing events; replay them through the event bus after fixing a downstream consumer. The cost is the archive storage + the replay re-billing of those events.
DR. Archive critical events for a configurable retention; replay if a downstream consumer was unavailable for a window.

The waste pattern: creating an archive at development time, never setting a retention, never replaying, and accumulating GB-month storage indefinitely.

API Destinations: The External-Webhook Pattern

API Destinations let an EventBridge rule deliver events to an external HTTPS endpoint with auth (Basic, API Key, OAuth). The cost is $0.20/million invocations on top of the standard event publish cost.

Common use cases: posting to Slack/Teams webhooks, calling third-party SaaS APIs (Salesforce, Stripe, etc.), forwarding events to external monitoring tools. The pattern replaces what would otherwise be a Lambda function making HTTP calls — typically cheaper and operationally simpler, with built-in retry and rate-limiting via Connection objects.

When to Use EventBridge vs Alternatives

EventBridge for rule-based routing or AWS-service automation; SNS for cheap fanout; Pipes for source-to-target plumbing; Scheduler for cron.

Use when

AWS-service-triggered automation (EC2, S3, CodePipeline, RDS) — free publish on the default bus
Cross-account event sharing without IAM gymnastics
Content-based rule routing where the routing logic varies per event
Workflows requiring event archive and replay capability
Partner event integrations (Datadog, Auth0, MongoDB Atlas, etc.) where partner publishes are free
Cron-style scheduled invocations — EventBridge Scheduler within the 14M free tier

Avoid when

Predictable high-volume fanout to a known consumer set — SNS-to-SQS is 50% cheaper
Source-to-target plumbing without meaningful logic — Pipes is cheaper than a Lambda-based forwarder
Schema Discovery left enabled on production after dev complete — pure waste
Cross-region replication enabled "just in case" without a consumer in the target region
Archive without an explicit retention period — storage grows forever

EventBridge is the right primitive for routing-heavy or AWS-service-driven workflows. For pure fanout, SNS-to-SQS is usually cheaper.

A 30-Day EventBridge Bill Cleanup Plan

Week 1 — Audit Schema Discovery. Check every event bus for an enabled discoverer. Disable on production buses where schemas are already known.

Week 2 — Audit archives. List every event archive with aws events list-archives. Apply a retention period (90–365 days typical) where none is set. Delete archives that have not been replayed in 12+ months.

Week 3 — Audit cross-region replication. Map every rule that targets a cross-region event bus against actual consumer activity in the target region. Disable replication to regions with no active consumers.

Week 4 — Audit Lambda forwarders. Find Lambda functions whose primary purpose is to forward events between services. Replace with Pipes where the logic fits the Pipes filter-and-enrich model. Each conversion removes Lambda cold-start cost and per-invocation overhead.

What This Post Doesn’t Cover

EventBridge for SaaS integrations in depth — covered in the event-driven architecture guide.
Comparison with Kinesis Data Streams — different primitive entirely (ordered streaming vs event routing); covered in the streaming-vs-eventing post.
Step Functions as a target — Step Functions has its own per-state-transition pricing; covered separately.
EventBridge Workflows (the visual workflow product) — different product, different pricing model.

If You Only Do One Thing This Week

Disable Schema Discovery on every production event bus. Run aws events list-discoverers per region; for each discoverer with a State=STARTED against a production bus, run aws events stop-discoverer --discoverer-id <id>. The schemas already discovered remain in the registry; you stop paying $0.10/M on every production event. Pair with a Service Control Policy that prevents Schema Discovery from being re-enabled in production accounts and the saving sticks.

For the broader event-driven architecture decision — when EventBridge is the right primitive vs SNS, SQS, or Kinesis — the event-driven architecture guide walks through the trade-offs.

Amazon EventBridge Pricing: Six Components, One Surprise Bill

The Six EventBridge Billing Dimensions