Amazon EventBridge Pricing: Complete Guide + Calculator (2026)

Amazon EventBridge pricing looks straightforward until you realize you're dealing with six independently billable components, a 64 KB chunking rule that silently multiplies your bill, and charges that hit at different points in the event lifecycle. The official pricing page lists the rates, but it doesn't help you figure out what EventBridge will actually cost for your specific architecture.

Most guides out there just copy the same trivial example from AWS docs (2 million events = $5.40/month). That's not useful when you're building a cross-account event-driven system with Pipes, Scheduler, and archive/replay.

This guide breaks down every Amazon EventBridge pricing dimension with March 2026 numbers, walks through real-world cost scenarios at three different scales, compares costs with SNS and SQS, and covers the billing gotchas that catch people off guard. If you want a quick estimate, the EventBridge pricing calculator lets you model your workload in minutes.

All prices are for US East (N. Virginia) as of March 2026. Prices are consistent across most commercial regions.

Here's the full pricing summary at a glance:

How EventBridge Billing Works

The pricing confusion with EventBridge comes from one thing: charges occur at multiple points in the event lifecycle, and different components have completely different billing models. Understanding where each dollar goes is the key to controlling your bill.

EventBridge is pure pay-per-use. No upfront costs, no reserved capacity, no minimum fees. You only pay for the components you actually use. And here's something that surprises people: rule evaluation is free. You can have 300 rules on an event bus matching against every event, and you won't pay a cent for that matching logic. The charges are on ingestion, delivery, and processing.

The Six Billable Components

EventBridge has six independently billable components. Most architectures only use two or three of these, so your bill depends heavily on which features you've enabled:

1. Event Buses - The core routers that receive events and deliver them to targets. Billed on ingestion (custom and partner events) and cross-account delivery.
2. Pipes - Point-to-point integrations with built-in filtering, enrichment, and transformation. Billed per request after filtering.
3. Scheduler - Serverless scheduler for one-time or recurring tasks targeting 270+ AWS services. Billed per invocation with a generous free tier.
4. API Destinations - HTTP endpoint integrations for sending events to external APIs. Billed per event delivered.
5. Archive and Replay - Event storage and replay capability. Billed on processing, storage, and replay ingestion.
6. Schema Discovery - Automatic schema inference from events. Billed on event ingestion for discovery.

The 64 KB Payload Chunking Rule

This is the single most important billing mechanic to understand. EventBridge bills based on 64 KB chunks, not individual events. Every 64 KB of payload counts as one billable event.

For small events (under 64 KB), this doesn't matter. But with the January 2026 payload size increase from 256 KB to 1 MB, a single event can now be billed as up to 16 events:

The chunking rule applies to Event Buses, Pipes, and API Destinations. Schema Discovery uses a different chunk size of 8 KB, so a 16 KB event counts as 2 billable discovery events.

One caveat worth noting: the 1 MB payload increase is great for functionality (you can send richer events without external references), but it's a potential cost trap if you're not paying attention to payload sizes.

Before I get into the per-component breakdown, let's start with the good news: EventBridge has a surprisingly generous free tier.

EventBridge Free Tier

EventBridge's free tier is more generous than most people realize. Depending on your use case, you might run significant workloads without paying anything for EventBridge itself.

What's Always Free

These are permanently free with no monthly limits:

• AWS management event ingestion - Over 250 AWS services emit management events (control plane operations like EC2 instance state changes, S3 bucket creation, IAM policy changes) to the default event bus at zero cost. This is unlimited.
• Same-account delivery - Routing events to targets within the same AWS account is always free. You only pay for ingestion.
• Schema Registry - Storing and accessing AWS and custom schemas costs nothing.
• Partner events to unattached buses - SaaS partner events sent to event buses with no rules attached aren't charged.
• Rule evaluation - Matching events against rules is free regardless of how many rules you have.

This means you can build monitoring and automation workflows using AWS management events, deliver to same-account Lambda functions and SQS queues, and manage schemas without any EventBridge charges at all.

Monthly Free Tier Allowances

The Scheduler free tier deserves special attention. 14 million invocations per month is enough for most scheduling workloads. That's roughly 5 invocations per second, 24/7, for free. And it's a global allowance across all regions, not per-region, and it's permanent (not limited to the first 12 months of your AWS account). The unused portion doesn't roll over.

For reference, here's what doesn't have a free tier: Pipes, API Destinations, Archive processing and storage, and custom event ingestion. These start billing from the first event.

Now let's break down what each component costs when you go beyond the free tier.

Event Bus Pricing

The event bus is the core of EventBridge. It receives events, matches them against rules, and delivers them to targets. Your cost depends on three things: the type of events you're sending, whether delivery stays within the same account, and the size of your payloads.

Custom Events

Custom events are events your applications publish to EventBridge using the PutEvents API. These are the most common billable events.

• Ingestion: $1.00 per million events
• Same-account delivery: Free
• 64 KB chunking applies: a 256 KB event costs 4x

For most applications, custom event ingestion is the primary EventBridge cost. A straightforward example: 10 million custom events per month, all delivered to same-account targets = $10.00/month. Simple.

AWS Management Events

Over 250 AWS services automatically send management events to the default event bus. These are control plane operations: EC2 instances starting and stopping, S3 buckets being created, IAM policies being modified, and so on.

The key insight: ingestion of management events is completely free. You can build CloudWatch-level monitoring, compliance automation, and security alerting using these events without paying EventBridge a cent, as long as you keep delivery within the same account.

Cross-account delivery of management events costs $1.00 per million events. So if you're routing management events to a central security account, that's where charges start.

Partner Events

SaaS partner events (from services like Zendesk, Datadog, Auth0, and others) have a slightly different pricing structure:

• Ingestion: $1.00 per million events
• Cross-account delivery: $0.05 per million events (20x cheaper than custom events cross-account)

That cross-account delivery discount is significant. If you're routing partner events across accounts, you're paying $0.05/M versus $1.00/M for custom events. Something to keep in mind when designing your event routing architecture.

Cross-Account Event Delivery

Cross-account delivery is where EventBridge costs can add up, because you're potentially paying twice: once for ingestion in the source account and once for delivery to the target account.

Here's where things get interesting. In January 2025, AWS launched direct delivery to cross-account targets (SQS, Lambda, Kinesis, SNS, API Gateway). Before this feature, cross-account patterns required an intermediary event bus in the target account, meaning you'd pay for cross-account delivery AND ingestion into the target bus. Direct delivery eliminates that intermediary bus entirely.

Before direct delivery (intermediary bus pattern):

• Source bus ingestion: $1.00/M
• Cross-account delivery to target bus: $1.00/M
• Target bus ingestion: $1.00/M
• Total: $3.00 per million events

After direct delivery:

• Source bus ingestion: $1.00/M
• Cross-account delivery to target service: $1.00/M
• Total: $2.00 per million events

That's a 33% cost reduction on every cross-account event, plus less architectural complexity. If you're still using intermediary buses for cross-account routing, switching to direct delivery is a quick win.

Global Endpoints

EventBridge global endpoints provide multi-region fault tolerance for event-driven architectures. The global endpoint itself is free, but there's a billing catch.

Custom events published to a global endpoint are billed at the standard $1.00/M rate. But when events are replicated to the secondary region, that replication counts as additional custom event ingestion. So you're effectively paying double: once for the primary region and once for the secondary. Cross-region data transfer charges may also apply on top of that.

Global endpoints make sense for high-availability requirements, but factor in the double-billing when estimating costs.

Event buses handle the routing, but if you need point-to-point integrations with filtering, Pipes has a different (and potentially cheaper) pricing model.

EventBridge Pipes Pricing

Pipes connect a single source to a single target with optional filtering, enrichment, and transformation steps. The pricing model is simpler than event buses, and filtering makes it a powerful cost optimization tool.

Pipes cost $0.40 per million requests, but only requests that pass the filter are billed. Events that get filtered out don't cost you anything.

There's no free tier for Pipes.

How Pipes Billing Works

The billing mechanics are straightforward:

1. Events arrive from a source (SQS, Kinesis, DynamoDB Streams, etc.)
2. Events pass through the filter stage. Filtered-out events are not billed.
3. Remaining events are optionally enriched and transformed
4. The final request to the target is the billable event
5. Each 64 KB chunk of payload in a batch counts as one request

For SQS sources, filtered-out messages are automatically deleted from the queue. For Kinesis and DynamoDB Streams sources, filtered-out records are simply skipped and expire according to the stream's retention settings.

Cost Savings Through Filtering and Batching

Filtering is the primary cost lever with Pipes. Let me show you the math on why it matters.

Say you have 10 million events per month from an SQS source. Without filtering, that's 10M x $0.40/M = $4.00/month. Now apply a filter that only passes 25% of events, and batch 5 events per request:

• Events passing filter: 10,000,000 x 25% = 2,500,000
• Requests after batching: 2,500,000 / 5 = 500,000
• Cost: 0.5M x $0.40/M = $0.20/month

That's a 95% cost reduction from filtering and batching combined. Even a basic filter that removes 50% of events cuts your Pipes bill in half. The takeaway: always implement filters when using Pipes, even if they seem simple.

If you need scheduled tasks rather than event routing, EventBridge Scheduler is often the cheapest option thanks to its massive free tier.

EventBridge Scheduler Pricing

EventBridge Scheduler lets you create, run, and manage one-time or recurring scheduled tasks targeting over 270 AWS services and 6,000+ API operations. It's the replacement for EventBridge scheduled rules (a legacy feature you should avoid for new workloads).

The pricing is simple: $1.00 per million invocations, with a free tier of 14 million invocations per month.

Scheduler Free Tier Deep Dive

The Scheduler free tier is worth understanding in detail because it's more generous than it first appears:

• 14 million invocations per month is a global allowance across all regions (except GovCloud), not per-region
• It's permanent and not limited to the first 12 months of your AWS account
• Unused invocations don't roll over to the next month
• It covers all schedule types: cron, rate (fixed interval), one-time, and flexible time windows

For context, 14 million monthly invocations works out to about 5.4 invocations per second continuously. That covers daily cron jobs, hourly data syncs, periodic cleanup tasks, and one-time scheduled events for most organizations.

Worked example: 10 million recurring schedules that each invoke twice per month:

• Total invocations: 10M x 2 = 20M
• Free tier deduction: 20M - 14M = 6M billable
• Cost: 6M x $1.00/M = $6.00/month

If your scheduling workload fits under 14 million invocations, Scheduler is effectively free. I recommend checking whether any of your existing cron-based Lambda functions or Step Functions schedules could be migrated to Scheduler to take advantage of this.

The remaining three components (API Destinations, Archive/Replay, and Schema Discovery) round out the pricing model.

API Destinations, Archive, and Schema Discovery Pricing

These three components are less commonly used than Event Buses, Pipes, and Scheduler, but each has distinct billing mechanics worth understanding, especially if you're using archive/replay at scale.

API Destinations

API Destinations let you send events from an event bus or Pipe to any HTTP endpoint (public or private via PrivateLink/VPC Lattice).

• Cost: $0.20 per million events delivered
• 64 KB chunking applies: a 256 KB event = 4 billable events
• No free tier

The $0.20/M rate is the cheapest per-event cost in EventBridge. But watch out for additional charges: public endpoints incur standard AWS data transfer costs, and private endpoints (via PrivateLink or VPC Lattice) add their own data processing fees on top.

Worked example: 2 million events delivered to an HTTPS webhook = 2M x $0.20/M = $0.40/month (plus data transfer).

Event Archive and Replay

Archive stores events for later replay. This is useful for debugging, reprocessing failed events, or populating new downstream systems with historical data. But it has four separate billing dimensions that can add up.

The cost that catches people: replayed events are billed at the full $1.00/M custom event rate when they're re-ingested into the event bus. Replaying your entire archive is essentially re-publishing every event at full price.

Worked example: 2 million events at 6 KB average, all archived and then replayed:

• Original event publishing: 2M x $1.00/M = $2.00
• Archive processing: ~11.4 GB x $0.10/GB = $1.14
• Archive storage: ~11.4 GB x $0.023/GB = $0.26/month
• Replay: 2M x $1.00/M = $2.00
• Total: $5.40/month

Important limits to know: you can run up to 10 concurrent replays per account per region, and replayed events can't be re-archived (EventBridge prevents loops with a managed rule). Always set explicit retention periods on archives - without them, storage costs grow indefinitely at $0.023/GB/month.

Schema Registry and Discovery

• Schema Registry: Always free for both AWS and custom schemas
• Schema Discovery: $1.00 per million ingested events, with 5 million events/month free tier

Schema Discovery automatically infers event schemas by analyzing events on your bus. For most development use cases, the 5 million event free tier is more than enough, since you typically enable discovery on development buses, not production.

One billing detail: Schema Discovery uses 8 KB chunks (not the 64 KB used everywhere else). A 16 KB event counts as 2 discovery events. This is a minor cost factor but worth knowing if you're processing large events with discovery enabled.

Those are the individual component rates. But what does EventBridge actually cost in a real production environment? Let's look at three scenarios.

Real-World Cost Scenarios

Abstract per-million rates are useful for a pricing reference, but they don't answer the question you're actually asking: "What will EventBridge cost for my workload?" Here are three scenarios modeled on real production architectures, from startup to enterprise.

For a quick estimate of your specific use case, plug your numbers into the EventBridge pricing calculator.

Startup: Simple Event-Driven App (~$5/month)

Architecture: Single AWS account, one custom event bus receiving application events, delivering to Lambda functions and SQS queues in the same account.

At small scale, EventBridge is cheap. Five million events per month costs less than a cup of coffee. And if you're only using management events (EC2 state changes, S3 notifications, etc.), the EventBridge cost is literally $0.

Mid-Size SaaS: Cross-Account with Scheduler (~$30/month)

Architecture: Two AWS accounts. Account A hosts the application and event bus, receiving 20 million custom events per month. 10 million events are routed cross-account to services in Account B (using direct delivery). Scheduler handles 5 million periodic invocations per month.

The key cost driver here is cross-account delivery. It effectively doubles the per-event cost for those 10 million cross-account events ($1.00 ingestion + $1.00 delivery = $2.00/M). If you were using the old intermediary bus pattern instead of direct delivery, this total would be $40.00/month.

Enterprise: High-Volume with Archive and Replay (~$80/month)

Architecture: High-volume event processing using Pipes for SQS-to-EventBridge integration, a custom event bus for routing, full archive with 30-day retention, and monthly replay for data reprocessing.

At this scale, two things stand out. First, Pipes filtering is doing heavy lifting: 100 million source events become 2 million billable requests, keeping Pipes costs under a dollar. Second, archive processing is a significant cost driver at $19.07/month, larger than the replay cost itself. High-volume buses with large events will see archive costs climb quickly.

At those per-million rates, you might be wondering how EventBridge stacks up against SNS and SQS. Let's compare.

EventBridge vs SNS vs SQS Pricing

"Should I use EventBridge, SNS, or SQS?" is one of the most common architecture questions I see, and cost is usually a deciding factor. Here's how they compare, and I'll be honest: EventBridge is the most expensive per message. But that's not the whole story.

Per-Message Cost Comparison

At face value, EventBridge is roughly 2-2.5x more expensive per message than SNS or SQS. For a simple notification or queue workload, that premium is hard to justify.

But the per-message rate comparison misses the bigger picture.

When EventBridge Is Cheaper (and When It's Not)

EventBridge wins on total architecture cost when:

• You need content-based routing to multiple targets. Without EventBridge, you'd build this with Lambda functions parsing messages and routing them, which adds Lambda invocation costs plus the development/maintenance overhead.
• You're doing cross-account event orchestration. EventBridge has built-in cross-account delivery. With SNS/SQS, you'd need cross-account IAM policies, separate queues per consumer, and custom routing logic.
• You need archive and replay for debugging or reprocessing. Building this yourself with SNS/SQS means DynamoDB or S3 for storage plus Lambda for replay logic.
• You want schema management and discovery for event governance across teams.

SNS and SQS win when:

• You need high-throughput simple fan-out (SNS) or point-to-point messaging (SQS) without complex routing logic.
• FIFO ordering is a requirement. EventBridge doesn't offer FIFO guarantees.
• Per-message cost is the primary concern and your routing needs are simple.

The real question isn't "which service is cheapest per message?" but "which service minimizes total architecture cost?" For simple workloads, SQS or SNS. For event-driven architectures with multiple producers, consumers, and content-based routing, EventBridge's premium often pays for itself by eliminating custom routing infrastructure. The AWS messaging service decision guide covers the non-cost architectural differences in depth.

You can run the numbers for your workload using the SNS pricing calculator and SQS pricing calculator to compare with the EventBridge calculator.

Whichever service you choose, there are some non-obvious costs that can catch you off guard.

Hidden Costs and Billing Gotchas

EventBridge pricing has several traps that don't show up in the per-million rate tables. I've seen each of these surprise teams in production, and most are avoidable once you know about them.

Payload Chunking with 1 MB Events

The January 2026 payload size increase from 256 KB to 1 MB is useful, but it introduced a real billing risk. A single 1 MB event is billed as 16 events due to the 64 KB chunking rule. If you're sending 1 million 1 MB events per month, your bill isn't $1.00 - it's $16.00.

The fix is simple: store large payloads in S3 and include an S3 reference (bucket + key) in the event. This keeps the event payload small and your billing multiplier at 1x. The target service fetches the full payload from S3 when it processes the event.

Downstream Service Costs

EventBridge's bill is just the starting point. Every target service bills independently:

• A rule that delivers to a Lambda function triggers a Lambda invocation (and execution time charges)
• A rule with 5 targets means 5 separate downstream invocations per matching event
• Pipes enrichment using Lambda, API Gateway, or Step Functions adds those services' costs on top of the $0.40/M Pipes charge
• Step Functions state transitions, SQS message charges, SNS publish charges all add up

If your event bus routes to 3 Lambda targets, you're paying $1.00/M for EventBridge ingestion plus 3x Lambda invocation costs. If your Lambda targets use provisioned concurrency, factor in those Lambda invocation costs as well. Use the Lambda pricing calculator to estimate the downstream impact.

Cross-Region Data Transfer

Cross-region event delivery incurs standard AWS data transfer charges on top of EventBridge pricing. This includes global endpoint event replication, where events replicated to the secondary region are billed as custom events in both regions, plus data transfer fees.

For high-volume cross-region architectures, data transfer can become a meaningful line item. I'd recommend calculating data transfer costs separately when planning multi-region EventBridge deployments.

Now that you know where the costs hide, here's how to keep your EventBridge bill as low as possible.

How to Reduce Your EventBridge Bill

EventBridge costs are already modest for most workloads, but there's no reason to pay more than necessary. These six strategies are ordered by impact, from the easiest wins to the more involved optimizations. For broader cost management context, check out AWS cost optimization best practices.

Leverage Free Management Events

This is the lowest-hanging fruit. Over 250 AWS services emit management events to the default event bus at no charge. Before you publish custom events, check whether an existing management event already captures the state change you need.

For example, instead of building a custom notification system that polls for EC2 instance state changes and publishes events, just create a rule on the default bus matching aws.ec2 source events with EC2 Instance State-change Notification detail type. Zero EventBridge cost (same-account delivery), and you get near-real-time notifications.

Use Cross-Account Direct Delivery

If you're still using the intermediary event bus pattern for cross-account routing, switch to direct delivery. It eliminates the target bus ingestion charge, saving roughly 33% on cross-account event costs (from $3.00/M to $2.00/M). Direct delivery supports SQS, Lambda, Kinesis, SNS, and API Gateway as cross-account targets.

This is especially valuable if you follow multi-account best practices and route events between workload accounts and shared services accounts.

Minimize Payload Sizes

Keep event payloads under 64 KB whenever possible to avoid the chunking multiplier. For events that need to carry large data:

• Store the payload in S3 and include the bucket/key reference in the event (the "claim check" pattern)
• Strip unnecessary fields before publishing
• Avoid embedding Base64-encoded files in event payloads

A single event going from 65 KB to 64 KB saves you from being billed for 2 events instead of 1. At scale, that's a 50% reduction.

Filter Aggressively in Pipes

Since Pipes only charges for requests that pass the filter, filtering is the most direct cost lever available. Always implement filters, even basic ones that exclude obvious noise. For detailed guidance on writing cost-effective event patterns, see the EventBridge event pattern best practices. Combine filtering with batching for maximum savings.

As I showed in the Pipes section, a 75% filter rate combined with batching of 10 events reduces costs from $4.00/month to $0.20/month on a 10M event workload. That's a 95% reduction.

Control Archive Costs

Three rules for managing archive costs:

1. Set explicit retention periods on every archive. Without them, storage grows indefinitely.
2. Use event patterns on archives to store only the events you'd actually replay, rather than archiving everything.
3. Monitor storage growth for high-volume buses. At $0.023/GB/month, a bus processing 50 million 10 KB events per month accumulates 500 GB/month in archive storage ($11.50/month). With 90-day retention, that's ~1.5 TB and $34.50/month in storage alone.

Monitor with CloudWatch Metrics

EventBridge publishes 20+ CloudWatch metrics for event buses (added November 2023, at no extra charge). Use these to catch cost issues early:

• Track event payload sizes to identify oversized events getting billed as multiple events
• Monitor failed invocations, since retries increase downstream service costs
• Watch for throttled events that indicate you're approaching quota limits

Set CloudWatch alarms on unexpected spikes in event volume or payload size. Catching an application bug that sends 10x normal event volume is worth the 5 minutes it takes to set up a billing alarm.

EventBridge doesn't offer Savings Plans, but downstream Lambda targets can benefit from Compute Savings Plans to reduce invocation costs.

Key Takeaways

Amazon EventBridge pricing comes down to a few core points:

1. Six independently billable components, but most architectures use only two or three. You pay only for what you use, with no minimums or upfront commitments.
2. The 64 KB chunking rule is the biggest gotcha. Keep payloads under 64 KB or use the S3 claim check pattern. A 1 MB event costs 16x a small event.
3. Real-world costs are modest. ~$5/month for a startup, ~$30/month for mid-size cross-account architectures, ~$80/month for enterprise with archive and replay.
4. EventBridge costs more per message than SNS/SQS, but the premium pays for itself in complex routing scenarios that would otherwise require custom Lambda routing functions.
5. Cross-account direct delivery and Pipes filtering are the two highest-impact optimization levers. Direct delivery saves 33% on cross-account costs, and Pipes filtering can reduce costs by 95%+.

Model your specific workload using the EventBridge pricing calculator to get an accurate monthly estimate. And for broader cost estimation across your full AWS stack, check out the guide on estimating your AWS costs or explore our full collection of AWS cost estimation tools.

Building event-driven architectures with CDK or Terraform? Follow AWS CDK best practices and start catching cost surprises during code review. It's a lot cheaper than finding them on your monthly bill.

What's driving your EventBridge costs? Have you run into billing surprises beyond what's covered here? Drop your experience in the comments.

Frequently Asked Questions