Integrate rich, verified RCS messaging into your application, CRM, or platform with our clean REST API. Webhooks, SDKs for 6 languages, full documentation, and a free sandbox environment to test against — everything developers need to ship fast.
Our RCS API follows REST principles and uses JSON for all request and response bodies. Authentication is handled via Bearer token API keys, with optional OAuth 2.0 support for enterprise SSO environments. All endpoints are served over HTTPS with TLS 1.2+, and every response includes rate limit headers so your integration can handle throttling gracefully.
The API surface is organized around three core concepts: Messages (send and track individual or batch messages), Campaigns (manage bulk sends with scheduling and audience targeting), and Events (consume real-time delivery and interaction events via webhooks or polling). This design makes it straightforward to build anything from a simple transactional notification service to a fully-featured omnichannel messaging platform.
All six official SDKs wrap the same underlying REST API and share a common interface, so switching languages or frameworks is painless. SDKs handle authentication, serialization, error handling, retry logic, and webhook signature verification out of the box.
Clean, predictable endpoints with JSON bodies and standard HTTP status codes
Push events to your server for every delivery, read, click, and reply
Native libraries with auto-retry, error handling, and signature verification
Test your integration against a full-featured sandbox before going live
{
"to": "+919228818877",
"from": "my-business-agent",
"type": "rich_card",
"rich_card": {
"standalone_card": {
"card_orientation": "VERTICAL",
"thumbnail_image_alignment": "RIGHT",
"card_content": {
"title": "Exclusive 40% Off Sale!",
"description": "Your favourite items at unbeatable prices. Limited time only.",
"media": {
"url": "https://cdn.mystore.com/sale-banner.jpg",
"height": "TALL"
},
"suggestions": [
{
"action": {
"text": "Shop Now",
"postback_data": "action_shop_now",
"open_url_action": {
"url": "https://mystore.com/sale"
}
}
},
{
"action": {
"text": "View All Offers",
"postback_data": "action_view_offers",
"open_url_action": {
"url": "https://mystore.com/offers"
}
}
}
]
}
}
},
"fallback_sms": {
"text": "Exclusive 40% Off Sale! Shop now: https://mystore.com/sale"
}
}{
"message_id": "msg_3f8a9b2c1d4e5f6a",
"to": "+919228818877",
"status": "queued",
"channel": "rcs",
"created_at": "2026-09-15T10:23:45Z",
"estimated_delivery": "2026-09-15T10:23:46Z"
}{
"event_type": "message.button_clicked",
"message_id": "msg_3f8a9b2c1d4e5f6a",
"to": "+919228818877",
"postback_data": "action_shop_now",
"timestamp": "2026-09-15T10:23:52Z",
"metadata": {
"campaign_id": "camp_summer_sale_2026",
"segment": "loyal_customers"
}
}message.sent // Message accepted and queued
message.delivered // Message delivered to device
message.read // Read receipt received
message.button_clicked // Suggestion chip / action button tapped
message.reply_received // User replied with text
message.failed // Delivery failed (with reason)
message.fallback_sms // Fell back to SMS (device unsupported){
"campaign_id": "camp_summer_sale_2026",
"from": "my-business-agent",
"scheduled_at": "2026-09-16T09:00:00Z",
"fallback_sms": true,
"recipients": [
{
"to": "+919228818877",
"personalisation": {
"first_name": "Priya",
"offer_code": "PRIYA40"
}
},
{
"to": "+918765432109",
"personalisation": {
"first_name": "Rahul",
"offer_code": "RAHUL40"
}
}
],
"template_id": "tpl_summer_sale_rich_card",
"rate_limit": 5000
}{
"batch_id": "batch_9c2d1e4f5a6b7c8d",
"status": "scheduled",
"total_recipients": 2,
"scheduled_at": "2026-09-16T09:00:00Z",
"estimated_completion": "2026-09-16T09:00:01Z"
}Our SDKs are open-source, actively maintained, and include full test suites. Each SDK provides complete API coverage, built-in retry logic, and typed interfaces.
Full TypeScript typings, Promise and async/await support, compatible with Express, Fastify, Next.js, and all major Node.js frameworks.
npm install @rcsbulksms/node-sdk
Supports Python 3.8+. Compatible with Django, Flask, FastAPI, and standalone scripts. Includes async client for high-throughput applications.
pip install rcsbulksms
Compatible with PHP 7.4+ and 8.x. Installable via Composer. Works with Laravel, Symfony, WordPress, and custom PHP applications.
composer require rcsbulksms/php-sdk
Java 11+ compatible JAR available on Maven Central. Integrates with Spring Boot, Micronaut, and standard Java enterprise applications.
com.rcsbulksms:java-sdk:1.0.0
Idiomatic Go module with context support, goroutine-safe clients, and full test coverage. Built for high-performance microservices.
go get github.com/rcsbulksms/go-sdk
Compatible with Ruby 2.7+ and Ruby on Rails 6+. Available as a Gem. Includes ActiveJob integration for background message sending.
gem install rcsbulksms
Register HTTPS webhook endpoints to receive push notifications for every message lifecycle event: sent, delivered, read, button clicked, reply received, and failed. Webhook payloads are HMAC-SHA256 signed using your secret key, allowing your server to verify authenticity before processing. Retry logic with exponential backoff ensures no events are lost even during brief outages.
Pull campaign performance data programmatically via our reporting endpoints. Query delivery rates, read rates, click-through rates, and reply rates by campaign, date range, audience segment, or individual message ID. Aggregate data can be pulled hourly, daily, or monthly in JSON or CSV format for import into your data warehouse or BI tool.
Send millions of messages in a single API call using our batch endpoint. Pass a recipient list with per-recipient personalisation tokens, specify a template ID, set a scheduled send time, and configure rate limiting to match your backend's processing capacity. The campaign API tracks progress in real time and allows pausing, resuming, or cancelling in-flight campaigns.
Create, update, and manage RCS message templates via API. Templates support dynamic token substitution (e.g., {first_name}, {order_id}), multi-language variants, and version history. Pre-approved templates can be sent immediately without additional review, making them ideal for time-sensitive transactional messages like OTPs, delivery notifications, and payment confirmations.
Manage your recipient database via API: create and update contacts with custom attributes, organise into segments, and automatically honour opt-out requests. When a user replies STOP, the API marks them as opted out and suppresses all future messages automatically — keeping your messaging compliant with TRAI and global anti-spam regulations.
Before sending, query our capability check endpoint to determine whether a specific phone number supports RCS on its current device and carrier. Use this data to pre-classify your audience, make routing decisions at the application layer, or display RCS availability status within your customer dashboard. Bulk capability checks are supported for up to 10,000 numbers per request.
Most developers complete their first successful RCS send within 30 minutes of receiving their API key.
Sign up at bulkrcsmessage.com and navigate to the API section of your dashboard. Generate a test API key for the sandbox environment and a live API key for production. Keys are scoped — you can create read-only keys for analytics integrations and full-access keys for message sending. Store your API keys securely in environment variables, never in source code.
Install the official SDK for your language (see SDK section above) or configure your preferred HTTP client to send requests to https://api.bulkrcsmessage.com/v1/ with the Authorization: Bearer YOUR_API_KEY header. The base URL and authentication header are the only configuration required to start making API calls in the sandbox environment.
Use the POST /v1/messages endpoint to send a test rich card to your own phone number in the sandbox environment. The sandbox simulates the full RCS delivery flow including capability checks, delivery events, and webhook calls — letting you verify your integration end-to-end without incurring any charges or sending to real users.
Create a publicly accessible HTTPS endpoint on your server (or use a tool like ngrok during development). Register the URL via the POST /v1/webhooks endpoint or the dashboard settings. Your endpoint will immediately start receiving POST payloads for message events. Verify the X-RCS-Signature header in each request using the HMAC-SHA256 signature to confirm the payload is genuine.
Switch from your test API key to your live API key and ensure your RCS Business Messaging verified sender agent is active (verification takes 5–10 business days from application). Test in production with a small pilot audience first, confirm delivery reports and webhook events are flowing correctly, then scale to your full audience. Our team is available 24/7 during your first live campaign.
Everything you need to integrate, troubleshoot, and optimise your RCS API implementation.
Complete endpoint documentation with request/response schemas, authentication, error codes, and interactive API explorer.
Read Docs ›Language-specific guides, code samples, and API reference for all 6 official SDKs including TypeScript type definitions.
View SDKs ›Complete guide to configuring, securing, and processing webhook events including signature verification and retry handling.
Learn More ›Open-source example integrations for common use cases: e-commerce order updates, appointment reminders, OTP delivery, and more.
View on GitHub ›Pay per message with no monthly platform fees for API access. All plans include full API and webhook access.
Our RCS API is a standard RESTful HTTP API using JSON for request and response bodies. Authentication is handled via Bearer tokens (API keys). We also support OAuth 2.0 for enterprise integrations. All API endpoints are served over HTTPS with TLS 1.2 or higher.
Yes. Every new account includes a free trial with 1,000 RCS messages and full API access, no credit card required. This lets you fully test integration, message templates, webhooks, and SDK behaviour before committing to a paid plan. See our pricing page for full details.
Default rate limits are 100 API requests per second and up to 10,000 messages per minute for batch sends. Enterprise plans support higher throughput on request. Rate limit headers are returned with every API response so your integration can handle throttling gracefully.
The API automatically handles RCS capability checks before every send. If a recipient's device or carrier does not support RCS, the message falls back to SMS or MMS. The API response and webhooks indicate which channel was used for each individual message, giving your application full visibility. Learn more about our RCS Messaging platform.
Yes. Our API supports international number formatting (E.164 standard) and routes messages globally through our carrier network. RCS is available in 60+ countries and across all major carriers. For destinations without RCS support, SMS fallback ensures delivery.
You register a publicly accessible HTTPS endpoint on your server. Our API sends POST requests to that URL for every message event: sent, delivered, read, button clicked, or reply received. Each webhook payload is signed with your secret key so you can verify authenticity. Webhooks are retried up to 5 times with exponential backoff if your endpoint returns a non-2xx response.
Fill in your details and our team will set up your free demo account within 24 hours. No credit card required.