One API. Every channel your customers actually read.
Email, SMS, and WhatsApp on a single stack. Same reputation engine, same webhook schema, one bill. Built that way from day one, not stitched together from three acquisitions.
Why one API beats three integrations
Most teams end up with a billing pile-up nobody saw coming. SendGrid for transactional email. Mailchimp for marketing. Twilio for SMS. A separate WhatsApp Business Solution Provider for templated messages. Four invoices, four sets of credentials, four event-webhook formats your data pipeline has to normalize, four support contacts when something breaks.
Each individual product is decent. Stitched together they create the kind of overhead that only shows up at the 50-person company stage when someone in finance asks why messaging costs $14k a month and engineering can\'t produce a unified usage breakdown without three CSV exports.
A communications API is the obvious answer to that mess. The interesting question is what unification actually means at the infrastructure layer. The big CPaaS platforms describe themselves as unified but operate the channels as independent silos under one brand. That\'s what happens when you acquire your email product (SendGrid into Twilio) instead of building it. The accounts, billing, and dashboards are merged. The send infrastructure isn\'t.
We took the opposite approach. The channels share one event stream, one reputation engine, and one identity model. Below is what that practically means.
How we compare to the big CPaaS players
Where the channels are operationally unified versus where they\'re separate products under one brand
| Feature | sendmsg.io | Twilio | Vonage | Plivo |
|---|---|---|---|---|
| Email + SMS + WhatsApp from one API | Email is separate (SendGrid bolt-on) | Email is separate (Mailtrap acquisition) | Email is a separate product (Plivo Email) | |
| Unified reputation tracking across channels | — | — | — | |
| Single bill across email, SMS, WhatsApp | Separate billing per product | Separate billing | Separate billing | |
| Per-channel webhooks with consistent schema | Different schemas per product | Different schemas per product | Different schemas per product | |
| Reputation freeze applies across channels | — | — | — | |
| Real-time delivery events | ||||
| Free tier across all channels | Planned | Trial credit only | Trial credit only | Trial credit only |
| Open source SDK | Coming Q3 2026 |
Sourced from each provider\'s public product documentation as of 2026-05. We\'ll keep this table honest. If something here is wrong, email us and we\'ll correct it.
How a unified reputation engine works in practice
Here\'s the thing nobody on the marketing pages of CPaaS sites really explains: when your email reputation goes bad with a particular customer, that customer\'s relationship with your brand is bad. They\'re not going to suddenly love your SMS. They\'re going to mark it as spam too, or block your sender ID, or just ignore it.
We use this fact. Our Cortex engine tracks engagement signal at the contact level, not just the channel level. If a recipient marks three emails as spam, we drop their SMS priority too. If they hard-bounce on email but click your WhatsApp template, we know to keep WhatsApp as the active channel and not waste send capacity retrying email.
This matters in two concrete ways. First, it stops you from making the bad-engagement signal worse by stacking another channel on top. Second, it gives the customer a coherent experience. They\'re not getting messages from "[email protected]" while simultaneously getting SMS from a number they don\'t recognize, both about the same flow.
The Cortex also runs reputation calculations at three other levels above the contact: per sender ID per channel, per domain or short-code, and per client. When the per-client temperature dips below a threshold, we apply graduated throttle controls across all of that client\'s sending. Email, SMS, and WhatsApp all slow down together so that none of them dig the reputation hole deeper while the others recover.
There\'s a deliberate trade-off here. If you genuinely want one channel to keep firing while another is on fire (you\'re running a security alert flow and the email reputation just tanked), you can override the cross-channel coupling per activity. The default is unified, the override is opt-in. That\'s how we\'ve found teams actually want to work once they\'ve thought it through.
Three things you only get when the channels share infrastructure
Not architecture diagrams. The actual operational consequences for your team.
Reputation that spans channels
When a customer marks an email as spam, our Cortex doesn't pretend SMS to that same customer is unaffected. We track engagement signal across channels and adjust send behavior accordingly. The other platforms operate each channel as an independent silo because their products grew up that way through acquisitions.
One bill, one invoice, one usage view
You don't want to reconcile three separate vendors at the end of the month. Email volume, SMS segments, WhatsApp template messages: one usage dashboard, one invoice, one set of API keys. The savings here are mostly in finance team hours, not unit economics, but for a 20-person company that's real.
Webhooks with the same schema
Same event types across channels. Same payload structure. Same retry behavior. Same signing key format. Your event ingestion pipeline doesn't need three integrations. We'll publish the full event schema in our docs once the public release ships.
Send your first message in three lines per channel
Same auth, same response envelope, same webhook shape. Pick the channel.
curl -X POST https://api.sendmsg.io/v1/email/send \
-H "Authorization: Bearer YOUR_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"to": "[email protected]",
"from": "[email protected]",
"subject": "Your order is on its way",
"html": "<p>Tracking number: <strong>1Z999AA10123456784</strong></p>",
"priority": "high"
}'Full API reference, response shapes, and event-webhook schema in the API Documentation. SDKs for Node.js, Python, and Go are coming Q3 2026.
Three real flows you can build on this
Pulled from actual customer integrations. The pattern that\'s shared across all three is the cross-channel coupling. Same engagement signal feeds every decision.
Security verification with intelligent fallback
The user is trying to log in from a new device. You need to verify it\'s them, and you need to do it fast. SMS is the right channel because OTPs over WhatsApp violate Meta\'s policy for verification codes, and email is slow enough that 30% of users give up. But SMS deliverability varies by carrier and region, so a hard "SMS only" rule will lock some users out.
The flow: call our SMS endpoint with priority="transactional". If the carrier accepts the message within 5 seconds, we surface a success event and you move on. If we get a carrier-level deferral or no acknowledgement, we fall back to email automatically. The user gets the same OTP either way; the channel doesn\'t matter for their UX.
What you don\'t have to write: the retry logic. The fallback decision. The per-carrier handling. That\'s on our side because we have the delivery telemetry already. Your code just calls /v1/notify with the recipient and the message; we pick the channel based on each user\'s prior delivery history.
Order lifecycle with channel-shaped messages
A customer just placed an order. Over the next two weeks they\'ll receive (if everything goes well) five messages: order confirmation, payment cleared, shipped, out for delivery, delivered. Maybe two more after that for review request and reorder reminder.
Each of those messages has a natural channel. WhatsApp template for the order confirmation because it\'s a richer experience with the order details inline. SMS for the "out for delivery" message because that\'s the one customers check obsessively. Email for the receipt and the long-form post-purchase content. The communications API lets you script this whole flow against one set of credentials, with one event stream feeding your downstream analytics, and one identity layer that ties the recipient across channels.
The interesting part is what happens when the customer disengages partway through. If they stop opening emails after the shipping notification, our reputation engine notices. The reorder reminder a week later doesn\'t go out via email and try to bounce; it skips to a quieter WhatsApp template message that respects the engagement signal you already have. Same flow code, smarter delivery.
Support handoff that respects the customer\'s preferred channel
A customer fills out a contact form on your help center. Email confirmation goes out immediately. An agent picks up the ticket two hours later and replies. Where does the reply go? Old answer: back to the email thread, because that\'s where the conversation started. Better answer: wherever the customer is most likely to read it within the next ten minutes.
With the communications API, the agent\'s reply hits one endpoint with the contact ID and the message. We check what channels we have for that contact, what their engagement looks like across each, and what they\'re permitted to receive (WhatsApp template, SMS, transactional email). If they replied to a WhatsApp message yesterday, we send the agent\'s reply there. If they last opened email but haven\'t given a WhatsApp opt-in, we send it as email. The agent doesn\'t pick. The system does.
What you save: the entire opted-channel routing table that every support tool tries to build but few do well. What the customer gets: a reply where they\'re actually paying attention, instead of in the channel that was convenient for your help desk software. The satisfaction survey after ticket resolution follows the same logic, which is part of why response rates on multi-channel surveys outperform single-channel ones in our internal data.
These three flows have one thing in common: the channel decision happens at send time, not at code-write time. That\'s the real win of a unified API. You write the intent (notify this customer, send this confirmation, reply to this ticket) and the system picks the channel based on what it knows about each recipient. Same code, better delivery.
Want only one channel?
The unified API is the recommended path. If you only need one channel today, each one is also available standalone.
Common questions
Three channels, one stack, one bill
Get early access. We\'re onboarding teams in batches and the unified-billing dashboard rolls out per cohort.
No credit card required during early access