Amazon SNS Pricing: Complete Guide + Calculator

Amazon SNS pricing looks deceptively simple: $0.50 per million API requests. But then you discover that a 256KB message counts as four requests, FIFO topics bill you three different ways, and SMS costs vary by country, carrier, and origination identity type. The official pricing page lists every rate, but it doesn't answer the question that actually matters: what will SNS cost for my specific workload?

This guide breaks down every Amazon SNS pricing component with current numbers, walks through real-world cost scenarios, and exposes the billing gotchas that catch teams off guard. If you want a quick estimate, the SNS pricing calculator lets you model your workload in minutes.

All prices are for US East (N. Virginia) as of March 2026. Prices vary by region.

Amazon SNS Pricing at a Glance

Amazon SNS is fully pay-as-you-go. No upfront fees, no minimum commitments, no long-term contracts. Your bill depends on what you publish, where you deliver, and which optional features you enable.

Here's the full pricing summary for quick reference:

The SNS free tier is permanent. It doesn't expire after 12 months like some AWS services. For dev/test and low-volume production workloads sending to SQS or Lambda, SNS can effectively cost nothing.

One gotcha to keep in mind: Standard topic billing uses 64KB chunks. A 256KB message counts as 4 API requests and 4 deliveries per endpoint. I'll explain the full cost impact later.

For a custom estimate based on your volumes, try the SNS pricing calculator.

How Amazon SNS Pricing Works

Before diving into per-component rates, it helps to understand how SNS meters charges. There are four cost dimensions: API requests (publishing messages), notification deliveries (varies by endpoint type), data transfer, and optional features (filtering, archiving, data protection). The endpoint you deliver to has the biggest impact on your per-message cost.

SNS supports two topic types, and they use fundamentally different billing models.

Standard Topics

Standard topics are the default choice for most workloads. They deliver messages with high throughput and best-effort ordering, and they support all endpoint types (SQS, Lambda, HTTP, email, push, SMS). Billing is based on 64KB chunks: each 64KB of published or delivered data counts as one request or one delivery. A 10KB message is one request. A 256KB message is four.

FIFO Topics

FIFO (First In, First Out) topics provide strict message ordering and exactly-once deduplication. The trade-off: they only deliver to SQS queues, and they use a triple-billing model. You pay separately for published messages, subscribed messages (multiplied by the number of subscriptions), and payload data per GB. This makes FIFO topics more expensive at scale, but they're required when message ordering matters.

Standard Topic Pricing

Standard topics are the most commonly deployed SNS configuration. The pricing has two components: what you pay to publish messages, and what you pay to deliver them.

API Request Costs

Every Publish, PublishBatch, topic owner operation, and subscription owner operation counts as an API request. The rate is $0.50 per 1 million requests, with the first 1 million per month free.

The critical detail is the 64KB chunking model. Each 64KB of published data counts as a separate request:

The PublishBatch API lets you send up to 10 messages in a single request (max 256KB total). Since you're billed per request, batching 10 small messages into one call reduces API costs by up to 90%.

Notification Delivery Costs by Endpoint

Delivery costs also follow the 64KB chunking model (except SMS). Each 64KB chunk of delivered data counts as one delivery.

The zero delivery cost for SQS, Lambda, and Firehose is a big deal. If you're building event-driven architectures where SNS fans out to SQS queues or Lambda functions, you're only paying for the publish side (plus data transfer, which I'll cover separately). Keep in mind that the SQS side still incurs per-request charges, so check the Amazon SQS pricing breakdown before estimating your total messaging costs.

Standard Topic Cost Example

Let's say you're running an event-driven microservice that publishes 5 million messages per month (average 10KB each) to a Standard topic with 3 SQS subscribers and 1 HTTP webhook.

Under five dollars a month for 5 million messages to 4 endpoints. That's the power of using SQS as your primary delivery target. If all four subscribers were HTTP endpoints instead, delivery costs alone would jump to roughly $12.

FIFO Topic Pricing

FIFO topics use a completely different billing model than Standard topics, and it's where I see the most billing confusion. The costs look low on paper ($0.30 per million) until you realize the subscription multiplication effect.

How FIFO Billing Differs from Standard

Standard topics have two cost components: API requests and deliveries. FIFO topics have three:

1. Published messages ($0.30 per 1 million): What you send to the topic
2. Subscribed messages ($0.30 per 1 million): Published messages multiplied by the number of subscriptions
3. Payload data ($0.11 per GB): Charged for both published and subscribed payload

Each message from 1KB to 256KB counts as one message (anything under 1KB rounds up to 1KB). Also note that API requests for topic management (CreateTopic, Subscribe) are still charged at the standard rate of $0.50 per million.

FIFO Cost Calculation Example

Publishing 10 million messages (average 2KB each) to a FIFO topic with 3 SQS subscriptions:

That's $20.80 for the same type of workload that would cost about $5 on a Standard topic with 3 SQS subscribers. The subscription multiplication is what gets you: each additional subscriber multiplies both the subscribed message count and the subscribed payload cost.

Standard vs FIFO: When Is FIFO Worth the Premium?

Here's the same 10 million messages (2KB average) with 3 SQS subscribers on both topic types:

FIFO costs roughly 4.6x more for this workload. That premium is justified when you need strict message ordering (financial transactions, order processing), exactly-once deduplication, or message grouping for parallel ordered processing.

If your workload tolerates best-effort ordering and at-least-once delivery, Standard topics save you significant money, especially as subscriber count grows.

SMS Messaging Costs

SMS is by far the most expensive component of Amazon SNS pricing. Unlike other endpoints where pricing is straightforward per-delivery, SMS costs stack up from three different sources: the SNS API request, the per-message SMS delivery fee, and monthly origination identity leases.

There's no SMS free tier, and you're charged even for failed delivery attempts to invalid phone numbers.

Per-Message SMS Costs

SMS delivery rates vary by destination country, carrier, and message type. AWS doesn't publish a flat per-message rate. Instead, costs depend on:

• Destination country and carrier: US rates differ from India rates, and T-Mobile rates may differ from AT&T
• Message type: Transactional messages (MFA codes, OTPs) cost more than promotional messages in countries that support promotional routes
• SNS API request: You still pay $0.50 per million requests on top of the SMS delivery charge

For US destinations, expect roughly $0.00581 per SMS segment for transactional messages. For exact rates by country, check the AWS SMS pricing page.

One more thing to watch: the default SMS spend threshold is $1.00 per account. You'll need to request an increase through AWS Support before sending any meaningful SMS volume.

Multi-Part Message Billing

Each SMS can carry up to 140 bytes of data. Messages exceeding this limit are automatically split into multiple segments, and you pay for each one:

A 320-character GSM-7 message splits into 3 segments (ceil(320/153)), so you're billed for 3 SMS deliveries. If your messages include emoji or non-Latin characters, UCS-2 encoding kicks in and a 150-character message becomes 3 segments instead of 1.

Origination Identity Costs (10DLC, Toll-Free, Short Codes)

For US destinations, you must purchase a dedicated origination identity. This is a monthly recurring cost on top of per-message fees.

10DLC (10-Digit Long Code) is the standard option for most use cases:

Toll-free numbers work for lower-volume use cases:

Dedicated short codes are the enterprise high-throughput option:

For most teams, 10DLC at $11/month (campaign + number) is the right starting point. Short codes at $995/month only make sense when you need the throughput and brand recognition of a 5-6 digit number.

The November 2024 Billing Change

Starting November 1, 2024, SMS charges appear under AWS End User Messaging on your AWS bill, not under Amazon SNS. This affects how you track SMS costs in Cost Explorer and how you set up cost allocation tags.

If you're wondering why your SNS line item dropped while a new "End User Messaging" charge appeared, this is why. Your actual costs didn't change, just the billing label.

Message Filtering, Archiving, and Data Protection Costs

SNS offers three add-on features that each have their own pricing model. The key thing to know upfront: attribute-based message filtering is free, which makes it the default recommendation over payload-based filtering.

Message Filtering (Free vs Paid)

SNS message filtering lets subscribers receive only a subset of messages published to a topic. There are two types, and the cost difference is significant:

Attribute-based filtering: Free. Filter policies evaluate message attributes (key-value metadata attached to the message). No additional charge beyond standard publish and delivery costs.

Payload-based filtering: $0.06 per GB scanned. Filter policies evaluate the message body content. Both filtered (rejected) and delivered messages count toward the scanned data volume, with a minimum billing unit of 1KB per outbound message.

Here's what that looks like in CDK with cost annotations:

// Attribute-based filtering: FREE
topic.addSubscription(
  new subscriptions.LambdaSubscription(fn, {
    filterPolicy: {
      eventType: sns.SubscriptionFilter.stringFilter({
        allowlist: ['order_placed', 'order_cancelled'],
      }),
    },
  })
);

// Payload-based filtering: $0.06 per GB scanned
topic.addSubscription(
  new subscriptions.LambdaSubscription(fn, {
    filterPolicyWithMessageBody: {
      order: sns.FilterOrPolicy.policy({
        type: sns.FilterOrPolicy.filter(
          sns.SubscriptionFilter.stringFilter({
            allowlist: ['premium', 'enterprise'],
          })
        ),
      }),
    },
  })
);

The takeaway: always put filtering criteria in message attributes instead of the message body when possible. It's a free optimization that requires minimal code changes.

Message Archiving and Replay (FIFO Only)

FIFO topics support message archiving with configurable retention from 1 to 365 days. Pricing:

The minimum billing of 1 day per message is a gotcha for high-volume topics. Even if you set a 1-day retention period, each message is charged for at least 1 full day of storage.

Standard topics don't have built-in archiving. The workaround is subscribing an Amazon Data Firehose delivery stream to route messages to S3, but that comes with Firehose and S3 charges.

Message Data Protection

Message data protection scans messages in transit to audit, mask, redact, or block sensitive data (PII, PHI). Available for Standard topics only.

Three operations are supported: audit (sample and log findings), de-identify (mask or redact sensitive data), and deny (block delivery if sensitive data is detected). All three are charged at the same scanning rate.

Data Transfer Costs

Data transfer is the cost dimension that surprises people most with AWS SNS pricing. Here's the counterintuitive part: even though SQS and Lambda deliveries have no per-notification charge, data transfer from SNS to these services is charged at internet data transfer rates. If your SNS consumers include ECS services, factor in the ECS pricing as well.

New AWS customers get 15 GB of free data transfer out per month for the first 12 months, aggregated across all AWS services including SNS. Data transfer tiers aggregate across services, so understanding how DynamoDB pricing and other services contribute helps with total cost estimation.

For most workloads with small messages (under 10KB), data transfer costs are negligible. But if you're publishing large payloads at high volume to SQS or Lambda, this adds a cost layer you might not expect. This is another reason to keep messages small and use references (S3 keys, database IDs) instead of embedding full payloads.

Amazon SNS Free Tier

The SNS free tier is one of the most generous among AWS messaging services, and it never expires. This isn't the "12-month new customer" free tier. It's permanent.

Free tier usage is calculated monthly across all regions and automatically applied to your bill. It doesn't accumulate from month to month.

For development, testing, and low-volume production workloads that deliver to SQS or Lambda, SNS can run at $0/month indefinitely. The combination of 1 million free API requests and zero-cost SQS/Lambda deliveries means you're only paying for data transfer, which is also free for the first GB per month.

The notable gap: no SMS free tier at all. Every SMS message is billed from the first one.

Billing Gotchas and Hidden Costs

This is where SNS pricing gets tricky. I've seen teams get surprised by these charges because they're not obvious from the standard rate tables.

The 64KB Chunking Multiplier

Standard topic billing counts each 64KB chunk as a separate request (publish side) and a separate delivery (delivery side). This applies to both directions.

Here's the real cost impact of a 256KB message delivered to 3 HTTP subscribers:

What looks like 4 billing events is actually 16. At scale, this 4x multiplier on large messages can be a meaningful cost driver. The fix is straightforward: keep messages small. Send a reference (S3 key, database ID, event ID) and let subscribers fetch the full payload when needed.

KMS Encryption Cost Multiplication

When you enable server-side encryption with AWS KMS on an SNS topic, each API interaction generates KMS calls:

• Each Publish call = 1 GenerateDataKey KMS call
• Each delivery to each subscriber = 1 Decrypt KMS call

For a topic with 5 subscribers, a single publish generates 6 KMS calls (1 encrypt + 5 decrypt). At $0.03 per 10,000 KMS requests:

$180/month just for encryption on a high-volume topic. Consider whether you need encryption at rest, or if the AWS-managed SNS key (aws/sns) works for your compliance requirements (it has lower costs than customer-managed keys).

Data Transfer from SNS to SQS/Lambda Is Not Free

This trips people up because the pricing page clearly states no per-notification delivery charge for SQS and Lambda. That's true. But in the same section, it also states that data transfer from SNS to these services is charged at internet data transfer rates, even within the same region.

For small messages (1-10KB) at moderate volumes, this cost is negligible - maybe a few cents. But at 100 million 10KB messages per month (roughly 1 TB of transfer), that's $90 in data transfer costs that you might not have budgeted.

Failed SMS Delivery Charges

You can be charged for SMS delivery attempts to invalid phone numbers. If the destination carrier reports the attempt, AWS bills for it. The mitigation is simple: validate phone numbers before sending, and use the phone number validation APIs to catch bad numbers before they cost you money.

Archive Minimum Billing and Payload Filtering Costs

Two smaller gotchas worth knowing:

• Archive minimum billing: Each archived FIFO message has a minimum storage charge of 1 day, regardless of your retention period or when the message expires.
• Payload filtering double-counting: Both filtered (rejected) and successfully delivered messages count toward the payload data scanned. If you're filtering 90% of messages, you're still paying for scanning 100% of the data.

How to Optimize Your SNS Costs

Here are the Amazon SNS pricing optimization strategies sorted by impact. Most of these take minutes to implement.

1. Use PublishBatch for Standard topics. Batching 10 messages per API call reduces request costs by up to 90%. Publishing 10 million messages individually costs $5.00 in API fees. Batching them in groups of 10 costs $0.50. This is the single biggest lever for most workloads.

2. Choose Standard over FIFO when strict ordering isn't required. As the comparison above showed, FIFO can cost 4-5x more for the same workload. Unless you need exactly-once deduplication or strict ordering, Standard topics are the cost-effective default.

3. Deliver to SQS, Lambda, or Firehose whenever possible. These endpoints have zero per-notification delivery charges. HTTP endpoints cost $0.06 per 100K, and email costs $2.00 per 100K. When you have flexibility in endpoint choice, SQS or Lambda subscriptions give you the lowest total delivery cost.

4. Use attribute-based filtering instead of payload-based. Attribute-based filtering is free. Payload-based costs $0.06 per GB. Move your filtering criteria from the message body into message attributes. It's a code change, not an architecture change.

5. Keep messages small. Send references instead of full payloads. For Standard topics, every 64KB chunk is a separate billing event for both publishing and delivery. A 256KB message costs 4x what a 10KB message costs.

6. Minimize SMS costs. Use 10DLC ($11/month) instead of short codes ($995/month) unless you need high throughput. Set the account-level SMS spend limit to prevent runaway charges. Validate phone numbers before sending. Use the promotional message type for non-critical messages in countries where it's supported.

7. Evaluate KMS encryption costs. If you have high-volume topics with multiple subscribers, KMS costs can add up fast. Use the AWS-managed aws/sns key for lower costs, or assess whether encryption at rest is a compliance requirement for your specific topics.

8. Right-size archiving retention. FIFO topic archiving at $0.10 per GB-month with a minimum 1-day billing per message adds up on high-volume topics. Set the retention period to the minimum your replay requirements need, not the maximum 365 days.

9. Leverage the perpetual free tier. The free tier covers 1 million requests and 1 million push notifications every month, permanently. Architect dev/test environments and low-volume production workloads to stay within these limits.

10. Monitor with CloudWatch and AWS Budgets. Track NumberOfMessagesPublished, NumberOfNotificationsDelivered, NumberOfNotificationsFailed, and PublishSize metrics. Set up AWS Budgets alerts for SNS spending to catch cost anomalies early. You can even test CloudWatch alarms via CLI to verify your alerting pipeline works.

For a broader framework on reducing AWS spending beyond SNS, check out the AWS cost optimization best practices guide.

Real-World Cost Scenarios

These three scenarios cover the most common SNS deployment patterns. All calculations use US East (N. Virginia) pricing with free tier deductions applied.

Event-Driven Microservices (Standard Topic Fan-Out)

Architecture: Standard topic with 5 SQS queue subscribers and 1 HTTP webhook, publishing 10 million messages per month at an average size of 5KB.

Optimization: Using PublishBatch to send 10 messages per API call would reduce the API request line from $4.50 to $0.45, bringing the total under $11.

Mobile Push Notification System

Architecture: Standard topic with mobile push delivery (APNs and FCM) for a consumer app sending 2 million notifications per month at an average size of 4KB.

For apps with under 1 million monthly active users sending one push notification per month, the free tier covers the entire cost. This workload is nearly free.

SMS Verification Service

Architecture: Standard topic with SMS delivery to US destinations, sending 50,000 verification codes per month via 10DLC.

SMS dominates the cost at over 96% of the total. The SNS infrastructure itself is nearly free because the API request volume stays within the free tier. This is why SMS cost optimization (validating numbers, using toll-free for lower volumes, setting spend limits) matters far more than optimizing the messaging layer for SMS-heavy workloads.

For a precise estimate with your specific volumes, use the SNS pricing calculator.

Key Takeaways

Amazon SNS pricing is pay-as-you-go with a generous permanent free tier that covers most development and low-volume production workloads. Standard topics are simpler and cheaper. Only use FIFO when you need strict message ordering or exactly-once deduplication, because the subscription multiplication in FIFO billing can drive costs 4-5x higher for the same message volume.

SQS and Lambda endpoints have no per-notification delivery charge, making them the most cost-effective delivery targets. Watch for hidden costs: 64KB chunking multiplies billing on large messages, KMS encryption generates N+1 calls per publish (where N is your subscriber count), and data transfer from SNS to SQS/Lambda is charged at internet rates even within the same region.

PublishBatch is the single biggest optimization lever for Standard topics, cutting API costs by up to 90%. For SMS workloads, the per-message delivery fee dwarfs everything else, so phone number validation and spend limits matter more than messaging infrastructure optimization. If your architecture involves SNS with SQS, model the SQS side using the SQS pricing calculator.

Run your workload through the SNS pricing calculator to estimate your specific monthly cost. For teams adopting a shift-left FinOps approach, catching these SNS costs during code review is more effective than discovering them on your monthly bill. Deploy SNS infrastructure via CDK or Terraform following AWS CDK best practices and estimate your AWS costs before deploying.

What's driving your SNS costs? Have you hit any billing surprises beyond what's covered here? Drop your experience in the comments.

Frequently Asked Questions