Amazon EventBridge Pricing: Six Components, One Surprise Bill

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.

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

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.

EventBridge vs SNS-to-SQS: The Cost Comparison

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

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:

1. 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.
2. 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

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.