---
title: Amazon SNS Pricing: Why a Single Publish Can Bill as Four Charges
description: SNS bills publish and delivery separately. Standard topic publish is $0.50/M, but HTTP delivery is $0.60/M on top, email is $2/100K, SMS varies by country, and mobile push is $0.50/M. A single publish to a topic fanned out to four protocols generates four billable lines, five if you count the cross-region data transfer.
url: https://www.joinhorizon.co/blog/amazon-sns-pricing-publishes-fanout-protocols/
datePublished: 2026-06-13T00:00:00.000Z
dateModified: 2026-10-28T00:00:00.000Z
author: kevin-w
category: Cost Optimization & FinOps
tags: aws-sns, sns-pricing, aws-pricing, cost-optimization, finops, messaging
---

# Amazon SNS Pricing: Why a Single Publish Can Bill as Four Charges

> SNS bills publish and delivery separately. Standard topic publish is $0.50/M, but HTTP delivery is $0.60/M on top, email is $2/100K, SMS varies by country, and mobile push is $0.50/M. A single publish to a topic fanned out to four protocols generates four billable lines, five if you count the cross-region data transfer.

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';
import PricingCalculatorCta from '~/components/blog/PricingCalculatorCta.astro';

Amazon SNS looks straightforward on the pricing page: $0.50 per million publishes for Standard topics, $0.30 per million for FIFO. The bill is almost never that simple. SNS separates _publishing_ from _delivery_, and the delivery side bills at a different per-protocol rate for each subscriber type: HTTP at $0.60 per million, email at $2 per hundred thousand, and SMS at variable per-country rates that can exceed $0.50 per single message in long-tail countries. A topic fanning out one publish to four protocols generates four separate billable lines, before counting cross-region data transfer.

> **Amazon SNS pricing** splits into publish charges and per-protocol delivery fees. SMS, email, HTTP, and SQS fan-out bill differently. In us-east-1 (June 2026), publishes cost $0.50 per million. Most surprises come from SMS country rates, HTTP retry storms, and fan-out to many HTTP endpoints instead of SQS.

| Action        | us-east-1        | Notes                         |
| ------------- | ---------------- | ----------------------------- |
| Publish       | $0.50/M          | Per message published         |
| SQS delivery  | Free             | Best fan-out pattern          |
| HTTP delivery | $0.60/M          | Retry storms add up           |
| SMS           | Country-specific | Often dominates mobile alerts |

<PricingHeroStats
  stats={[
    { value: '$0.50', label: 'Standard publish / M', note: '$0.30/M for FIFO + $0.017/GB payload' },
    { value: 'Free', label: 'SQS + Lambda delivery', note: 'Internal AWS subscribers are billing-free' },
    { value: '$2.00', label: 'Email / 100K', note: '40× more expensive than mobile push' },
    { value: '20–50×', label: 'SMS country variance', note: 'US ~$0.012; long-tail $0.50+' },
  ]}
  caption="us-east-1 list prices, June 2026. SMS rates vary by destination country and carrier. Source: [AWS Pricing page](https://aws.amazon.com/sns/pricing/), us-east-1, retrieved June 2026."
/>
<PricingCalculatorCta blogSlug="amazon-sns-pricing-publishes-fanout-protocols" />

This post is the bill story. For SNS architecture patterns (fanout, filtering, retry semantics, and DLQ wiring), the [event-driven async messaging guide](https://www.joinhorizon.co/blog/aws-event-driven-async-messaging-boundaries/) covers the design side. For the queue side of SNS-to-SQS fanout, the [SQS pricing post](https://www.joinhorizon.co/blog/amazon-sqs-pricing-64kb-rule-fifo-vs-standard/) covers the receiving end.

## The two-layer SNS bill: publish plus delivery

The biggest source of SNS bill surprises is forgetting that publish and delivery are billed separately. A single Publish call costs the per-million publish rate. Every subscriber that receives that publish then bills _separately_ at the per-protocol delivery rate.

<PricingDimensionTable
  title="SNS pricing breakdown, us-east-1, June 2026"
  intro="Publish bills once per topic regardless of subscriber count. Delivery bills per subscriber per delivery at the per-protocol rate."
  region="us-east-1"
  dimensions={[
    {
      name: 'Standard topic publish',
      unitPrice: '$0.50 / million',
      example: '10M publishes / month',
      monthly: '$5.00',
      note: 'First 1M free per month, account-wide',
      highlight: true,
    },
    {
      name: 'FIFO topic publish',
      unitPrice: '$0.30 / million + $0.017 / GB payload',
      example: '5M publishes × 5 KB avg',
      monthly: '~$1.93',
      note: 'Lower per-publish but adds payload data line',
    },
    {
      name: 'HTTP/HTTPS delivery',
      unitPrice: '$0.60 / million',
      example: '10M publishes × 1 HTTP sub',
      monthly: '$6.00',
      note: 'Per delivery; failed retries bill too',
      highlight: true,
    },
    {
      name: 'Email / Email-JSON',
      unitPrice: '$2.00 / 100K',
      example: '500K emails / month',
      monthly: '$10.00',
      note: '40× the price of mobile push',
    },
    {
      name: 'SMS (US)',
      unitPrice: '~$0.012 / SMS (US, incl. carrier fee)',
      example: '100K SMS / month',
      monthly: '$1,200',
      note: 'Cheapest SMS rate; price varies by carrier',
    },
    {
      name: 'SMS (international long-tail)',
      unitPrice: 'Up to $0.50+ / SMS',
      example: '10K SMS to long-tail countries',
      monthly: '$5,000+',
      note: 'Highest variance line in SNS',
      highlight: true,
    },
    {
      name: 'Mobile push (APNS, FCM, ADM)',
      unitPrice: '$0.50 / million',
      example: '10M push notifications',
      monthly: '$5.00',
      note: 'Cheapest user-facing delivery channel',
    },
    {
      name: 'SQS subscription delivery',
      unitPrice: 'Free',
      example: '100M deliveries',
      monthly: '$0.00',
      note: 'SQS side bills the receive separately',
      highlight: true,
    },
    {
      name: 'Lambda subscription delivery',
      unitPrice: 'Free',
      example: '100M invocations',
      monthly: '$0.00',
      note: 'Lambda side bills the invocation separately',
    },
    {
      name: 'Kinesis Data Firehose delivery',
      unitPrice: '$0.85 / million',
      example: '50M events / month',
      monthly: '$42.50',
      note: 'Plus Firehose ingestion + delivery charges',
    },
    {
      name: 'Cross-region delivery transfer',
      unitPrice: '$0.02 / GB',
      example: 'Multi-region SQS fanout',
      monthly: 'Variable',
      note: 'On top of the publish + delivery cost',
    },
  ]}
  footnote="The SQS and Lambda delivery being free is what makes SNS-to-SQS fanout the cheapest internal-distribution pattern on AWS."
/>

_If you only audit one dimension first, route internal fan-out through **SNS to SQS**, since delivery to SQS is free._

## Worked example: one publish, four charges

Consider an order-confirmation topic with four subscribers: SQS (for downstream processing), Lambda (for analytics), Email (for the customer), and Mobile Push (for the app notification). One publish, four deliveries:

- 1 publish × $0.50/M = base cost
- SQS delivery: free
- Lambda delivery: free
- Email delivery: $2/100K = $0.00002 per delivery
- Mobile push: $0.50/M = $0.0000005 per delivery

For 10M publishes/month with this fanout:

- Publish: $5
- SQS delivery: $0
- Lambda delivery: $0
- Email delivery: $200 (10M × $0.00002)
- Mobile push: $5

Email dominates the bill at 40× the publish rate. This is invisible if you only think about the publish line, and it gets dramatically worse with SMS.

## The SMS trap

![Architecture diagram of an SNS message delivered to SQS and the same style of message delivered as SMS](../../assets/images/blog/amazon-sns-pricing-publishes-fanout-protocols-sms.webp)

_Figure: protocol choice in the article. The rows are alternatives. A queue delivery and an SMS delivery are billed differently. The article's SMS rates stay in the post. [Open the draw.io source](https://www.joinhorizon.co/examples/architecture-blog-2026/amazon-sns-pricing-publishes-fanout-protocols/sms.drawio)._

SMS is the highest-variance line item in SNS. United States rates are reasonable (about $0.012/SMS including the carrier fee, October 2026). International rates vary by country and carrier from ~$0.04 to over $0.50 per single message. A B2C app sending one two-factor code a day to 100K users generates about 3M SMS a month, roughly $36,000 at the US rate alone and more once international destinations are included.

The common patterns to mitigate:

1. **Cap global rate per recipient.** A user receiving five SMS in a minute is almost always a misconfiguration; rate-limit at the application layer.
2. **Use AWS End User Messaging or a dedicated SMS provider** for high-volume SMS. End User Messaging (the SMS and voice service that replaced Pinpoint's messaging features) gives you registered origination numbers, short codes, phone pools, and SMS Protect fraud filtering. For codes, its Notify feature runs OTP end to end. See the [End User Messaging SMS guide](https://www.joinhorizon.co/blog/aws-end-user-messaging-sms-guide-2026/). SNS is fine for low-volume operational alerts; it is rarely the right primitive for high-volume customer SMS.
3. **Default to mobile push or email** for app-installed users. Push at $0.50/M is roughly 1,000,000× cheaper than long-tail-country SMS ($0.0000005 per push against $0.50 per SMS) for the same notification.
4. **Set a monthly SMS spend limit** per AWS account via the SNS SMS spend limit configuration. This is a hard cap; once hit, further SMS is dropped until the next month or you raise the limit.

<BillSurpriseCallout
  variant="surprise"
  title="2FA SMS to a global user base via SNS"
  amount="$36,000+/month at 100K codes a day"
>
  Two-factor codes via SNS SMS look cost-effective at the per-message US rate but compound when traffic comes from
  countries with high SMS rates. A retail app launching in Brazil, India, and Indonesia can see SMS spend triple within
  weeks of expansion. Cap the SNS SMS spend limit aggressively (a few hundred dollars per month) as a safety net, and
  move the production code path to End User Messaging Notify, which generates, sends, and verifies the code with
  mandatory SMS Protect, a 10-messages-per-number daily cap, and text, voice, or WhatsApp delivery (October 16, 2026).
</BillSurpriseCallout>

## HTTP delivery and retry storms

HTTP and HTTPS delivery at $0.60/M is the most expensive non-user-facing protocol (Kinesis Firehose is more expensive but rarely used at this junction). Most of the cost comes from retries against failing endpoints.

By default, SNS retries a failed HTTP delivery up to three times, 20 seconds apart. A custom delivery policy is capped at 3,600 seconds of total retry time. Every retry attempt is a billable delivery, so a topic with an HTTP subscription pointed at a chronically failing endpoint bills up to four delivery attempts per message with no successful messages reaching the subscriber.

<BillSurpriseCallout
  variant="trap"
  title="HTTP subscription with no DLQ + a failing endpoint"
  amount="Up to 4 billed attempts per message at $0.60/M"
>
  Configure a redrive policy that routes failed deliveries to an SQS DLQ after 3 to 5 retries. The DLQ accepts the failed
  messages cheaply (one SQS write at $0.40/M) instead of SNS retrying every message at $0.60/M per attempt.
  Pair with a CloudWatch alarm on `NumberOfNotificationsFailed` per topic.
</BillSurpriseCallout>

## Message filtering is free but needed at scale

![Architecture diagram of an SNS topic delivering every message and the same topic filtered to one subscriber](../../assets/images/blog/amazon-sns-pricing-publishes-fanout-protocols-filter.webp)

_Figure: subscription filters in the article. The rows are alternatives. Without a filter, a publish is delivered to every subscriber. A filter delivers only the matching messages. The large-payload fan-out is an earlier diagram. Rates stay in the article. [Open the draw.io source](https://www.joinhorizon.co/examples/architecture-blog-2026/amazon-sns-pricing-publishes-fanout-protocols/filter.drawio)._

SNS message filtering lets a subscription declare a filter policy (a JSON expression over message attributes) so only matching publishes are delivered. The filter evaluation is free, but the publish still bills. The saving is on the delivery side.

For a topic with 100 subscribers where each publish is only relevant to one subscriber, no filtering means 100× delivery charges per publish. With filtering, only the matching subscriber receives the delivery. On high-fanout topics with mixed-interest subscribers, filtering routinely cuts the delivery bill by 90%+.

## When to use SNS vs alternatives

<PricingDecisionCard
  headline="SNS for known-consumer fanout; EventBridge for rule-based routing; End User Messaging for high-volume SMS; direct-call for synchronous low-latency."
  useWhen={[
    'One-to-many fanout to a known set of internal AWS consumers (SQS, Lambda), the cheapest pattern on AWS',
    'Multi-protocol delivery to email, mobile push, and HTTP from a single publish',
    'Cross-account event publishing where consumers manage their own SQS queues',
    'Low-volume operational SMS alerts (on-call notifications, monitoring escalations) within US-only territory',
    'FIFO topics for ordered fanout to FIFO SQS queues with strict ordering requirements',
  ]}
  avoidWhen={[
    'High-volume customer-facing SMS: AWS End User Messaging or a third-party SMS provider fits better at scale',
    'Complex rule-based routing: EventBridge has a richer rule language and event archive',
    'Sub-100ms latency requirements: SNS delivery has variable latency; use direct invocation',
    'Long-term event retention or replay: SNS does not store events; EventBridge archive or Kinesis is the right primitive',
    'Tiny topics (under 1M monthly publishes) where the free tier covers the publish line and delivery cost is the only line; verify the delivery math first',
  ]}
  footnote="SNS-to-SQS fanout is one of the highest-impact AWS patterns: free delivery, decoupling, and cheap consumer scaling. Use it whenever the consumer is internal AWS."
/>

## A 30-day SNS bill cleanup plan

**Week 1: Audit SMS spend.** Check the SNS SMS spend limit per account; set a sensible hard cap if not set. Identify topics sending SMS by reviewing `NumberOfMessagesPublished` by protocol per topic. Migrate any high-volume customer SMS to AWS End User Messaging or a third-party provider.

**Week 2: Add filter policies.** For each topic with multiple subscribers, audit whether subscribers receive all publishes or only relevant ones. Add filter policies where subscribers should only receive a subset. This is often a quick code/IaC change with significant delivery-cost saving.

**Week 3: Add DLQs for HTTP and Email subscriptions.** For every HTTP and email subscription, configure a redrive policy targeting an SQS DLQ. Add CloudWatch alarms on `NumberOfNotificationsFailed`.

**Week 4: Cross-region pattern audit.** Map every cross-region SNS-to-SQS pattern against the actual consumer footprint. Disable cross-region fanout to regions with no active consumers.

## More in this series

Part of the **AWS Service Pricing** series (June 2026).

- Previous: [Part 6](https://www.joinhorizon.co/blog/amazon-sqs-pricing-64kb-rule-fifo-vs-standard/)
- Next: [Part 8](https://www.joinhorizon.co/blog/amazon-eventbridge-pricing-events-pipes-schema-archive/)
- Browse all: [Cost Optimization & FinOps category](https://www.joinhorizon.co/category/cost-optimization-and-finops/)

## What this post doesn't cover

- **AWS End User Messaging pricing for high-volume customer messaging:** registration fees, origination leases, and per-country message rates; covered in the [SMS guide](https://www.joinhorizon.co/blog/aws-end-user-messaging-sms-guide-2026/).
- **SES email vs SNS email:** SES at $0.10/1K is dramatically cheaper than SNS email for marketing or transactional email at any volume; covered in the SES guides.
- **CloudWatch Events to EventBridge migration:** EventBridge is the modern replacement for CloudWatch Events; covered in the [EventBridge pricing post](https://www.joinhorizon.co/blog/amazon-eventbridge-pricing-events-pipes-schema-archive/).
- **Mobile push delivery setup:** APNS/FCM/ADM credential management is operational, not billing-relevant.

## If you only do one thing this week

Set the SNS SMS monthly spend limit on every production account to a sensible cap. The default is unlimited, which combined with the high per-SMS rates in long-tail countries creates the single biggest risk of a runaway SNS bill. Run `aws sns get-sms-attributes` per account, then `aws sns set-sms-attributes --attributes MonthlySpendLimit=<dollar-amount>` to set the cap. Pair with a CloudWatch alarm on the SNS SMS spend metric and you have a hard ceiling that prevents the worst-case bill spike.

For the receiving end of SNS-to-SQS fanout patterns, the [SQS pricing post](https://www.joinhorizon.co/blog/amazon-sqs-pricing-64kb-rule-fifo-vs-standard/) covers the polling, FIFO, and chunking details that compound with the SNS publish line.

## FAQ

### Why is SNS publish billed separately from delivery?
SNS decouples the act of publishing from the act of fanning out to subscribers. A single Publish call costs the per-million publish rate ($0.50/M for Standard topics) regardless of how many subscribers exist. Each delivery to each subscriber then bills at the per-protocol rate: HTTP at $0.60/M, email at $2/100K, mobile push at $0.50/M, SMS at variable per-country rates. The split is logical (publishing is the same work regardless of subscriber count; delivery scales with subscriber count) but produces surprising bills when teams forget to count both lines.

### Are SQS subscriptions to SNS free?
The SNS delivery to SQS is free: there is no per-message charge for SNS-to-SQS delivery. The SQS side bills normally at $0.40/M Standard or $0.50/M FIFO for the incoming messages. Similarly, Lambda subscriptions are free on the SNS side and bill normally on the Lambda side. This makes SNS-to-SQS fanout the cheapest pattern for distributing one publish to many internal AWS consumers, and far cheaper than EventBridge for predictable high-volume fanout to a known set of queues.

### How expensive is SNS SMS really?
SMS is the single most expensive SNS protocol and varies dramatically by country. United States SMS costs about $0.012 per message ($0.00774 plus a $0.00421 carrier fee, October 2026); Brazil, India, and most of EMEA range from $0.04 to $0.20 per message. International SMS to long-tail countries can hit $0.50 per message. A B2C app sending one two-factor code a day to 100K users generates about 3M SMS a month, roughly $36,000 at the US rate alone and more for international destinations. Most production deployments use a dedicated SMS provider (Pinpoint, Twilio, Vonage) for the messaging-grade reliability and rate negotiation, with SNS reserved for low-volume internal alerts or US-only consumer notifications.

### Does FIFO SNS have the same throughput limits as FIFO SQS?
Yes. SNS FIFO topics inherit similar throughput constraints: 300 publishes per second per topic by default (raisable on request), strict ordering within a message group, and content-based or explicit deduplication. The pricing is $0.30/M publishes plus $0.017/GB of payload data. The payload-data line item is unique to FIFO SNS and surprises teams: a high-throughput FIFO topic with 1 KB messages adds a small per-publish data line; at 100 KB messages the data line dominates the per-publish line. Most workloads do not need SNS FIFO. Standard topics plus idempotent consumers cover the same use cases more cheaply and at much higher throughput.

### How does message filtering affect the bill?
Filtering is free to apply but does not reduce the publish cost: every publish is billed regardless of whether the filter selects any subscribers. What filtering does reduce is the delivery cost: a publish that matches filters for only one of five subscribers bills delivery to that one subscriber. This makes filtering essential for cost control on topics with mixed subscriber interest; without it, every subscriber receives every publish and the delivery line scales with subscriber count rather than relevance.

### What is the cheapest way to fan out an event to multiple regions?
For internal AWS consumers, the cheapest pattern is a single SNS topic in the source region with cross-region SQS subscriptions. SNS publish is billed once; the SNS-to-SQS delivery is free; the inter-region data transfer is $0.02/GB. A common alternative, EventBridge with custom event buses replicated across regions, is more flexible but bills $1/M per region. For most known-consumer fanout patterns, SNS-to-SQS is 50%+ cheaper than EventBridge.

### What happens when an HTTP subscription endpoint is down?
By default, SNS retries a failed HTTP/S delivery up to three times, 20 seconds apart, and a custom delivery policy is capped at 3,600 seconds of total retry time. Every retry is a billable delivery attempt at the per-protocol rate, so a topic with an HTTP subscription to a chronically failing endpoint bills up to four delivery attempts for every message. Configure a redrive policy to an SQS DLQ for failed deliveries (cheaper than infinite retries), monitor the `NumberOfNotificationsFailed` CloudWatch metric, and use the SNS-side delivery status logging to identify chronic-failure endpoints quickly.

---

*Source: https://www.joinhorizon.co/blog/amazon-sns-pricing-publishes-fanout-protocols/*
