--- title: Amazon EventBridge Pricing: Six Components, One Surprise Bill description: EventBridge looks like a $1/million-events service. It is actually six different billing dimensions — custom events, Pipes at $0.40/M, API Destinations at $0.20/M, Schema Discovery at $0.10/M, Archive at $0.10/GB-month, and cross-region replication that doubles the publish line. Built-in AWS-service events are free; custom buses are where the bill lives. url: https://www.factualminds.com/blog/amazon-eventbridge-pricing-events-pipes-schema-archive/ datePublished: 2026-06-13T00:00:00.000Z dateModified: 2026-06-13T00:00:00.000Z author: palaniappan-p category: Cost Optimization & FinOps tags: aws-eventbridge, eventbridge-pricing, aws-pricing, cost-optimization, finops, event-driven --- # Amazon EventBridge Pricing: Six Components, One Surprise Bill > EventBridge looks like a $1/million-events service. It is actually six different billing dimensions — custom events, Pipes at $0.40/M, API Destinations at $0.20/M, Schema Discovery at $0.10/M, Archive at $0.10/GB-month, and cross-region replication that doubles the publish line. Built-in AWS-service events are free; custom buses are where the bill lives. import PricingHeroStats from '~/components/blog/PricingHeroStats.astro'; import PricingDimensionTable from '~/components/blog/PricingDimensionTable.astro'; import BillSurpriseCallout from '~/components/blog/BillSurpriseCallout.astro'; import PricingDecisionCard from '~/components/blog/PricingDecisionCard.astro'; 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](/blog/aws-eventbridge-event-driven-architecture-patterns/). For the SNS-to-SQS comparison angle, the [SNS pricing post](/blog/amazon-sns-pricing-publishes-fanout-protocols/) 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. Many teams run cron-style automation on always-on EC2 instances or on Lambda functions invoked via CloudWatch Events scheduled rules. EventBridge Scheduler is the modern replacement: time-zone-aware crons, one-time schedules, flexible time windows. It is free for the first 14M invocations per month, which covers virtually all cron workloads. The migration is non-controversial and removes the EC2-cost-for-cron pattern entirely. ## 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. Schema Discovery is enabled per event bus. Audit with `aws events list-event-buses` followed by checking each bus's discoverer configuration. Disable on production buses once the schemas are documented in the registry; the schemas remain stored even after discovery is disabled. ## 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](/blog/aws-eventbridge-event-driven-architecture-patterns/). - **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 `. 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](/blog/aws-eventbridge-event-driven-architecture-patterns/) walks through the trade-offs. ## FAQ ### 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. --- *Source: https://www.factualminds.com/blog/amazon-eventbridge-pricing-events-pipes-schema-archive/*