---
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.factualminds.com/blog/amazon-sns-pricing-publishes-fanout-protocols/
datePublished: 2026-06-13T00:00:00.000Z
dateModified: 2026-06-13T00:00:00.000Z
author: palaniappan-p
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';

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, 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.

<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: '20× more expensive than mobile push' },
    { value: '20–50×', label: 'SMS country variance', note: 'US $0.00645; long-tail $0.50+' },
  ]}
  caption="us-east-1 list prices, June 2026. SMS rates vary by destination country and carrier."
/>

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

## The Two-Layer SNS Bill: Publish + 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: '20× the price of mobile push',
    },
    {
      name: 'SMS — US',
      unitPrice: '~$0.00645 / SMS',
      example: '100K SMS / month',
      monthly: '$645',
      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."
/>

## The Four-Charge Publish: A Worked Example

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

SMS is the highest-variance line item in SNS. United States rates are reasonable (~$0.00645/SMS). International rates vary by country and carrier from ~$0.04 to over $0.50 per single message. A B2C app sending two-factor authentication SMS to 100K global users daily can produce a bill in the high four or low five figures per month depending on user geography.

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 Pinpoint or a dedicated SMS provider** for high-volume SMS. Pinpoint offers carrier-grade routing, rate negotiation for high volumes, and dedicated short codes that reduce per-message rates. 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 13,000× cheaper than long-tail-country 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="$5,000–$25,000/month at modest volume"
>
  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
  migrate to Pinpoint or Twilio for the production SMS path.
</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). The cost driver is rarely the happy-path delivery — it is retries against failing endpoints.

SNS retries failed HTTP deliveries with an exponential backoff that, by default, runs for 20 days. Every retry attempt is a billable delivery. A topic with an HTTP subscription pointed at a chronically failing endpoint can quietly generate tens of thousands of retry deliveries per day with no successful messages reaching the subscriber.

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

## Message Filtering: Free but Mandatory at Scale

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; Pinpoint 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) — 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 — Pinpoint or third-party SMS provider is dramatically cheaper 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-leverage 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 Pinpoint 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.

## What This Post Doesn't Cover

- **Pinpoint pricing for high-volume customer messaging** — Pinpoint has its own pricing model with per-event, per-endpoint, and per-channel charges; covered in a separate post.
- **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](/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](/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 — 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 roughly $0.00645 per message; 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 two-factor codes to 100K global users daily can spend $5K–$25K/month on SMS alone. 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?
SNS uses an exponential backoff retry policy (default: 3 fast retries with no delay, then 16 retries over 20 days with progressive delays). Every retry is a billable delivery attempt at the per-protocol rate. A topic with an HTTP subscription to a chronically failing endpoint can quietly accumulate thousands of failed retries per day. 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.factualminds.com/blog/amazon-sns-pricing-publishes-fanout-protocols/*
