Courier vs Knock for In-App Notifications: Free Tiers, Channel Limits, and Real Pricing

You're building a product and you need to send notifications — in-app bells, emails, push, maybe SMS. You've narrowed it down to Courier and Knock, both look reasonable on the surface, and now you're trying to figure out which one won't blindside you with a $400 invoice once you hit any kind of traction. That's a fair concern, and the answer isn't simple.

This article does the legwork: free tier limits, what each platform actually supports, where the pricing walls are, and which tool makes more sense depending on what you're shipping.

What you'll learn

• What Courier and Knock actually offer on their free plans
• Which notification channels each platform supports and how they're billed
• Where the pricing cliffs are and how to estimate your real costs
• Which platform suits small projects vs. growing products
• Gotchas that don't show up on the pricing page

A Quick Primer on Both Platforms

Before diving into numbers, it helps to understand what each product is trying to be.

Courier is a notification routing platform. Its core idea is that you send one API call, and Courier handles deciding which channel to deliver through — email, SMS, push, in-app — based on rules and user preferences. It's been around longer and has a broader feature surface: routing logic, template management, brand controls, and a fairly deep integration library.

Knock is a developer-first notification infrastructure tool. It launched later and takes a cleaner architectural stance: workflows as code (or near-code), a feed API for in-app notifications, and a tighter focus on the building blocks rather than drag-and-drop everything. It leans heavily into the idea that your engineering team should own the notification logic.

Both serve the same end goal. Where they differ is in philosophy, flexibility, and — critically — cost structure.

Free Tier: What You Actually Get

Courier Free Plan

Courier's free plan is generous enough to get a real project off the ground. As of the time of writing, it allows up to 10,000 notifications per month at no cost. That covers the basics for most early-stage products and side projects.

The catch is that the free plan restricts some of the more advanced routing features. You get access to email, SMS (via your own provider credentials), push, and basic in-app. Template management is available, but multi-brand support and some advanced tenant controls are gated behind paid tiers. There's also a limit on the number of users in your audience segment for certain features.

Courier uses a bring-your-own-provider model for most channels. You connect your Twilio account for SMS, your Sendgrid or Mailgun for email, and so on. This means your actual sending costs come from those providers separately — Courier charges for the orchestration layer on top.

Knock Free Plan

Knock's free tier caps at 10,000 monthly notifications as well, which makes direct comparison easy at least at this one data point. The free plan includes the in-app feed, email, push, and SMS channels, plus their workflow builder.

Where Knock's free tier stands out is that the in-app feed — the bell icon experience with read/unread state, real-time updates via WebSocket — is included even on free. This is a non-trivial feature to build yourself, and getting it for free is a real advantage if that's your primary use case.

Like Courier, Knock uses a bring-your-own-provider model for email and SMS. You wire up Sendgrid, Postmark, Twilio, or similar. Knock handles the workflow logic and delivery orchestration; the per-message costs on those channels flow through your provider accounts.

Channel Support: Side by Side

Both platforms cover the mainstream channels. The difference is in the depth of the implementation. Knock's in-app feed component is more polished out of the box — it ships with a React component, a JavaScript SDK, and hooks that plug into your frontend without much ceremony. Courier's in-app is functional but requires a bit more assembly.

For push notifications, both integrate with APNs and FCM. Neither does the push infrastructure itself — you still need Firebase or equivalent. They just manage the workflow and templating layer.

Paid Plans and Where the Pricing Walls Are

Courier Pricing

After the free tier, Courier's pricing moves to a usage-based model. You pay per notification delivered beyond the free allowance. The exact per-notification rate depends on your plan and volume, and Courier has historically offered a tiered model where higher volume gets you a lower unit cost.

Their growth plans add features like advanced routing, multi-brand support, audit logs, SLA guarantees, and priority support. The jump from free to the first paid tier can be meaningful depending on your volume. If you're sending 50,000 notifications a month, expect to pay for that volume on top of any base platform fee.

One thing worth knowing: Courier's pricing page doesn't always give you a clean per-notification number upfront. You often have to contact sales for anything beyond the self-serve entry tier, which can be frustrating when you're trying to run a quick build-vs-buy calculation.

Knock Pricing

Knock is more transparent about its pricing tiers. Their self-serve paid plan (typically called the Starter or Growth tier) charges a monthly base fee plus a per-notification rate above the included volume. The included volume on paid plans is higher, and the per-notification rate for overages is published openly.

One structural advantage Knock has: the in-app feed notifications are often counted differently from outbound channel notifications in their billing model. If your primary use case is the in-app feed, you may find that you get further on the same budget compared to outbound-heavy workloads.

Knock also gates features like tenant-level branding, custom roles, and SSO behind higher tiers. For B2B SaaS products where you need per-customer branding on notifications, this is a real consideration when estimating costs.

Developer Experience

Both platforms have REST APIs and SDKs, but they feel different to work with.

Knock's API design is opinionated in a way that most backend developers appreciate. You define a workflow, trigger it with a user and data payload, and Knock handles the rest. Here's a minimal example of triggering a Knock workflow from a Node.js backend:

import Knock from "@knocklabs/node";

const knock = new Knock(process.env.KNOCK_API_KEY);

await knock.workflows.trigger("new-comment", {
  recipients: [{ id: "user_123", email: "user@example.com" }],
  data: {
    commenter_name: "Alex",
    comment_text: "Great post!",
    post_url: "https://yourapp.com/posts/42",
  },
});

Courier's API follows a similar pattern. You send a message with a recipient and an event or template identifier. The routing logic lives in Courier's dashboard, which can be a convenience or a friction point depending on how much your team prefers code-driven configuration:

import { CourierClient } from "@trycourier/courier";

const courier = CourierClient({ authorizationToken: process.env.COURIER_AUTH_TOKEN });

const { requestId } = await courier.send({
  message: {
    to: { user_id: "user_123", email: "user@example.com" },
    template: "NEW_COMMENT",
    data: {
      commenter_name: "Alex",
      comment_text: "Great post!",
    },
  },
});

Both are clean. Knock's workflow model maps slightly better to complex branching logic (send email, wait 24 hours, send push if unread) because the workflow is the first-class concept. In Courier, similar logic is built visually in the dashboard, which is friendlier for non-engineers but can make version control and reproducibility harder.

In-App Notifications: Where Knock Has an Edge

If your primary goal is the in-app notification feed — the little bell icon that shows unread messages, alerts, and activity — Knock is meaningfully ahead in terms of out-of-the-box tooling.

Knock ships a @knocklabs/react-notification-feed package that gives you a pre-built, customizable notification bell and feed component. Plug it in, pass your user token, and you have a working feed in under an hour. It uses WebSockets for real-time delivery, so notifications appear instantly without polling.

Courier also has an in-app inbox component. It works, but the setup is more involved and the styling customization is less granular. For teams who want a polished feed fast, Knock's approach wins here.

If in-app is just one of several channels you need and you're more focused on routing and template management across email, SMS, and push, the gap narrows considerably.

Common Pitfalls and Gotchas

Notification counting varies by event vs. delivery. Both platforms can send one event that fans out to multiple channels (email + push + in-app). Some pricing models count each channel delivery separately; others count by event. Confirm which model applies before you multiply your expected volume.

Provider costs are separate. Neither Courier nor Knock covers your Twilio SMS costs or Sendgrid email costs. Budget for both layers. A misconfiguration that sends 10,000 duplicate SMS messages will show up on your Twilio bill, not theirs.

Free tier limits reset monthly. If your product has spiky usage — product launches, announcements, viral moments — your free tier headroom can evaporate in a day and you'll hit paid rates for the rest of the month.

Audit logs and log retention are gated. On free and entry-level paid plans, both platforms limit how far back you can query delivery logs. If debugging a missed notification from two weeks ago matters to you, check the log retention policy on the plan you're considering.

Workflow versioning in Courier is GUI-first. If your team treats infrastructure as code (IaC) and wants notification workflows in Git alongside your application code, Knock's model aligns better. Courier is catching up with API-driven configuration, but its primary workflow editing surface is still the dashboard.

Which One Should You Pick?

The honest answer is: it depends on what your product needs most right now.

Pick Knock if your primary use case is an in-app notification feed, you have a React frontend, your team is engineering-led and wants code-first workflow definitions, or you want transparent self-serve pricing you can calculate upfront.

Pick Courier if you need broader channel routing with complex preference management, your team prefers a visual workflow editor for non-engineers to manage, or you need specific integrations that Courier supports out of the box and Knock doesn't yet.

For small projects and side projects under the free tier limits, either works fine. The decision matters more when you start projecting growth past 50,000 notifications per month, when you need multi-tenant branding, or when audit and compliance requirements enter the picture.

Wrapping Up

Both Courier and Knock are solid tools with meaningful free tiers that can take you further than you'd expect before any costs kick in. The real differentiation shows up in developer ergonomics, in-app feed quality, and how their pricing scales as your product grows.

Here are concrete next steps to make your decision:

• Estimate your monthly notification volume across all channels, then check both platforms' paid tier calculators against that number.
• If in-app feed is a core feature, spin up Knock's React component in a sandbox project and assess how much you'd need to customize it.
• Look at the channels you actually need today — don't pay for routing sophistication you won't use for six months.
• Check log retention policies on both platforms against your debugging and compliance requirements.
• Start on whichever free tier fits your stack, but design your notification abstraction layer so switching providers doesn't require a full rewrite.