# Courier vs BuildBase, and the meter that never switches off

> Courier has no subscription line. It is $0.005 a send from the first one, sitting on top of the provider bill you already pay, and it is cheaper than our top plan below roughly 20,000 sends a month.

- Source: https://www.buildbase.app/compare/courier-vs-buildbase
- Section: Comparisons
- Author: Dharmendra Jagodana
- Published: 2026-11-15

## In short

Courier is notification infrastructure with no subscription line: $0.005 per send on the Business tier, charged from the first send, on top of the SendGrid or Twilio bill you pay anyway. BuildBase is a flat plan from $19 covering email, web push and Slack inside a backend that already does auth and billing.

Courier has no floor. No subscription line, no included volume, just $0.005
a send from the first send onward, and below about 20,000 sends a month that
works out cheaper than our top plan.

That is awkward for us. Three days ago we published
[a comparison](/compare/knock-vs-buildbase) arguing that notification
infrastructure gets expensive because it meters the one thing your product
is supposed to get better at, and the example was a $250 floor you pay
before you have sent anything. Courier does not have one. So this post does
not get to lead with the invoice, and it would be dishonest to pretend
otherwise.

The other half of that argument survives. No floor also means no ceiling,
and a meter that counts everything counts things you were not thinking about
when you priced it.

## The one-paragraph answer

Pick Courier if notifications are a surface your users judge you on and you
need to reach them off the web: iOS and Android push, text messages, an
embeddable in-app inbox, Microsoft Teams and WhatsApp. Pick BuildBase if
your notifications are email, web push and Slack alerts, and they are one
piece of a backend you have not finished building. Courier reaches further
and starts cheaper. Our bill is flat, and it does not bill for your staging
environment.

## What each one actually is

Courier is orchestration, not delivery. You connect your own provider
accounts, and the ones Courier names are SendGrid, Postmark, Amazon SES,
Twilio, Firebase Cloud Messaging and APNs. Courier then owns the routing
between them, the failover when one is down, the templates, the preference
page and the logs. That is a real product and the $0.005 buys it. And that
half a cent sits on top of what SendGrid and Twilio charge you, because
Courier does not send the message, your provider does.

BuildBase is [a backend sold as an SDK](/blog/what-is-a-saas-backend).
Notifications are a few of its 20 modules, not the product. Email runs
through Mailgun, Google, Amazon SES or your own SMTP, with templates,
open and click tracking, unsubscribe groups and preference centers. Web
push generates VAPID keys per organization on the first subscribe, and
one server call sends email and push together to a single user or a
whole workspace. Slack alerts are Block Kit messages that link back to
the console record. The workflow builder wires it together with more
than 100 triggers and 19 actions.

One of those is a layer you add to a stack. The other is the stack.

## Pricing, verified 15 November 2026

Courier publishes three tiers and one meter. Developer is free up to 10,000
sends a month and includes the SDKs, the CLI, the MCP server and workspace
login through Google or GitHub. Business is $0.005 per send. Adding a card
is what moves a workspace onto it.

Read that Business line carefully, because it is unusual. There is no flat
fee, which is the good part. There is also no included volume, and Courier's
own billing documentation says Business charges for every send including the
first 10,000. The free tier does not carry over. So the first send past
10,000 does not cost half a cent, it costs about $50, because adding the
card re-prices everything you already sent that month.

BuildBase plans are Free at $0, Launch at $19, Grow at $49 and Scale at $99
a month, with yearly billed as ten months for twelve. Those four prices were
last checked against the database on 31 October 2026, and the pricing page
renders live from it, so treat them as a mirror rather than the source.

> **Key takeaway:** At $0.005 a send, Courier passes our $19 Launch plan at 3,800 sends a month,
> Grow at 9,800 and Scale at 19,800. Only the last of those is a number anyone
> meets, because below 10,000 sends nobody is paying Courier anything. So the
> real crossover sits around 20,000 sends, and almost nobody writes it down.

## What the meter counts

Courier counts one unit per template send, per recipient. What it does not
count matters more. A multi-channel template is one send even when it
delivers over email, text message and push separately. Fan one event
out to three channels and the meter moves once. That is a genuinely better
unit than per-message metering, and it is the strongest thing on Courier's
pricing page.

Two other things it counts, though, and both live in the billing docs rather
than on the pricing page. A send counts whether or not the provider delivers
it, so bounces and blocks are billable. And sends from every environment
count, including Test and custom environments.

Your CI suite, your load test and your staging smoke test all bill at the
production rate. Nobody notices until the invoice arrives carrying a number
nobody can attribute to a customer.

Our side meters differently, and "we do not meter" would be too convenient a
way to put it. Marketing email is metered.
[Transactional](/guides/transactional-email-landing-in-spam) and system mail
is not counted and not capped: not password resets, not invites, not billing
alerts, not a workflow telling someone their export finished. Web push is
metered per device actually delivered to, rather than per user dispatched.
And of every quota we run, only three bill past their allowance at all:
workflow runs, web analytics events and storage. Everything else stops
instead of charging.

So we have a ceiling you can hit and Courier has a bill that keeps climbing.
Neither is obviously the better deal. They are different failure modes, and
you should pick the one your finance team would rather explain.

| Feature | BuildBase | Courier |
| --- | --- | --- |
| What the bill tracks | A flat plan, $19 to $99 | $0.005 per send, no plan fee |
| Free tier | Free plan: $0, 10,000 MAU | Developer: $0, 10,000 sends/mo |
| Included volume when paying | Plan allowances that stop, not bill | None. Every send billed from the first |
| Test and staging sends | Counted against a dev allowance, never billed | Billed at the production rate |
| Who delivers | Mailgun, Google, Amazon SES or your SMTP | Your own providers, billed separately |
| Channels | Email, web push, Slack | Email, text, mobile push, chat, in-app |
| Mobile delivery | Web push only, VAPID per org | APNs and Firebase Cloud Messaging |
| Self-hosting | Priced per installation, by conversation | Managed cloud only, per their docs |
| Scope | Notifications inside 20 modules | Notification infrastructure only |

Read that table from the bottom up. Scope changes what every row above it
means.

## Where Courier wins

> **Where Courier wins:**   **The cheap end, and it is not close.** Ten thousand sends a month for
>   nothing, then half a cent each with no plan fee. A product sending a few
>   thousand notifications a month pays Courier zero. The smallest paid plan
>   here is $19, and that $19 is buying a backend rather than a notification
>   service, which is only an argument if you wanted the backend.
>
> **Channels nobody reaches from a browser.** Mobile push through APNs and
> Firebase Cloud Messaging, text messages through your own Twilio account,
> chat into Microsoft Teams and WhatsApp. Our outbound list is email, web push
> and Slack. Web push reaches a browser, including when your app is closed,
> and nothing past that. If a notification has to arrive on a phone that is
> not currently looking at your site, this comparison ended several paragraphs
> ago.
>
> **The compliance answer.** Courier's documentation states SOC 2 Type II,
> HIPAA and PCI DSS programs, a security portal holding current reports for a
> vendor review, a BAA on the Enterprise tier and an EU datacenter for
> residency. That is the paragraph a healthcare or fintech buyer's security
> review is looking for. Ours says AES-256 at rest and TLS 1.2+ in transit,
> and on uptime it says targets vary by plan with no guarantee of 100%. For
> that buyer those are not the same answer.
>
> **Design Studio, and the organizational question underneath it.** Courier
> ships a visual multi-channel editor where one author writes once and sees
> every channel rendered, with no deploy in the loop. Their changelog, read
> 15 November 2026, dates experiments in Journeys to July and AI translation
> to June. Our
> templates are editable in the console in HTML, Markdown or plain text, and
> the workflow builder owns the triggers, but there is no single canvas a
> growth team can be handed.
>
> **The in-app inbox.** Courier's Inbox is an embeddable in-app notification
> center with a real-time message list and toasts, with drop-in components for
> React, JavaScript, iOS, Android, React Native and Flutter, plus a hosted
> preference page enforced on every send. It is one of their named product
> pillars, which is why the comparison table above has no line for it: we
> could not write ours honestly, and an empty column is better than a guess.

## Who owns the message

Courier assumes a notification belongs to whoever writes the copy. On our
side it belongs to the code that fired the event, and most of that table,
the invoice line included, is downstream of that one difference.

Design Studio, the hosted preference page, routing strategies, Journeys with
their branches and digests: these exist so a growth or lifecycle team can
change what a notification says, who gets it and when, without opening a
pull request. Courier now describes itself as a customer messaging platform
rather than a notification API, and that is not marketing drift. It is the
shape of the product.

We start from the event instead, because your product code already owns it.
The subscription upgraded. The workspace member was added. The credit
balance went low. Those are our events before they are anybody's
notification, which is why the notification is a step in a workflow sitting
next to the gate that checks the plan and the webhook that tells your own
systems.

Neither is better. One of them describes your team and the other does not.
If your notification copy is changed by someone who does not deploy, we are
the wrong shape for you whatever the bill says.

## When each one is the wrong call

Courier is the wrong call if your notifications are email and a Slack alert
and the rest of your backend does not exist yet. You would be paying for
orchestration across channels you do not use, on top of a provider bill, and
still needing
[auth, billing and workspaces from somewhere else](/blog/auth-billing-stack-cost).

BuildBase is the wrong call above roughly 20,000 notifications a month if
notifications are all you want, and it is the wrong call at any volume if
you need a phone. We would be the cheaper wrong answer, which is the most
expensive kind.

Running both is the third option people forget. We emit 239
[webhook events](/blog/what-are-webhooks) signed with HMAC-SHA256 and
carrying Standard Webhooks headers, so Courier can subscribe to what happens
in your product and own delivery on the channels we do not reach. Two bills,
no gaps.

## If you are moving

There is no import to build. Notification history is a log you let age out,
not state you migrate, so the work is re-authoring templates and re-deciding
the preference model. The preference model is the part that overruns, and
[which notifications a user gets to turn off](/guides/which-notifications-users-can-turn-off)
is the decision underneath it.

Move one workflow that matters. Run both for a billing cycle. Then read the
invoice, and read the line that says how many of those sends came from your
test environment.
