RCS API Complete Guide — Build Rich Messaging Experiences (2026)
RCS (Rich Communication Services) is the modern standard for business messaging, delivering read receipts, typing indicators, branded sender profiles, and rich media — all in the native Messages app without requiring a third-party install. This guide explains how RCS works, how it compares to iMessage and SMS, and how to send RCS messages via Sendblue's API with automatic protocol fallback.
What is RCS?
RCS (Rich Communication Services) is an open messaging protocol developed by the GSMA and supported natively on Android (via Google Messages) and — since iOS 18 — on iPhone for cross-platform conversations. It runs over IP rather than the cellular SS7 voice network that powers SMS.
RCS delivers a dramatically better experience than SMS without requiring a separate app:
- Read receipts — know when your message was opened
- Typing indicators — see when the recipient is composing a reply
- High-resolution images and video — no more compressed MMS thumbnails
- Branded business profiles — verified sender name, logo, and description visible to recipients
- Suggested reply chips — quick-tap responses for structured transactional flows
- No character limit — unlike SMS's 160-character ceiling
- Group messaging — proper group chats with participant management
Unlike iMessage, RCS works across carriers and device ecosystems — it is the universal upgrade path from SMS for everyone not on an iPhone.
RCS vs SMS vs iMessage — comparison table
| Feature | SMS | RCS | iMessage |
|---|---|---|---|
| Transport | Cellular (SS7) | IP (data) | IP (Apple servers) |
| Read receipts | No | Yes | Yes |
| Typing indicators | No | Yes | Yes |
| High-res media | No (MMS) | Yes | Yes |
| Encryption | No | Optional (E2E on Android) | End-to-end |
| Branded sender | No | Yes (verified) | No |
| Works on Android | Yes | Yes (native) | No |
| Works on iPhone | Yes | Yes (iOS 18+) | Yes (Apple only) |
| Requires special app | No | No | No (Apple devices) |
| A2P spam filters | Heavy | Moderate | None |
The practical summary: iMessage is best for iPhone-to-iPhone engagement — blue bubbles get 30–45% response rates with no spam filters. RCS is best for Android users or cross-platform campaigns where you need read receipts and rich media. SMS is the universal fallback for when neither is available.
RCS on iPhone — what changed in iOS 18
Before iOS 18, all iPhone-to-Android conversations fell back to SMS/MMS. Apple added RCS support in iOS 18, changing cross-platform messaging significantly:
- iPhone users now see read receipts and typing indicators when texting Android contacts
- Photos and videos send at full resolution in iPhone-to-Android threads
- Group chats between mixed iOS/Android devices work properly
These cross-platform conversations still appear as green bubbles on iPhone — RCS is not iMessage. iMessage (blue bubbles) remains Apple-to-Apple only. But RCS now fills the gap for cross-platform messaging with a dramatically better experience than the old SMS/MMS fallback.
For businesses sending to a mixed iOS/Android audience, this means RCS features are now available to iPhone recipients for non-iMessage conversations — expanding the effective reach of RCS messaging.
Sendblue's RCS support — automatic protocol routing
Sendblue automatically selects the best available protocol for each recipient. You write one API call; Sendblue handles all the routing logic:
- If the recipient has iMessage enabled → deliver as iMessage (blue bubble, highest engagement)
- Else if RCS is available for this number → deliver as RCS (read receipts, rich media)
- Else → deliver as SMS (universal fallback)
This means you get maximum reach and maximum engagement features without building any protocol detection logic yourself. The API request is identical regardless of which protocol is ultimately used:
curl -X POST https://api.sendblue.co/api/send-message \
-H "Content-Type: application/json" \
-H "sb-api-key-id: YOUR_API_KEY_ID" \
-H "sb-api-secret-key: YOUR_API_SECRET_KEY" \
-d '{
"number": "+14155551234",
"content": "Your package has shipped! Track here: https://track.example.com/abc123"
}'The response includes a status field (QUEUED → DELIVERED → READ) and a messageHandle for delivery tracking via webhook.
Send RCS with media using Node.js
Include a media_url field to attach an image, PDF, or video to the message. The same field works for iMessage, RCS, and MMS fallback:
import fetch from 'node-fetch';
async function sendRichMessage(toNumber, text, imageUrl) {
const payload = {
number: toNumber,
content: text,
};
if (imageUrl) {
payload.media_url = imageUrl;
}
const response = await fetch('https://api.sendblue.co/api/send-message', {
method: 'POST',
headers: {
'Content-Type': 'application/json',
'sb-api-key-id': process.env.SENDBLUE_API_KEY_ID,
'sb-api-secret-key': process.env.SENDBLUE_API_SECRET_KEY,
},
body: JSON.stringify(payload),
});
const data = await response.json();
console.log('Status:', data.status, '| Handle:', data.messageHandle);
return data;
}
// Text-only message (auto-routes to best available protocol)
await sendRichMessage('+14155551234', 'Your appointment is confirmed for tomorrow at 2pm.');
// Message with image attachment
await sendRichMessage(
'+14155551234',
'Here is your order summary:',
'https://yourserver.com/orders/12345/summary.png'
);Check iMessage vs RCS capability before sending
If you need to know in advance which protocol will be used — for analytics, routing logic, or audience segmentation — use the evaluate-service endpoint:
const response = await fetch(
`https://api.sendblue.co/api/evaluate-service?number=${encodeURIComponent('+14155551234')}`,
{
headers: {
'sb-api-key-id': process.env.SENDBLUE_API_KEY_ID,
'sb-api-secret-key': process.env.SENDBLUE_API_SECRET_KEY,
},
}
);
const data = await response.json();
// data.is_imessage: true → will deliver as iMessage (blue bubble)
// data.is_imessage: false → will use RCS or SMS fallback
console.log('Is iMessage capable:', data.is_imessage);This is useful for segmenting your audience: prioritize iMessage outreach for iPhone users (30–45% response rates), and use RCS for Android users to still get read receipts and rich media delivery confirmation.
RCS features — read receipts, typing indicators, branded sender
Sendblue's webhook delivers RCS delivery events to your server in the same format as iMessage events:
- Read receipts —
status: "READ"fires when the recipient opens the message thread - Typing indicators —
isTyping: trueevents in the inbound webhook when the recipient is composing a reply - Media delivery —
status: "DELIVERED"confirms the attachment was received
For branded sender (your company logo and verified name visible in the message thread header), Sendblue supports RCS Business Messaging (RBM) configuration. Contact the Sendblue team to set up a verified business profile for your sender number. See /features/rcs for the full setup guide.
When to use RCS vs iMessage
Use iMessage when:
- Your audience is primarily iPhone users (US enterprise, iOS-first apps)
- Response rate is the primary metric — iMessage gets 30–45%, SMS gets 6%
- You want iMessage-exclusive features: invisible ink, screen effects, Tapback reactions
- You are building an AI sales agent or outreach automation
Use RCS (or let Sendblue auto-route) when:
- Your audience is mixed iOS/Android or primarily Android
- You need a branded verified sender with your logo in the message thread
- You are sending transactional messages (shipping, appointments, 2FA) where universal delivery matters
- You want suggested reply buttons for structured flows like appointment confirmations or surveys
The simplest approach: use Sendblue's single API endpoint with automatic routing. You get iMessage where available, RCS for Android, and SMS as the fallback — one integration, maximum reach.
Next steps
- Sendblue RCS features — Branded sender setup, verified profiles, and suggested replies
- API reference — Full endpoint documentation with request/response schemas
- iMessage vs RCS vs SMS (2026) — Deep comparison for choosing the right channel
- Read receipts guide — How to use delivery and read events in your integration
Send RCS and iMessage from one API
Free sandbox, no credit card required. Automatic protocol fallback included.