One API for SMS, WhatsApp and RCS: How Sent's Smart Routing Works

Adding messaging to an app looks like a one-liner until the second request. SMS, WhatsApp and RCS each bring their own credentials, formatting and failure modes; one market favors SMS, another leans on WhatsApp, a third just opened RCS. Eric Tech's demo parks right there and tests Sent — a unified API that promises to speak all three from one request — end to end to a real handset. The fastest way in the title is less slogan than architecture bet: the app should not choose the channel, the platform should decide and show its work.

Why One Channel Is Not Enough

Teams used to start on SMS, bolt on WhatsApp when it stuck, then patch RCS last. Every branch means another provider, another auth flow and another template language, plus fallback logic you write yourself when a channel stalls. Internationally it gets worse because SMS can be pricey or unreliable in one country while WhatsApp penetration is thin in another. The codebase forks, the test matrix swells and each new channel opens a new maintenance window. The video sums it up in one line — sending is easy, delivering everywhere is hard.

How Sent's Smart Routing Works

Sent flips that load. You do not write SMS or WhatsApp or RCS in the request; you give a recipient and a template reference and let the platform pick. Docs describe the router weighing availability, engagement signals and cost to choose the best live channel and to reformat content for it. Templates keep long copy out of app code so the same call may land as SMS today and RCS tomorrow without a code change. Compliance, identity and fallback stay platform-side as well — code stays lean while deliverability stays resilient.

Wiring the Notification Flow in TypeScript

The demo is deliberately modest. A fresh TypeScript project, Sent SDK install and an API key plus destination number in env; the shared sender path gets you moving fastest. A dedicated identity exists too, but US 10DLC and TCR approval takes one to three business days so starting now makes sense. The flow shown centers on sent.message with a template and variables rather than inlined copy, which eases both multi-channel adaptation and long-term maintenance. The skeleton looks like a small notification feature yet it is lean enough to live inside a larger product.

The first send returns two things — a message ID and an initial state. Moments later the channel Sent picked becomes visible, and that is where the abstraction proves its value. The same request can yield SMS, WhatsApp or RCS, but there is no branch in app code; channel specifics resolve platform-side. The clarity matters because the decision is observable, not hidden. Seeing which path was taken in logs makes debugging and cost tuning possible and removes channel assumptions for international sends.

Delivery Is Async: From Sent to Delivered via Webhook

An API accept is not delivery; messaging is async by nature. Hence the second act is webhooks. In the Sent dashboard you register an endpoint, subscribe to message.sent and message.delivered, and expose the local handler with a tunnel. The handler logs ID, event type, chosen channel and current state, and verifies the signature secret from env so random internet hits are not treated as events. Trigger again and sent lands first, delivered follows once the carrier confirms, with the whole trace visible in one terminal. The message popping on a real handset is the live proof — not a mock, a carrier confirmation.

Proof on a Real Handset and What It Means at Scale

By the end Sent's promise sharpens: as channels multiply you do not grow branches in code. Same request, same template ref, same webhook; when RCS coverage expands or prices shift the router updates its choice while your notification layer stays untouched. That abstraction lowers maintenance and lifts deliverability for transactional, verification or alert flows, especially internationally. The lifecycle, setup and event catalogs in the docs close the loop; you can reuse the same skeleton to try different templates and build your own multi-channel workflow.