# Courier

> Courier is a notification orchestration platform that routes product messages across email, SMS, push, in-app inbox, Slack, and Microsoft Teams through more than fifty delivery providers you connect with your own credentials, adding a visual template designer, automation workflows with batching and throttling, a preference center, and drop-in inbox components, billed purely on notifications sent at $0.005 each with the first 10,000 a month free.

- Category: Marketing Automation (https://saastracker.org/categories/marketing-automation)
- Website: https://www.courier.com
- Starting price: $0 (Developer, 10,000 sends per month), then $0.005 per send
- Free plan: Developer includes 10,000 notification sends per month across email, push, SMS, in-app, and chat.
- Free trial: No time-limited trial; the Developer plan is permanently free within its send allowance
- Founded: 2019, HQ: San Francisco, California, United States, Ownership: Venture-backed
- Profile last reviewed: 2026-08-22
- Canonical profile: https://saastracker.org/products/courier

## Overview

Courier was founded in 2019 by Troy Goode, who had led engineering at Eloqua before Oracle acquired it and then served as CTO at Winmore. That background matters: Eloqua was one of the original marketing automation platforms, and Courier is what somebody builds after watching marketers and developers fight over the same messaging system for a decade. The company went through Y Combinator in the summer 2019 batch, raised a $10.1M Series A led by Bessemer in 2020 with strategic money from Twilio, SendGrid, and Slack, and a $35M Series B in 2022.

The product's organizing idea is that you should never be locked into a delivery provider. Courier holds the templates, the routing logic, the user preferences, and the observability, then hands the finished message to whichever of fifty-plus providers you have configured: SendGrid or Postmark for email, Twilio for SMS, APNs and Firebase for push, Slack and Teams for chat. Swapping providers becomes a configuration change rather than a refactor, and you keep whatever rates and reputation you have already built.

Where Courier differs most visibly from its closest competitor, Knock, is the design surface. Courier ships a drop-in visual template editor intended for non-developers, with multi-channel preview on a single canvas, so the same notification can be composed for email, SMS, push, and in-app side by side. That is a deliberate bet that the person writing the message should not need a pull request, and it makes Courier the more approachable of the developer-first tools for a mixed team.

Pricing is the simplest in this batch and possibly the simplest in the category: 10,000 notification sends a month free, then $0.005 per send on the Business plan, with no per-seat fee and no charge for using more channels. Enterprise adds volume discounts, EU data residency, role-based access control, observability integrations, and an SLA. There is no contact-count meter anywhere, which means a large user base costs nothing until you actually message it.

## How it works

1. You connect your delivery providers in the Courier dashboard using your own credentials. Courier maintains integrations with more than fifty of them, so the same account can hold SendGrid for marketing-adjacent email, Postmark for transactional, Twilio for SMS, Firebase and APNs for push, and Slack for chat, with no code changes when you swap one out.

2. You design notifications in the template designer, a visual editor that previews every channel on one canvas so a single notification produces an email, an SMS, a push payload, and an in-app entry from one piece of work. Developers who prefer code use the Elemental API, a JSON document format for describing notification content programmatically.

3. Your application sends a request to the Courier API with a recipient and data. Courier resolves which channels to use based on routing rules and the recipient's stored preferences, renders the templates, and delivers through the appropriate providers, falling back down a routing chain when a channel fails or the user has opted out.

4. Automations add the time dimension: batch many events into a digest, throttle sends to prevent floods, add delays and conditions, and on the Business plan insert an AI agent node so a frontier model like Claude can personalize content, score a user, or enrich a profile as a step inside the workflow. The in-app Inbox component and the preference center are drop-in front-end pieces for React, JavaScript, iOS, Android, React Native, and Flutter.

## Best for

Engineering teams at product companies who already pay for SendGrid, Twilio, or Firebase and want an orchestration layer over them, particularly mixed teams where a non-developer needs to own the message content without filing tickets.

## Not the right fit for

- Marketing teams with no engineering support; Courier has no contact upload, no campaign calendar, and nothing sends until an application calls the API.
- Anyone who wants delivery included; you connect and pay for your own providers, so the $0.005 send fee is always on top of a SendGrid or Twilio bill rather than instead of one.
- Ecommerce operators; there is no catalog, no cart abandonment recipe, no revenue attribution, and no promotional campaign tooling of any kind.
- High-volume broadcast senders; at $0.005 a send, a million-message monthly newsletter costs $5,000 in orchestration fees alone before a single email is delivered, which is absurd against an ESP's rate card.
- Teams needing deep per-tenant configuration and branding on a small budget; Knock's multi-tenancy is more developed, and Courier reserves role-based access control and EU residency for Enterprise.

## Features

### Provider routing

The core promise: your providers, your rates, your reputation, one API.

- **Fifty-plus provider integrations**: SendGrid, Postmark, Twilio, APNs, Firebase, Slack, Microsoft Teams, and dozens more connect with your own credentials, so switching a provider is a settings change rather than an engineering project.
- **Routing rules and fallbacks**: Define which channel to try first and what happens when it fails or the recipient has opted out, so a notification can attempt in-app, then email, then SMS without your application knowing about any of it.
- **No channel add-on fees**: Adding SMS or push does not change the price. Billing is purely per notification sent, whatever channel it goes out on.
- **No per-seat pricing**: Team size is not a billing lever, so bringing designers, PMs, and support staff into the tool costs nothing.

### Content and design

The part that makes Courier usable by people who do not write code.

- **Visual template designer**: A drop-in editor where a non-developer designs content without code and ships updates without a deploy, which is the clearest difference from purely code-first notification tools.
- **Multi-channel preview on one canvas**: Email, SMS, push, and in-app renderings of the same notification appear side by side, so the person writing the copy sees every surface at once.
- **Elemental API**: A JSON document format for describing notification content programmatically, for teams who want templates in code and under version control instead of in a UI.
- **Localization and translations**: AI Translations are available as an add-on so one template can serve multiple locales without maintaining parallel copies by hand.
- **Branding and layouts**: Shared brand configuration applied across templates so a logo or color change propagates rather than being edited in twenty places.

### Automations and workflows

Time, volume, and conditional logic pulled out of application code.

- **Digests and batching**: Collect many events into a single notification over a defined window, the feature most product teams need and least want to build.
- **Throttling**: Rate-limit sends so a burst of activity does not produce a notification flood, protecting both the user and your provider reputation.
- **Delays and conditions**: Wait steps and conditional branches so a reminder can check whether the user already acted before firing.
- **AI agent node**: Frontier models including Claude Opus run as a step inside any workflow for personalization, user scoring, or profile enrichment. Available as an add-on on the Business plan.
- **Scheduled and recurring sends**: Time-based automation for digests and reminders that do not originate from a single product event.

### User-facing surfaces

The components that stop notifications becoming a support ticket.

- **Inbox component**: An in-app notification center with real-time sync across devices, available as customizable UI components for React, JavaScript, iOS, Android, React Native, and Flutter.
- **Preference center**: A built-in surface letting users control what they receive and where, backed by a preferences API that routing rules automatically respect.
- **Cross-device read state**: Inbox read and seen state syncs in real time, so dismissing a notification on mobile clears it on the web too.

### Operations and observability

Knowing what was sent, to whom, and why it failed.

- **End-to-end delivery tracking**: Delivery status, errors, and engagement in one place across every provider, rather than in four separate provider dashboards.
- **Per-message debugging**: Trace an individual notification through routing, rendering, and delivery to see exactly which rule sent it where.
- **Observability integrations**: Log and metric export into external monitoring, available on the Enterprise plan.
- **Role-based access control**: Granular permissions for larger teams, reserved for the Enterprise plan.
- **EU data residency**: European hosting is available on Enterprise, which is one of the few genuinely enterprise-only capabilities that a European mid-market buyer may actually need.

## Use cases

- **SaaS team already paying for SendGrid and Twilio**: Notification logic lives in three services, each provider has its own dashboard, and nobody can answer why a specific customer did not get an alert. Outcome: Courier orchestrates over the existing providers, so no contracts change and no domain reputation is rebuilt, and end-to-end tracking finally answers the delivery question from one place.
- **Product designer who owns notification copy**: Every wording or layout change to a transactional email requires an engineer to edit an HTML template and cut a release. Outcome: The visual template designer with multi-channel preview lets the designer edit email, SMS, push, and in-app versions of the same notification and ship without a deploy.
- **Collaboration product drowning its users in alerts**: A busy document generates twelve notifications in ten minutes and users are turning email off entirely. Outcome: Batching collapses the burst into one digest, throttling caps the rate, and the preference center lets users keep the categories they care about instead of opting out of everything.
- **Startup at 8,000 notifications a month**: Volume is real but small, and paying a $250 platform floor for notification orchestration is not defensible yet. Outcome: The free Developer plan covers 10,000 sends a month across every channel, so the total orchestration cost is zero and the only bill is the existing provider one.

## Pricing

Pure usage-based pricing on notifications sent, with no per-seat fee and no channel add-on charges, plus a free monthly allowance and a quoted enterprise tier with volume discounts.

- **Developer**: $0 per month. 10,000 notification sends per month; All channels: email, push, SMS, in-app, chat; Visual template designer and Elemental API; Inbox component and preference center; Provider integrations with your own credentials. A complete product within the allowance, and enough for most pre-product-market-fit companies.
- **Business**: $0.005 per notification sent. Unlimited sends at a flat per-send rate; No per-seat fees and no channel charges; Automations with batching, throttling, delays, and conditions; AI Translations add-on; AI agent node add-on. The linear rate is the most predictable pricing in this category; multiply your send volume by half a cent and you have your bill.
- **Enterprise**: Custom annual contract. Volume-based discounting; EU data residency; Role-based access control; Observability integrations and a dedicated Slack channel; Enterprise SLA.

Add-ons:

- AI Translations (Quoted): Automated localization of templates across locales.
- AI agent node (Quoted): Runs a frontier model such as Claude Opus as a workflow step for personalization, scoring, or enrichment.

Billing notes:

- The meter is notifications sent, not profiles stored, so an audience of any size costs nothing until you message it. This is the opposite structure to Customer.io, Ortto, or Drip.
- You pay your delivery providers separately. The Courier fee is orchestration only, so total cost is always Courier plus SendGrid plus Twilio plus push provider.
- Modelled at 5,000 users receiving roughly two notifications a month each, that is 10,000 sends and therefore $0: the free plan covers it outright.
- Modelled at 50,000 users receiving two notifications a month each, that is 100,000 sends at $0.005, or $500 a month plus provider costs.
- There is no seat charge, so team size never enters the calculation, which quietly saves real money on tools that charge per editor.
- At broadcast volumes the linear rate becomes punishing. A million-send month costs $5,000 in orchestration alone, which is why Courier is a product-notification tool rather than a marketing send tool.

Value assessment: Courier's pricing is the easiest to reason about in this whole category and, at low to moderate volume, extremely fair. Ten thousand free sends a month covers a real early-stage product, and $0.005 a send with no seat fees and no channel charges means the bill scales exactly with usage and nothing else. Against Knock, Courier is dramatically cheaper in the 10,000 to 50,000 message band, where Knock's $250 floor bites hard. The break-even flips at high volume: 400,000 sends costs $2,000 on Courier and would be an Enterprise negotiation on either platform. What you are not getting for the money is delivery, deliverability, or any marketing capability, and the honest total cost of ownership always includes the provider invoices sitting underneath.

## Strengths

- The simplest pricing in the category: no seats, no channel fees, no contact meter, just $0.005 a send with 10,000 free every month.
- Fifty-plus provider integrations with your own credentials, which means no vendor lock-in, no reputation rebuild, and no renegotiated contracts.
- The visual template designer with multi-channel preview on one canvas is the friendliest content surface among the developer-first notification tools.
- Batching, throttling, delays, and conditions cover the notification-fatigue problem that most in-house implementations get wrong.
- Drop-in Inbox components for React, JavaScript, iOS, Android, React Native, and Flutter with real-time cross-device read state.
- Strategic investment from Twilio, SendGrid, and Slack signals that the provider ecosystem sees Courier as complementary rather than competitive.
- The AI agent node is a genuinely interesting primitive: a frontier model as a workflow step for personalization and scoring rather than as a template-writing gimmick.

## Limitations

- Nothing works without engineering; the API call has to come from your application, so a marketer cannot get value alone.
- Delivery is not included, so the sticker price understates the real cost and you own deliverability, domain authentication, and list hygiene entirely.
- Multi-tenancy is less developed than Knock's, which matters for B2B products giving each customer organization its own notification configuration.
- Role-based access control and EU data residency are Enterprise-only, so a European mid-market buyer with residency requirements cannot self-serve.
- The linear per-send rate becomes uncompetitive at broadcast volumes, making Courier a poor fit for anything resembling a newsletter.
- No marketing surface at all: no campaign calendar, no revenue attribution, no A/B testing of the sort a growth team expects.

## Comparisons

- **Courier vs Knock**: The two are direct competitors and the choice usually comes down to volume and shape. Courier is cheaper in the 10,000 to 100,000 message band ($500 at 100,000 sends versus Knock's $250 floor plus overage) and has the better visual design surface for non-developers. Knock has the more generous free tier at equal volume, deeper multi-tenancy, workflows as code with CI validation, and Guides for in-product messaging. Pick Courier for simplicity and design; pick Knock for B2B tenant complexity and notification logic in version control.
- **Courier vs Novu**: Novu is open source and self-hostable, metered by workflow runs from $30 a month, which makes it the answer when data control or an on-premises requirement is non-negotiable. Courier is hosted only, priced per send, and considerably more polished on the template designer and provider integration breadth. Take Novu if you want to own the deployment; take Courier if you would rather not run it.
- **Courier vs OneSignal**: OneSignal includes delivery and gives away unlimited mobile push, and it is operable by a growth team without engineering after the SDK lands. Courier delivers nothing itself and cannot be used without engineering. If your problem is reaching consumers on their phones with campaigns, OneSignal is both cheaper and better suited; if your problem is orchestrating product notifications across providers you already pay for, Courier is the right layer.
- **Courier vs Dittofeed**: Dittofeed is open-source marketing automation with journeys, segments, and templates, self-hostable free or in cloud from $75 a month, and it also expects you to bring your own ESP. The difference is intent: Dittofeed builds lifecycle campaigns for marketers, Courier orchestrates product notifications for engineers. A team wanting onboarding drips should take Dittofeed; a team wanting a digest and an in-app inbox should take Courier.
- **Courier vs Customer.io**: Customer.io is a full platform with its own delivery, a CDP, real-time behavioral segmentation, and campaign tooling from a $100 monthly floor billed on profile count. Courier is an orchestration layer with no delivery and no marketing surface, free up to 10,000 sends. Marketing-led companies should buy Customer.io; product-led companies whose notification problem is routing and fatigue rather than campaigns should buy Courier, and plenty of companies end up running both.

## Implementation

- Setup time: An afternoon to a first notification in production: connect a provider, design a template, call the API. Migrating an existing notification service takes one to two sprints and is usually done one notification type at a time.
- Learning curve: Low. The core concepts (providers, templates, routing, preferences, automations) map closely to how teams already think about notifications, and the visual designer means content people onboard in minutes rather than days.
- Onboarding: Fully self-serve on Developer and Business, with documentation and quickstarts. Enterprise adds a dedicated Slack channel and guided implementation.
- Migration: Because you keep your existing providers, migration touches routing and templates only. There is no sending domain to warm, no reputation to rebuild, and no deliverability risk in the cutover. The awkward part is preferences: existing opt-out state must be loaded into the Courier preferences API before you route live traffic, or you will message people who already unsubscribed elsewhere.

## Platform, API & security

- Platforms: Web dashboard, REST API, React and JavaScript components, iOS, Android, React Native, and Flutter SDKs
- API: REST API plus the Elemental JSON document format for programmatic notification content, server SDKs across common languages, and outbound webhooks for delivery and engagement events.
- Compliance: SOC 2, GDPR
- Data residency: US-hosted by default; EU data residency is available on the Enterprise plan.
- SSO: Single sign-on and role-based access control are Enterprise capabilities.
- Security notes: Provider credentials are held per workspace, end-to-end delivery tracking gives an auditable record of what was sent to whom, and observability integrations on Enterprise export logs and metrics to external monitoring. Enterprise SLAs back production use.

## Support

- Channels: Email support, In-app support, Dedicated Slack channel on Enterprise, Enterprise SLA
- Documentation: Documentation at courier.com/docs covering the API, Elemental, providers, automations, the Inbox component, and preferences, with quickstarts per language and framework.
- Community: Developer community with a public changelog; the company publishes technical writing on notification architecture and has an active presence in the Y Combinator alumni network.

## Company

- Founded: 2019
- Founders: Troy Goode
- Headquarters: San Francisco, California, United States
- Ownership: Venture-backed
- Employees: Not disclosed; small team
- Funding: More than $45M raised, including a $10.1M Series A led by Bessemer Venture Partners in 2020 and a $35M Series B in 2022.

Funding history:

- Y Combinator (2019): Accelerator. Summer 2019 batch.
- Series A (2020): $10.1M. Led by Bessemer Venture Partners with strategic investment from Twilio, SendGrid, and Slack.
- Series B (2022): $35M. Growth round to expand the notification infrastructure platform.

Timeline:

- 2019: Founded by Troy Goode, previously an engineering leader at Eloqua before its acquisition by Oracle and CTO at Winmore, and admitted to Y Combinator's summer batch.
- 2020: Raises a $10.1M Series A led by Bessemer Venture Partners, with strategic money from Twilio, SendGrid, and Slack.
- 2022: Raises a $35M Series B, expanding provider coverage past fifty integrations and shipping the Inbox component and preference center.
- 2024: Automations mature with batching, throttling, delays, and conditional logic, moving Courier from a routing API to a workflow platform.
- 2026: Positions around messaging for humans and AI agents, adding an AI agent node that runs frontier models as a step inside any workflow, plus AI Translations.

## Integrations

SendGrid, Postmark, Mailgun, Amazon SES, and other email providers, Twilio, MessageBird, and other SMS providers, Apple Push Notification service and Firebase Cloud Messaging, Slack, Microsoft Teams, Expo and OneSignal as push delivery providers, Segment, Zapier, Webhooks and custom providers, Observability tooling on Enterprise

## FAQ

### What is Courier?

Courier is a notification orchestration platform. It holds your templates, routing logic, user preferences, and delivery observability, then sends each message through providers you connect with your own credentials, across email, SMS, push, in-app inbox, Slack, and Microsoft Teams. It is billed on notifications sent, with the first 10,000 a month free and $0.005 per send after.

### How much does Courier cost?

The Developer plan is free for 10,000 notification sends a month across every channel. Business is $0.005 per send with no per-seat fees and no channel charges. Enterprise is quoted and adds volume discounts, EU data residency, role-based access control, observability integrations, and an SLA. At 100,000 sends a month you would pay $500 plus your provider bills.

### Do I need my own email and SMS provider?

Yes. Courier does not deliver anything itself. You connect SendGrid, Postmark, Twilio, Firebase, APNs, Slack, or any of more than fifty supported providers with your own credentials, and you pay those providers separately. The advantage is that you keep your existing rates, contracts, and sending reputation and can swap a provider with a settings change.

### Who is responsible for deliverability?

You are. Domain authentication, SPF and DKIM, bounce handling, list hygiene, and inbox reputation all sit with you and your chosen email provider. Courier's responsibility ends at handing a correctly rendered message to that provider. This is a fundamental difference from platforms like Ortto, Drip, or Customer.io that run the sending infrastructure themselves.

### Is Courier event-driven or list-driven?

Entirely event-driven. There is no contact list to upload and no campaign to schedule against a static audience. Your application calls the API when something happens and Courier decides the rest. That makes it unusable without engineering and very good at the things a list tool cannot do, such as digesting twelve events into one message.

### Can a non-developer use Courier?

For content, yes, and this is Courier's clearest edge over purely code-first alternatives. The visual template designer with multi-channel preview on one canvas lets a designer or PM own the copy and layout for email, SMS, push, and in-app versions of the same notification and ship updates without a deploy. Routing rules and automations are also dashboard-editable. What a non-developer cannot do is create the trigger.

### How does Courier handle notification fatigue?

With three tools: batching, which collapses many events into a single digest over a window you choose; throttling, which rate-limits sends so a burst of activity does not become a flood; and the preference center, which lets users keep the categories they want instead of turning everything off. These are the features teams most often build badly in-house and the most common reason companies arrive at Courier.

### Does Courier support self-hosting?

No, Courier is hosted only. Enterprise offers EU data residency for European buyers with regional requirements, but there is no on-premises deployment. Teams whose requirement is genuinely self-hosting should look at Novu for notification infrastructure or Dittofeed for the marketing automation equivalent, both of which are open source.

### Is Courier suitable for marketing campaigns or newsletters?

No, and the pricing makes that explicit. At $0.005 per send, a million-message newsletter would cost $5,000 in orchestration fees before any email was actually delivered, which is nonsense against an ESP's rate card. Courier is built for product notifications where each message is triggered by something happening. Use an ESP or a marketing automation platform for broadcast sending.

### Who founded Courier and how is it funded?

Courier was founded in 2019 by Troy Goode, who previously led an engineering group at Eloqua before Oracle acquired it and was CTO at Winmore. It went through Y Combinator's summer 2019 batch, raised a $10.1M Series A led by Bessemer Venture Partners in 2020 with strategic investment from Twilio, SendGrid, and Slack, and a $35M Series B in 2022. It is headquartered in San Francisco.

## Editorial verdict

Courier is the notification orchestration layer to pick when you want the least complicated bill and the friendliest content surface. Ten thousand free sends a month is enough for a real early-stage product, $0.005 a send with no seats and no channel fees is the most predictable pricing in this category, and the visual designer with multi-channel preview means the person writing the notification does not need an engineer to publish it. Set against Knock, its nearest rival, Courier wins on price in the low and middle volume bands and on design ergonomics, and loses on multi-tenancy depth and workflows-as-code discipline. The hard limits are structural rather than fixable: delivery is not included, deliverability is entirely your problem, there is no marketing capability, and the per-send rate makes broadcast sending economically silly. For a five-person startup whose product needs to notify people without annoying them, Courier is the cheapest sensible starting point in this batch. For a five-person startup whose problem is lifecycle marketing, it is the wrong shelf entirely.

---

Source: SaaSTracker (https://saastracker.org), an independent editorial project. This profile is compiled from public information, carries no peer reviews or paid placement, and was last reviewed 2026-08-22. Awards are judged on published criteria: https://saastracker.org/methodology