Courier Pricing in 2026: What $0.005 Per Send Really Costs

Quick answer (2026): Courier charges $0.005 per notification sent, and the first 10,000 sends each month are free on the Developer plan. The meter counts notifications, not channels and not seats, so one alert fanned out to email, SMS, and push still bills as a single send. That makes extra channels effectively free and puts the whole cost driver on frequency and audience size. A 20,000-daily-user app sending three notifications per user per day runs about 1,800,000 sends a month, or roughly $8,950, before you touch a line of routing code.

How does Courier bill in 2026?

Courier keeps the pricing page short. Two numbers do all the work (Courier pricing, 2026):

• Developer: free, up to 10,000 sends a month.
• Pay-as-you-go: $0.005 per send after that.

Enterprise adds volume pricing and custom terms, but the public meter is a single per-send rate. Courier states it plainly: pricing is based on notifications sent, not team size or channels. There are no per-seat charges and no per-channel add-on fees. Add ten teammates or a fourth delivery channel and the invoice does not move. Only the send count does.

What does $0.005 per send mean in real money?

Per-send rates hide their scale. Convert the number once and keep it:

• $0.005 per send
• $5.00 per 1,000 sends
• $5,000 per 1,000,000 sends

A send sounds free until you multiply it by an active user base and a daily cadence. Ten thousand free sends covers a side project or an early launch. It does not cover a live product that pings users more than once a day.

Why are channels free but frequency the trap?

This is the part worth internalizing. Because Courier meters notifications and not channels, the usual usage-billing multiplier is not where you would expect it.

Say you route one notification to a user across three channels: email, SMS, and push. On a per-message or per-channel meter, that is three billable units. On Courier it is one send. The channel fan-out that inflates most notification bills does not exist here.

Run the arithmetic. An app fires 1,800,000 notifications in a month, each delivered on three channels:

• On Courier: 1,800,000 sends, because channels do not multiply the meter. Orchestration cost is about $8,950.
• On a hypothetical per-channel meter at the same $0.005 rate: 5,400,000 units, or about $27,000.

The meter is on your side for channels. The cost lives somewhere else: how often you notify, and how many people you notify. Frequency times audience is the entire bill.

What do three 30-day Courier bills look like?

Same $0.005 rate, three very different invoices. The first 10,000 sends are free in each case.

The disciplined product barely registers. The notification-happy product pays almost nine thousand dollars a month, and not one dollar of that came from adding channels. It came from cadence.

What is the one lever that cut the bill $6,000?

Batching. The notification-happy app in the table sent three separate nudges per user per day. Collapse those into a single daily digest and the send count drops from 1,800,000 to 600,000. The bill falls from $8,950 to $2,950. That is a $6,000 monthly cut with the same audience, the same channels, and arguably a better user experience.

The lever is always the same on a per-notification meter: reduce the number of distinct notifications, not the number of channels. Digest low-urgency events. Collapse retries and duplicates. Honor mute preferences so you are not paying to send messages people already silenced. None of that is a code rewrite. It is a notification-strategy decision that happens to also be the cheapest one.

What does the free Developer plan actually cover?

The Developer plan is capped at 10,000 sends a month, and it does not carry overage. You do not silently accrue a bill on the free tier; you reach the ceiling and move to pay-as-you-go to keep sending. That is friendlier than a metered free tier that quietly bills a viral spike, but it also makes the planning number simple: budget for paid the month you expect to cross 10,000 sends. At 30,000 sends that is 20,000 billable at $0.005, or $100. At 100,000 sends it is $450. There is no per-seat charge stacked on top.

What are you actually paying for, and when should you self-host?

Here is the honest framing. Courier is an orchestration layer: routing, templates, preferences, batching, and cross-channel logic. The $0.005 per send buys that orchestration. It does not buy delivery. You still pay SendGrid or your email provider for the actual email, and Twilio or your SMS provider for the actual text. At 1,800,000 sends, the $8,950 is the orchestration bill. Delivery is separate and on top.

That reframes build versus buy. If your routing is simple and orchestration cost dominates, an open-source layer such as Novu (source on GitHub, MIT licensed and self-hostable) removes the per-send orchestration fee. You still pay delivery, and you own the ops. Managed platforms like Courier and Knock (knock.app) earn their keep when preference management, template versioning, and multi-channel routing are real product surface you do not want to maintain. We ran the same math on Knock's model in the Knock pricing teardown, and the general crossover is worked out in when DIY beats SaaS at scale.

The rule of thumb: below a few hundred thousand sends a month, managed orchestration is cheaper than the engineering time to replace it. Above that, and with simple routing, the per-send fee starts to look like rent on code you could own.

Math check: Courier's meter is notifications, not channels. Three channels on one notification is still one send, so the multiplier that matters is frequency times audience. Cut 3 notifications per day to 1 daily digest for 20,000 users and the bill goes from $8,950 to $2,950, a 67 percent cut with the same reach.