MagicBell logo

MagicBell

The notification bell you were about to spend a quarter building, plus the routing behind it

MagicBell is a notification infrastructure platform built around an embeddable in-app notification inbox, delivering product notifications across in-app, email, mobile push, web push, Slack, and SMS from a single broadcast API call routed through your own delivery providers, with built-in per-user preference management and a delivery planner for fallback rules, priorities, and delays, priced free to 1,000 deliveries a month and $249 a month for 50,000.

Visit website

Overview

MagicBell started from the front end and worked backwards, which is the opposite of most of this category and explains its shape. The founding observation was that every product eventually needs a notification bell, that building one properly means real-time delivery, read and unread state, cross-device synchronisation, infinite scroll, and preference controls, and that this is a quarter of engineering time nobody wants to spend on a widget. MagicBell shipped an embeddable inbox that does all of it, then built the multi-channel routing layer behind it.

The company was founded in 2020 by Hana Mohan and went through Y Combinator's Winter 2021 batch, backed by Cherry Ventures and Connect Ventures with roughly $4.5 million raised. Mohan had previously bootstrapped SupportBee for nine years, which shows in the product's restraint: MagicBell does one job and does not attempt to be a marketing platform. It reports more than a billion notifications delivered at 99.99 percent uptime across more than a thousand companies, with GitBook, Pitch, and Winamp among the named customers.

The model is event-driven and deliberately simple. You create a broadcast with a single API call, and MagicBell routes it across the channels your delivery planner specifies, respecting each recipient's preferences. Preferences are built in rather than something you construct: every notification carries a category, users choose which channels they want per category, and the platform enforces it automatically. That is the feature teams most reliably underestimate when they decide to build notifications themselves.

Delivery runs through providers you already use. You connect APNS, Firebase Cloud Messaging, SendGrid, Mailgun, Amazon SES, Twilio, and Slack with credentials supplied once, so sending reputation, contracts, and rates stay yours. The meter is deliveries, and it counts each channel separately: one notification reaching a user by both email and in-app is two deliveries. At $249 a month for 50,000 deliveries plus $0.0025 for each additional one, a multi-channel product should model that fan-out carefully before comparing against per-trigger competitors.

Best for

Product and engineering teams who primarily need a polished in-app notification inbox with real multi-channel escalation behind it, who value a small focused vendor over a sprawling platform, and whose notification volume fits comfortably inside 50,000 deliveries a month.

Not the right fit for

  • Marketing teams; MagicBell has no campaigns, no lists, no segmentation, and no conversion reporting, and every notification originates from an application event rather than a marketing schedule.
  • High-volume multi-channel products on a budget, because the meter counts each channel as a separate delivery, so a three-channel notification to 20,000 users is 60,000 deliveries and blows through the Startup tier in one send.
  • Teams that need sophisticated batching and digest as the core reason for buying; MagicBell handles priorities, delays, and fallbacks well, but SuprSend and Knock are more developed on collapsing event storms.
  • Buyers requiring published enterprise terms; single sign-on, security review, invoice billing, and unlimited volume all sit on a custom-priced Enterprise tier with no public figure.
  • Organisations that cannot accept vendor-continuity risk in a critical path; MagicBell is a very small team on roughly $4.5 million raised since 2020, and that is worth pricing honestly.

How it works

  1. 1

    You register users with MagicBell and connect your existing delivery providers, supplying credentials once in the dashboard or through the API. Nothing about your sending setup changes.

  2. 2

    Your application creates a broadcast with a single API call, naming a category, a set of recipients, and the content. That is the only code your engineers write per notification type.

  3. 3

    The delivery planner in the dashboard decides what happens next: which channels fire, in what priority order, with what delays, and what fallback applies if a channel fails or a user does not engage. Because it is configuration, changing the escalation policy for a notification type does not require a deployment.

  4. 4

    Per-user preferences are enforced automatically at this layer, so a recipient who has turned off email for a category never receives it regardless of the broadcast. The in-app channel renders through MagicBell's embeddable inbox component, with real-time delivery, read state, and cross-device synchronisation handled by the platform.

Feature breakdown

23 features in 5 modules

The in-app inbox

The reason most customers arrive, and the best-executed part of the product.
Embeddable notification inbox
A drop-in notification bell and feed with real-time delivery, read and unread state, and infinite scroll, replacing what is typically a multi-week internal project with an afternoon of integration.
Cross-device synchronisation
Read state syncs across web and mobile automatically, so a notification dismissed on a laptop does not reappear on a phone. This is the detail internal implementations almost always get wrong.
Deep customisation
Styling and layout hooks so the inbox matches your design system rather than announcing that it came from a vendor.
Headless usage
The inbox can be consumed as data through the API and SDKs for teams that want to render their own components entirely.
React and mobile components
First-class React components alongside SDK support that covers the common web and mobile paths.

Multi-channel delivery

Six channels, your providers, one API call.
Single broadcast API call
One call creates a notification for a set of recipients, and MagicBell handles channel routing, ordering, and preference enforcement without further application logic.
Delivery planner
Dashboard configuration of fallback rules, channel priorities, and delays, so a notification can try in-app first and escalate to email only if unread, all without a deployment.
Six channels
In-app inbox, email, mobile push through APNS and Firebase Cloud Messaging, web push, Slack, and SMS.
Bring your own providers
Connect SendGrid, Mailgun, Amazon SES, Twilio, APNS, FCM, and Slack with credentials supplied once. Your sending reputation and provider rates remain entirely yours and MagicBell never owns your delivery relationship.
Fallback and escalation
If a channel fails or a recipient does not engage within a configured window, the next channel fires, which is the correct pattern for anything time-sensitive.

Preferences and categories

Built in rather than bolted on, which is the feature teams most often underestimate.
Per-user channel preferences
Every notification carries a category and every user chooses which channels they want per category, with MagicBell enforcing those choices automatically on every send.
Notification categories
Categories organise notification types so preferences are meaningful rather than an all-or-nothing mute, which is the difference between users tuning and users leaving.
Preference UI included
The preference controls ship with the inbox component, so you do not build a settings page to accompany the feature.
Unlimited users on every tier
Recipient count is not part of the meter on any plan, so a large user base with light notification volume is priced sensibly.

Developer surface

Deliberately small and well documented rather than sprawling.
REST API
Full API for broadcasts, users, notifications, categories, preferences, and delivery configuration.
SDKs across major languages
Official libraries for React, Node.js, Ruby, Python, and Go, plus community packages in other ecosystems.
Notification primitive
MagicBell models a notification as a first-class object with its own lifecycle, state, and delivery record, which makes debugging what happened to a specific message straightforward.
Multiple projects
Five projects on the Startup tier with additional projects at $99 each, and unlimited projects on Enterprise, which suits agencies and multi-product companies.
Unlimited team members
Seats are not metered on any tier, so the whole engineering team can have dashboard access without a per-seat conversation.

Operations and enterprise

Reliable in production, with the formal enterprise apparatus reserved for custom pricing.
Published reliability record
More than a billion notifications delivered at a reported 99.99 percent uptime, with a public status page.
Delivery logs
Per-notification delivery records showing which channels fired, when, and with what result, which is what you need when a user says they never received something.
Security review support
Available on the Enterprise tier for organisations with formal vendor assessment processes.
Invoice billing and integration support
Enterprise adds invoice billing and hands-on integration assistance rather than self-serve card payment.

Use cases

4 documented

SaaS product with a notification bell on the roadmap

The design is agreed, the estimate is six weeks, and nobody wants to own real-time sync and read state indefinitely.

The embeddable inbox ships in days with cross-device read state handled, and the free tier at 1,000 deliveries a month covers development and internal testing at no cost.

Collaboration tool needing escalation, not spam

Time-sensitive mentions need to reach people, but emailing every mention immediately trains users to ignore the emails entirely.

The delivery planner sends in-app first, waits, and escalates to email or push only if the notification is still unread, and per-category preferences let each user decide the rules for themselves.

Agency or multi-product company

Several products each need notifications, and standing up separate infrastructure per product is wasteful.

Five projects are included on the Startup tier with additional projects at $99, sharing one account, one set of provider credentials, and one dashboard.

Team with a large user base and light notification volume

A hundred thousand registered users but only a few thousand notifications a month, and per-user pricing on competing tools is absurd for that shape.

MagicBell does not meter users at all, so the bill reflects actual notification volume rather than database size.

Pricing

from $0 (Builder), then $249 per month (Startup)

Tiered subscription metered on deliveries per month, where each channel counts separately, with unlimited users and unlimited team members on every tier.

PlanPriceIncludes
Builder$0
per month
  • 1,000 deliveries a month
  • 1 project
  • All channel integrations supported
  • Unlimited users and unlimited team members
  • Embeddable inbox component

Enough to build and test with, not enough to run a product of any size on.

Startup$249
per month
  • 50,000 deliveries a month
  • $0.0025 per additional delivery
  • 5 projects included, additional projects $99 each
  • All channel integrations supported
  • Unlimited users and unlimited team members

The only published paid tier, and the jump from 1,000 to 50,000 deliveries is where the price lives.

EnterpriseCustom
quoted
  • Unlimited deliveries
  • Unlimited projects
  • Integration support
  • Invoice billing
  • Security review

Add-ons

  • Additional project ($99 per month): Beyond the five included on the Startup tier.
  • Delivery overage ($0.0025 per delivery): Above the 50,000 included on the Startup tier.

Billing notes

  • Deliveries are counted per channel, so one notification reaching a user by both email and in-app consumes two. A three-channel notification to 20,000 recipients is 60,000 deliveries and exceeds the entire Startup allowance in a single send.
  • Users and team members are unlimited on every tier and are not part of the meter, which is unusually sensible for products with large user bases and light notification volume.
  • The gap between the free 1,000 deliveries and the paid 50,000 is large, and there is no intermediate tier, so a product outgrowing free goes straight to $249 a month.
  • Delivery costs are not included. You pay your own email, SMS, and push providers separately, so the subscription covers orchestration only.
  • Overages at $0.0025 per delivery are predictable but add up: an extra 100,000 deliveries in a month costs $250, doubling the base price.
  • Enterprise pricing is not published, so single sign-on, security review, and invoice billing require a sales conversation.

Value assessment: MagicBell's value depends almost entirely on your channel fan-out. For a product with 5,000 users where notifications land mainly in the in-app inbox, monthly deliveries are modest and the free or Startup tier is comfortable, so realistic spend is $0 to $249. For a product with 50,000 users where each notification goes to in-app, email, and push, four notifications per user per month is 600,000 deliveries, which is $249 plus 550,000 overages at $0.0025, roughly $1,624 a month. Engagespot would charge $250 for the same traffic because it meters triggers rather than deliveries. That comparison is the single most important thing a multi-channel buyer should run before choosing. Where MagicBell earns its price is the inbox itself: it is the most polished embeddable notification centre in this category, and if that component is the actual product you are buying, the rest is a reasonable package around it.

Strengths & limitations

Strengths

  • The embeddable inbox is the best-executed component of its kind in this category, handling real-time delivery, read state, and cross-device sync so you never build them.
  • Per-user, per-category channel preferences are built into the platform and enforced automatically, which is the feature teams most consistently underestimate when they decide to build notifications in-house.
  • The delivery planner makes escalation policy configuration rather than code, so trying in-app first and falling back to email only if unread is a dashboard change.
  • Bring your own delivery providers means your sending reputation, contracts, and per-message rates never move.
  • Users and team members are unlimited on every tier, so a large user base with light notification traffic is priced on what you actually send.
  • A focused product from an experienced founder, with more than a billion notifications delivered at a reported 99.99 percent uptime and a customer list including GitBook, Pitch, and Winamp.
  • Deliberate restraint: MagicBell does not pretend to be a marketing platform, which makes it much easier to reason about than tools that do.

Limitations

  • Per-channel delivery counting makes multi-channel fan-out expensive relative to per-trigger competitors, and the difference at volume can be five or six times.
  • There is nothing between the free 1,000 deliveries and the $249 Startup tier at 50,000, so outgrowing free is a large single step.
  • Batching and digest are less developed than SuprSend or Knock, so products generating activity storms should evaluate that specifically.
  • No published Enterprise pricing, so single sign-on, security review, and invoice billing all require sales contact.
  • Fewer channels than the broadest competitors: no WhatsApp, no Microsoft Teams, and no Discord.
  • A very small company on roughly $4.5 million raised since 2020, which is a genuine continuity consideration for infrastructure in a critical path.
  • No marketing capability at all, so this cannot substitute for a lifecycle marketing platform even though it shares the category label.

Head-to-head comparisons

5 alternatives

MagicBell vs Knock

from $0 (Developer), then $250 per month (Starter)

Knock is the broader and more institutionally established platform with deeper batching, a stronger enterprise posture, and more documentation. MagicBell's inbox component is more polished and its product surface is smaller and easier to reason about. Choose Knock when the notification problem is complex orchestration at scale; choose MagicBell when the notification bell is genuinely the thing you are buying.

Full MagicBell vs Knock comparison

MagicBell vs Novu

from $0 (Free or self-hosted), then $30 per month (Pro)

Novu is open source and self-hostable at no licence cost, which MagicBell does not offer at any tier. If controlling the infrastructure matters, or if the $249 step from free is prohibitive, Novu is the obvious alternative. MagicBell is the more polished managed product with a better inbox component and nothing for you to operate.

Full MagicBell vs Novu comparison

MagicBell vs SuprSend

from $0 (Free), then $110 per month (Essentials)

SuprSend charges $275 a month for 50,000 notifications against MagicBell's $249 for 50,000 deliveries, and adds batching and digest, Wait Until, object data modelling, and nine channels including WhatsApp and Teams. MagicBell has the better inbox and a simpler mental model. If notification fatigue and complex orchestration are the problem, SuprSend; if the embeddable notification centre is the problem, MagicBell.

Full MagicBell vs SuprSend comparison

MagicBell vs Engagespot

from $0 (Launch), then $250 per month (Growth)

Engagespot charges $250 a month for 250,000 event triggers where one trigger covers every channel, against MagicBell's $249 for 50,000 deliveries counted per channel. For a multi-channel product that is a five to fifteen times difference in effective cost, and Engagespot also includes Discord and WhatsApp. MagicBell's inbox component is better and its product is more mature. Model your own fan-out before deciding, because the economics can be decisive.

Full MagicBell vs Engagespot comparison

MagicBell vs OneSignal

from $0 (Free), then $19 per month plus usage (Growth)

OneSignal is a much larger vendor built around push notification scale, with a generous free tier for mobile and web push and a marketing-flavoured campaign layer MagicBell does not have. MagicBell is a developer-oriented notification primitive with a first-class in-app inbox. If push volume to a consumer app is the requirement, OneSignal; if a per-user notification feed inside a B2B product is the requirement, MagicBell.

Full MagicBell vs OneSignal comparison

Implementation & onboarding

Setup time
An afternoon to render the inbox and send a first broadcast. A week or two to migrate an existing spread of notification code, most of which is inventorying the call sites rather than integration work.
Learning curve
Low. The model is small: users, categories, broadcasts, channels, and preferences, with no separate object or subscription concepts to learn. This restraint is one of the product's genuine advantages over more elaborate competitors.
Onboarding
Entirely self-serve on the Builder and Startup tiers with card payment and no sales contact. Enterprise adds integration support, invoice billing, and security review, and requires a conversation.
Migration notes
Provider credentials transfer unchanged because MagicBell routes through your existing vendors, so there is no deliverability migration and no domain warm-up. Replace each existing notification call site with a broadcast call, define categories early so preferences are meaningful from the start, and configure the delivery planner before switching traffic over rather than afterwards.

Platform, API & security

Platforms
REST APIReact components for the in-app inboxNode.js, Ruby, Python, and Go SDKsWeb and mobile push delivery through your own providers
API
REST API covering broadcasts, users, notifications, categories, preferences, and delivery configuration, with official SDKs for React, Node.js, Ruby, Python, and Go. Notifications are modelled as first-class objects with their own state and delivery record.
Compliance
GDPRSecurity review available on the Enterprise tier
Data residency
Not published as a customer-selectable option on the self-serve tiers.
SSO
Not advertised on the published self-serve tiers; enterprise arrangements are quoted.
Security notes
More than a billion notifications delivered at a reported 99.99 percent uptime with a public status page. Because delivery routes through your own providers, sending credentials and reputation remain under your control. Formal security review is offered as part of the Enterprise engagement rather than as self-serve documentation.

Support & resources

Channels
Email supportIntegration support on the Enterprise tier
Documentation
Developer documentation covering the notification primitive, channels, the in-app inbox, preferences, and SDK references, with a public status page.
Community
Small developer community; the vendor invests in documentation rather than forums.

Company

Founded
2020
Headquarters
Barcelona, Spain
Ownership
Venture-backed
Founders
Hana Mohan
Employees
Fewer than 10 (est. 2026)
Funding
Approximately $4.5M raised, with backing from Y Combinator (Winter 2021), Cherry Ventures, and Connect Ventures.

Funding history

RoundAmountYearNotes
Y CombinatorStandard batch investment2021Winter 2021 batch.
SeedPart of roughly $4.5M total2021Backed by Cherry Ventures and Connect Ventures.

Timeline

  1. 2020Founded in Barcelona by Hana Mohan, who had previously bootstrapped the support tool SupportBee for nine years, around the observation that every product rebuilds the same notification bell.
  2. 2021Goes through Y Combinator's Winter 2021 batch and raises seed funding from Cherry Ventures and Connect Ventures.
  3. 2022Expands from the in-app inbox into multi-channel delivery across email, mobile push, web push, Slack, and SMS through customer-supplied providers.
  4. 2023Ships the delivery planner for fallback rules, channel priorities, and delays, plus built-in per-category user preference management.
  5. 2025Reports more than a billion notifications delivered at 99.99 percent uptime across more than a thousand companies including GitBook, Pitch, and Winamp.

Integrations

  • SendGrid, Mailgun, and Amazon SES for email
  • Twilio for SMS
  • Apple Push Notification service
  • Firebase Cloud Messaging
  • Web push providers
  • Slack
  • REST API and webhooks
  • React, Node.js, Ruby, Python, and Go SDKs

Frequently asked questions

10 questions

What is MagicBell?

MagicBell is notification infrastructure built around an embeddable in-app notification inbox. A single broadcast API call from your application is routed across in-app, email, mobile push, web push, Slack, and SMS through delivery providers you supply yourself, with per-user, per-category preferences enforced automatically and a delivery planner controlling fallback rules, priorities, and delays.

How much does MagicBell cost?

The free Builder plan covers 1,000 deliveries a month with one project. Startup is $249 a month for 50,000 deliveries with $0.0025 per additional delivery, five projects included and further projects at $99 each. Enterprise is custom-priced with unlimited deliveries and projects, integration support, invoice billing, and security review. Users and team members are unlimited on every tier.

How does the delivery meter work?

Deliveries are counted per channel. If one notification reaches a user by both email and the in-app inbox, that is two deliveries. A three-channel notification to 20,000 recipients is 60,000 deliveries and exceeds the entire Startup allowance in one send. This is the most important thing to model before buying, particularly against competitors such as Engagespot that count one trigger regardless of how many channels fire.

Is MagicBell event-driven or list-driven?

Event-driven. Notifications originate from application events, created through a broadcast API call at the moment something happens. There are no marketing lists, no campaign scheduling, and no segmentation, so a marketer cannot adopt MagicBell independently; engineering has to place the broadcast calls first.

What does MagicBell cost at 5,000 users versus 50,000?

Users are not metered, so the answer depends entirely on notification volume and channel fan-out. A product with 5,000 users where most notifications stay in the in-app inbox sits comfortably inside the Startup tier at $249, and often inside the free plan during development. A product with 50,000 users sending four notifications each across three channels generates 600,000 deliveries a month, which is $249 plus roughly $1,375 in overages, about $1,624. At that shape, a per-trigger competitor is much cheaper.

Do I bring my own email and SMS providers?

Yes. You connect SendGrid, Mailgun, Amazon SES, Twilio, APNS, Firebase Cloud Messaging, and Slack by supplying credentials once in the dashboard or through the API. Your sending reputation, provider contracts, and per-message rates stay entirely yours, and MagicBell charges for orchestration only, so your delivery bills sit alongside the subscription rather than inside it.

How does preference management work?

Every notification belongs to a category, and every user chooses which channels they want to receive for each category. MagicBell enforces those choices automatically on every send, and the preference controls ship with the inbox component so you do not build a settings page. This is the part teams most reliably underestimate when they choose to build notifications in-house, and it is one of the strongest reasons to buy rather than build.

Does MagicBell offer self-hosting or warehouse sync?

Neither is offered. MagicBell is a hosted service with no self-hosted or private-cloud deployment at any published tier, and there is no data warehouse connector for notification logs. If self-hosting is a hard requirement, Novu is the open-source comparison; if warehouse log sync matters, SuprSend offers it from its Business tier.

How does it handle notification fatigue?

Through the delivery planner and preferences rather than through batching. You can send in-app first, delay, and escalate to email only if the notification is still unread, and users can mute channels per category. What MagicBell does less of than SuprSend or Knock is collapsing a burst of forty events into one digest, so if your product generates activity storms, evaluate that gap specifically.

Should a five-person startup choose MagicBell?

If an in-app notification centre is the actual requirement, it is one of the best choices available and the free tier covers development. The question to answer honestly first is channel fan-out: if most notifications stay in the inbox, the economics are fine, but if every notification goes to three channels, model the delivery count against a per-trigger competitor before committing, because the difference at volume is large. Also weigh vendor size, since this is a sub-ten-person team holding infrastructure in your critical path.

Editorial verdict

MagicBell is the most focused product in notification infrastructure and the best at the one thing most buyers actually want, which is an embeddable notification inbox that handles real-time delivery, read state, cross-device sync, and per-category preferences without you building any of it. The delivery planner turns escalation policy into configuration, bringing your own providers keeps your sending reputation where it belongs, and not metering users is the right decision. The catch is the meter that it does use: deliveries counted per channel makes multi-channel fan-out expensive, and a per-trigger competitor can be five times cheaper for identical traffic. Buy MagicBell when the notification centre is the product decision and your fan-out is modest. Model the delivery count carefully if it is not, and weigh the fact that this is a very small company with roughly $4.5 million raised sitting in a path your users notice immediately when it breaks.

Written by the SaaSTracker editorial team. Awards, when shown, are judged against the published criteria in our methodology.