Building customer journeys with rich media, carousels, and interactive buttons in RCS delivers greater engagement than ever. However, reliable delivery is essential when mobile data coverage can temporarily fail, network timeouts can occur, or the recipient's device does not support RCS. The solution is intelligent SMS fallback logic built directly into the API infrastructure.
With a well-designed fallback strategy, you never have to choose between rich interactivity and 100% reach. If an RCS message cannot be delivered, the system seamlessly switches to SMS through the same API endpoint, without requiring you to build complex redundancy systems.
Why is automated fallback logic necessary?
Although RCS adoption is growing rapidly worldwide, a data-based message may not reach the recipient's screen in several situations:
- Temporary lack of mobile data: The recipient is in an area with weak mobile data coverage, such as on a train, in a garage, or abroad without roaming. Traditional SMS signaling may still work even when the mobile data connection is unavailable.
- The recipient does not support RCS: The recipient's device, operator, or application may not yet support RCS.
- Network timeouts and operator delays: If the operator's RCS gateway does not confirm delivery within the specified period, the message must be secured through the fallback channel.
By allowing the API to monitor the delivery chain automatically, business-critical messages such as one-time passwords (OTPs), delivery updates, and time-sensitive offers can always reach the customer.
The five fallback policies
The fallback logic is controlled through the fallbackPolicy parameter. You can select one policy or combine policies in a comma-separated string to tailor the behavior to the message.
| Policy | Description | Typical use case |
|---|---|---|
| NoFallback | No fallback is performed. Delivery stops if RCS fails. | Non-critical rich messages with no SMS equivalent. |
| FallbackOnNoCapability | An SMS is sent if the recipient does not support RCS. | Basic reach assurance before sending. |
| FallbackOnFailure | An SMS is sent if the RCS message is rejected or fails on the network. | Protection against technical network or operator errors. |
| FallbackAfterTimeout | An SMS is sent if no delivery confirmation is received within a specified period. | Time-sensitive messages, such as sign-in codes. |
| CustomerControlledFallback | The system sends callbacks so your application can control the fallback steps externally. | Complex business systems with custom business rules. |
Pro tip: Combine multiple policies for maximum reliability, for example:
"fallbackPolicy": "FallbackOnNoCapability,FallbackOnFailure,FallbackAfterTimeout" Configuring the fallback message (fallbackMessage)
An RCS message can contain a product carousel, high-resolution images, and interactive buttons. Because SMS is a text-only format, best practice is to define a dedicated fallbackMessage.
If no fallbackMessage is specified, the system attempts to generate text automatically from the RCS content. Setting explicit text ensures that the message remains clear in SMS format:
- RCS (Rich Card): Package image and an interactive "Track delivery" button.
- SMS (fallbackMessage): "Your package is on its way! Track your delivery here: https://dinhemsida.se/spara/12345"
For time-sensitive messages, also enable fallbackTimeOutSeconds, which specifies how many seconds the platform waits for RCS delivery confirmation before activating the SMS fallback.
API implementation with code examples
All requests use the platform's base URL and Bearer Token authentication.
Example 1: Single recipient (POST /v3/conversations)
using System.Net.Http.Headers;
using System.Text;
using System.Text.Json;
var apiKey = "YOUR_API_KEY";
using var client = new HttpClient();
client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", apiKey);
var payload = new
{
brand: "mitt-varumarke",
agent: "kundtjanst",
recipient: "46700123456",
fallbackPolicy: "FallbackOnNoCapability,FallbackOnFailure,FallbackAfterTimeout",
fallbackMessage: "Hello! Your service appointment is booked for June 15 at 10:00 AM. Need to reschedule? https://dinhemsida.se/omboka/12345",
fallbackTimeOutSeconds: 300,
type: "Card",
card: {
title: "Booking confirmation",
content: "We look forward to your service appointment on June 15 at 10:00 AM.",
mediaUrl: "https://cdn.dinhemsida.se/bilder/service.png",
type: "Standalone",
order: 0,
height: "Medium",
orientation: "Horizontal",
suggestions: [
{
text: "Reschedule appointment",
type: "OpenUrlAction",
order: 1,
url: "https://dinhemsida.se/omboka/12345",
postbackData: "reschedule_12345",
}
]
},
};
var json = JsonSerializer.Serialize(payload);
var content = new StringContent(json, Encoding.UTF8, "application/json");
var response = await client.PostAsync("https://api.ip1.net/v3/conversations", content);
var result = await response.Content.ReadAsStringAsync();
Console.WriteLine($"Status: {response.StatusCode}
Response: {result}");import asyncio
import httpx
api_key = "YOUR_API_KEY"
url = "https://api.ip1.net/v3/conversations"
payload = {
"brand": "mitt-varumarke",
"agent": "kundtjanst",
"recipient": "46700123456",
"fallbackPolicy": "FallbackOnNoCapability,FallbackOnFailure,FallbackAfterTimeout",
"fallbackMessage": "Hello! Your service appointment is booked for June 15 at 10:00 AM. Need to reschedule? https://dinhemsida.se/omboka/12345",
"fallbackTimeOutSeconds": 300,
"type": "Card",
"card": {
"title": "Booking confirmation",
"content": "We look forward to your service appointment on June 15 at 10:00 AM.",
"mediaUrl": "https://cdn.dinhemsida.se/bilder/service.png",
"type": "Standalone",
"order": 0,
"height": "Medium",
"orientation": "Horizontal",
"suggestions": [
{
"text": "Reschedule appointment",
"type": "OpenUrlAction",
"order": 1,
"url": "https://dinhemsida.se/omboka/12345",
"postbackData": "reschedule_12345"
}
]
}
}
async def send_message():
headers = {"Authorization": f"Bearer {api_key}"}
async with httpx.AsyncClient(headers=headers) as client:
response = await client.post(url, json=payload)
print(f"Status: {response.status_code}
Response: {response.text}")
asyncio.run(send_message())const apiKey = "YOUR_API_KEY";
const url = "https://api.ip1.net/v3/conversations";
const payload: ConversationPayload = {
brand: "mitt-varumarke",
agent: "kundtjanst",
recipient: "46700123456",
fallbackPolicy: "FallbackOnNoCapability,FallbackOnFailure,FallbackAfterTimeout",
fallbackMessage: "Hello! Your service appointment is booked for June 15 at 10:00 AM. Need to reschedule? https://dinhemsida.se/omboka/12345",
fallbackTimeOutSeconds: 300,
type: "Card",
card: {
title: "Booking confirmation",
content: "We look forward to your service appointment on June 15 at 10:00 AM.",
mediaUrl: "https://cdn.dinhemsida.se/bilder/service.png",
type: "Standalone",
order: 0,
height: "Medium",
orientation: "Horizontal",
suggestions: [
{
text: "Reschedule appointment",
type: "OpenUrlAction",
order: 1,
url: "https://dinhemsida.se/omboka/12345",
postbackData: "reschedule_12345",
},
],
},
};
const response = await fetch(url, {
method: "POST",
headers: {
"Authorization": `Bearer ${apiKey}`,
"Content-Type": "application/json",
},
body: JSON.stringify(payload),
});
const result = await response.text();
console.log(`Status: ${response.status}
Response: ${result}`);Example 2: Multiple recipients / Bulk send (POST /v3/bundles)
using System.Net.Http.Json;
var apiKey = "YOUR_API_KEY";
var rcsUrl = "https://api.ip1.net/v3";
using var client = new HttpClient();
client.DefaultRequestHeaders.Add("Authorization", $"Bearer {apiKey}");
async Task SendSmartMessages(string[] recipients, string text)
{
var rcsResponse = await client.PostAsJsonAsync($"{rcsUrl}/bundles", new
{
brand = "min-butik-ab",
agent = "DIN_AGENTS_ID",
type = "Card",
card = new
{
title = "Autumn Campaign 2026",
content = "Get 20% off all products in our store throughout October. Visit us today!",
mediaUrl = "https://example.com/images/hoestkampanj.jpg",
type = "Standalone",
order = 0,
suggestions = new[]
{
new
{
label = "Visit our store",
order = 0,
type = "OpenUrlAction",
url = "https://example.com/butik"
},
new
{
label = "View more offers",
order = 1,
type = "OpenUrlAction",
url = "https://example.com/erbjudanden"
}
},
height = "Medium",
Orientation = "Vertical"
},
recipients = recipients,
fallbackPolicy = "FallbackOnNoCapability, FallbackOnFailure",
fallbackMessage = text
});
}
var myNumbers = new[] { "46700123456", "46700987654", "456189040623" };
await SendSmartMessages(myNumbers, "Hello! This is a smart message.");import requests
API_KEY = "YOUR_API_KEY"
RCS_URL = "https://api.ip1.net/v3"
session = requests.Session()
session.headers.update({
"Authorization": f"Bearer {API_KEY}",
"Content-Type": "application/json"
})
def send_smart_messages(recipients: list[str], text: str):
payload = {
"brand": "min-butik-ab",
"agent": "DIN_AGENTS_ID",
"type": "Card",
"card": {
"title": "Autumn Campaign 2026",
"content": "Get 20% off all products in our store throughout October. Visit us today!",
"mediaUrl": "https://example.com/images/hoestkampanj.jpg",
"type": "Standalone",
"order": 0,
"suggestions": [
{
"label": "Visit our store",
"order": 0,
"type": "OpenUrlAction",
"url": "https://example.com/butik"
},
{
"label": "View more offers",
"order": 1,
"type": "OpenUrlAction",
"url": "https://example.com/erbjudanden"
}
],
"height": "Medium",
"Orientation": "Vertical"
},
"recipients": recipients,
"fallbackPolicy": "FallbackOnNoCapability, FallbackOnFailure",
"fallbackMessage": text
}
response = session.post(f"{RCS_URL}/bundles", json=payload)
response.raise_for_status()
return response.json()
my_numbers = ["46700123456", "46700987654", "456189040623"]
send_smart_messages(my_numbers, "Hello! This is a smart message.")const apiKey = "YOUR_API_KEY";
const rcsUrl = "https://api.ip1.net/v3";
async function sendSmartMessages(recipients: string[], text: string): Promise<unknown> {
const payload: CardMessagePayload = {
brand: "min-butik-ab",
agent: "DIN_AGENTS_ID",
type: "Card",
card: {
title: "Autumn Campaign 2026",
content: "Get 20% off all products in our store throughout October. Visit us today!",
mediaUrl: "https://example.com/images/hoestkampanj.jpg",
type: "Standalone",
order: 0,
suggestions: [
{
label: "Visit our store",
order: 0,
type: "OpenUrlAction",
url: "https://example.com/butik",
},
{
label: "View more offers",
order: 1,
type: "OpenUrlAction",
url: "https://example.com/erbjudanden",
},
],
height: "Medium",
Orientation: "Vertical",
},
recipients,
fallbackPolicy: "FallbackOnNoCapability, FallbackOnFailure",
fallbackMessage: text,
};
const response = await fetch(`${rcsUrl}/bundles`, {
method: "POST",
headers: {
"Authorization": `Bearer ${apiKey}`,
"Content-Type": "application/json",
},
body: JSON.stringify(payload),
});
if (!response.ok) {
const errorBody = await response.text();
throw new Error(`HTTP error! status: ${response.status} - ${errorBody}`);
}
return response.json();
}
// Call:
const myNumbers = ["46700123456", "46700987654", "456189040623"];
await sendSmartMessages(myNumbers, "Hello! This is a smart message.");Monitoring and status codes for fallback
When a message is processed by the fallback engine, its status is continuously updated through the API and your registered webhooks. This provides complete real-time traceability of the channel actually used for delivery.
Important status codes in the pipeline include:
- 121 (FallbackPending): RCS delivery could not be confirmed; the message has been prepared for SMS fallback.
- 122 (FallbackQueued): The message has been queued for delivery through the SMS gateway.
- 221 (FallbackDeliveredToHandset): The message was delivered to the recipient's phone through an alternative delivery path.
- 421 (FallbackRejected): The fallback request was rejected, for example because of an invalid number or missing authorization.
- 521 (FallbackFailed): The message could not be delivered through either RCS or SMS.
Best practices for maximum delivery reliability
- Match the timeout to the use case: For sign-in codes and one-time passwords (OTPs), set fallbackTimeOutSeconds to a low value, such as 30–60 seconds, so the customer does not have to wait. For marketing campaigns, 300–600 seconds gives the RCS network a reasonable amount of time to deliver.
- Always include a link in fallbackMessage: If your RCS message contained a clickable button to a landing page, include the corresponding web address as plain text in fallbackMessage.
- Measure channel distribution: Use the status codes to analyze the percentage of messages that reach recipients through RCS versus SMS. This provides valuable insight into how quickly RCS adoption is growing within your customer base.

