RCS Scenario

This request starts an RCS scenario for a list of numbers from its identifier (token).

To enable this feature, please contact the technical team

Overview

An RCS scenario is an automated dialogue configured on the platform: an entry message, clickable suggestions, and bot replies depending on the recipient's choices.

This route starts a scenario for a list of numbers by simply providing its identifier (scenarioToken), without having to rebuild its content. Once the entry message has been sent, the rest of the dialogue (bot replies to clicks) is handled automatically by the platform.

The identifier can also be pasted into our modules and connectors (PrestaShop, WooCommerce, Zapier, Make…) wherever an “RCS scenario identifier” is requested.

The identifier only designates the scenario to start. It does not expire, is not an authentication secret, and is recognized only for the account that owns the scenario (resolution based on the apiKey). The apiKey remains mandatory.

The identifier is available in RCS Scenarios (/dashboard/rcs/scenario), “API Identifier” column, Copy identifier button.

URL

POST https://api.smspartner.fr/v1/rcs/scenario/to/send

Rate limit: 30 requests / 60 seconds (see Rate limiting))

The platform does not send commercial SMS messages between 8 PM and 8 AM on weekdays and on Sundays and public holidays (legal restriction). If a commercial SMS is sent, the message is paused until the next working day at 8 AM. Not sending commercial SMS messages? Contact us to disable this restriction: [e-mail]

Required Parameters

Name	Value
apiKey	Your API key
scenarioToken	Identifier of the RCS scenario to start. The scenario must be validated / activated on the platform.
phoneNumbers	Recipient phone numbers. To send to multiple recipients, the numbers must be separated by commas. The limit per request is 500 numbers. They can be: in national format (06xxxxxxxx) or international format (+336xxxxxxxx), for French numbers. in international format (+496xxxxxxxx), for non-French numbers.

You do not send any richContent: the content comes from the scenario.

Optional Parameters

Name	Value
sender	Sender of the fallback SMS (failover).
tag	Free label to find the send later (3 to 20 characters, no spaces).
scheduledDeliveryDate	Send date in dd/mm/YYYY format (scheduled send).
time	Send time (0-24 format). If scheduledDeliveryDate is set, this parameter is required.
minute	Send minute (0-55 format, in five-minute intervals). If scheduledDeliveryDate is set, this parameter is required.
scheduledAt	Scheduled send as a single value: absolute date (2026-05-20 10:15, 20/05/2026 10:15, ISO 8601…) or relative delay (+2 hours, +3 days…). Replaces scheduledDeliveryDate / time / minute. The resulting date must be in the future and at most 3 months ahead.
sandbox	true = simulation, no real send.
urlDlr	Callback URL for delivery receipts.
urlResponse	Callback URL for replies / interactions.
failover	Fallback SMS if the RCS is not delivered: { "message": "...", "sender": "..." }.

Requests

PHP

<?php
        // Prepare data for POST request
        $fields = array(
            'apiKey'=> 'YOUR API KEY',
            'scenarioToken'=> 'SCENARIO_TOKEN',
            'phoneNumbers'=> '+336xxxxxxxx',
            'tag'=> 'cart-reminder',
            'failover'=> array(
                'sender'=> 'MyBrand',
                'message'=> 'Your cart is waiting: https://example.com/cart'
            )
        );


        $curl = curl_init();
        curl_setopt($curl, CURLOPT_URL,'https://api.smspartner.fr/v1/rcs/scenario/to/send');
        curl_setopt($curl, CURLOPT_RETURNTRANSFER, true);
        curl_setopt($curl, CURLOPT_TIMEOUT, 10);
        curl_setopt($curl, CURLOPT_POST, 1);
        curl_setopt($curl, CURLOPT_POSTFIELDS,json_encode($fields));

        $result = curl_exec($curl);
        curl_close($curl);

        // Process your response here
        echo $result;
?>

VB.net

Imports System.IO
Imports System.Net

Module Module1

  Sub Main()

    Dim base_url As String = "https://api.smspartner.fr/v1/"
    Dim apiKey As String = "YOUR_APIKEY"

    #start rcs scenario
    url = base_url & "rcs/scenario/to/send"
    #note: use a JSON library in production, for example:
    #https//www.nuget.org/packages/Newtonsoft.Json/
    Dim parameters As String = String.Format(
        "{{""apiKey"":""{0}"",""scenarioToken"":""{1}"",""phoneNumbers"":""{2}""}}",
        apiKey,
        "SCENARIO_TOKEN",
        "+33XXXXXXXXX")
    Console.Write(parameters)
    apiRequest("POST", url, parameters)

  End Sub

  Function apiRequest(method As String, url As String, parameters As String) As String

    Dim request As HttpWebRequest
    request = WebRequest.Create(url)
    request.Method = method
    request.Timeout = 10000   # timeout in ms
    request.ContentType = "application/json; charset=utf-8"
    request.ContentLength = 0

    #set POST data
    If Not String.IsNullOrEmpty(parameters) Then
      request.ContentLength = parameters.Length
      Using reqStream As StreamWriter = New StreamWriter(request.GetRequestStream())
        reqStream.Write(parameters)
      End Using
    End If

    #get response
    Dim returnValue As String = Nothing
    Using response As HttpWebResponse = request.GetResponse()
      If response.StatusCode = HttpStatusCode.OK Then
        Using resStream = response.GetResponseStream()
          If resStream IsNot Nothing Then
            Using reader As New StreamReader(resStream)
              returnValue = reader.ReadToEnd()
            End Using
          End If
        End Using
      End If
    End Using
    apiRequest = returnValue

  End Function

End Module

Python

# std
import json
from collections import OrderedDict

# 3p
import requests

API_KEY = "MY API KEY"
URL = "https://api.smspartner.fr/v1"


def start_scenario(scenario_token, phone_numbers):
    data = OrderedDict([
        ("apiKey", API_KEY),
        ("scenarioToken", scenario_token),
        ("phoneNumbers", phone_numbers),
    ])

    r = requests.post(URL + "/rcs/scenario/to/send", data=json.dumps(data))
    r_json = r.json()
    print(r_json)
    return r_json.get("success") is True

cURL

curl -H  "Content-Type: application/json" -X POST -d '{"apiKey":"xxxxx","scenarioToken":"SCENARIO_TOKEN","phoneNumbers":"+336xxxxxxxx"}' https://api.smspartner.fr/v1/rcs/scenario/to/send

Nodejs

const https = require('https');

// Prepare the data for the POST request
let data = JSON.stringify({
  apiKey: 'YOUR API KEY',
  // identifier of the RCS scenario created and activated in your SMS Partner account
  scenarioToken: 'SCENARIO_TOKEN',
  phoneNumbers: '+336XXXXXXXX',
  tag: 'cart-reminder',
  failover: {
    sender: 'MyBrand',
    message: 'Your cart is waiting: https://example.com/cart'
  }
});

let options = {
  hostname: 'api.smspartner.fr',
  path: '/v1/rcs/scenario/to/send',
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'Content-Length': data.length
  }
};

let req = https.request(options, (res) => {
  let data = '';
  res.on('data', (chunk) => {
    data += chunk;
  });

  res.on('end', () => {
    console.log(JSON.parse(data));
  });

}).on("error", (err) => {
  console.log("Error: " + err.message);
});

req.write(data);
req.end();

JAVA

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.net.HttpURLConnection;
import java.net.URL;

public class ScenarioRcs {
    public static void main(String[] args) {
        try {
            String apiKey = "your_api_key";
            String scenarioToken = "SCENARIO_TOKEN";
            String phoneNumbers = "+336XXXXXXXX";

            String jsonPayload = "{\"apiKey\": \"" + apiKey + "\", \"scenarioToken\": \"" + scenarioToken +
                    "\", \"phoneNumbers\": \"" + phoneNumbers + "\"}";

            URL url = new URL("https://api.smspartner.fr/v1/rcs/scenario/to/send");
            HttpURLConnection connection = (HttpURLConnection) url.openConnection();
            connection.setRequestMethod("POST");
            connection.setRequestProperty("Content-Type", "application/json");
            connection.setDoOutput(true);

            OutputStream outputStream = connection.getOutputStream();
            outputStream.write(jsonPayload.getBytes());
            outputStream.flush();
            outputStream.close();

            BufferedReader reader = new BufferedReader(new InputStreamReader(connection.getInputStream()));
            StringBuilder response = new StringBuilder();
            String line;
            while ((line = reader.readLine()) != null) {
                response.append(line);
            }
            reader.close();

            System.out.println(response.toString());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

Swift

import Foundation

let apiKey = "YOUR_API_KEY"
let scenarioToken = "SCENARIO_TOKEN"
let phoneNumber = "+336xxxxxxxx"

let url = URL(string: "https://api.smspartner.fr/v1/rcs/scenario/to/send")!

var request = URLRequest(url: url)
request.httpMethod = "POST"
request.addValue("application/json", forHTTPHeaderField: "Content-Type")

let parameters: [String: Any] = [
    "apiKey": apiKey,
    "scenarioToken": scenarioToken,
    "phoneNumbers": phoneNumber
]

request.httpBody = try? JSONSerialization.data(withJSONObject: parameters)

let task = URLSession.shared.dataTask(with: request) { (data, response, error) in
    if let error = error {
        print("Error: \(error)")
    } else if let data = data {
        print(String(data: data, encoding: .utf8) ?? "")
    }
}

task.resume()

Go

package main

import (
	"bytes"
	"encoding/json"
	"io/ioutil"
	"log"
	"net/http"
	"time"
)

func main() {
	data := map[string]interface{}{
		"apiKey":        "YOUR API KEY",
		"scenarioToken": "SCENARIO_TOKEN",
		"phoneNumbers":  "+336xxxxxxxx",
	}

	payload, err := json.Marshal(data)
	if err != nil {
		log.Fatalf("Error preparing data: %v", err)
	}

	client := &http.Client{Timeout: 10 * time.Second}
	req, err := http.NewRequest("POST", "https://api.smspartner.fr/v1/rcs/scenario/to/send", bytes.NewBuffer(payload))
	if err != nil {
		log.Fatalf("Error creating request: %v", err)
	}

	req.Header.Set("Content-Type", "application/json")

	resp, err := client.Do(req)
	if err != nil {
		log.Fatalf("Error sending request: %v", err)
	}
	defer resp.Body.Close()

	body, err := ioutil.ReadAll(resp.Body)
	if err != nil {
		log.Fatalf("Error reading response body: %v", err)
	}

	log.Printf("Response: %s", body)
}

C#

using System;
using System.Net.Http;
using System.Text;
using System.Threading.Tasks;
using Newtonsoft.Json;

class Program
{
    private static readonly HttpClient client = new HttpClient();

    static async Task Main(string[] args)
    {
        var request = new
        {
            apiKey = "YOUR_API_KEY",
            scenarioToken = "SCENARIO_TOKEN",
            phoneNumbers = "+336xxxxxxxx"
        };

        var content = new StringContent(
            JsonConvert.SerializeObject(request),
            Encoding.UTF8,
            "application/json");

        HttpResponseMessage response = await client.PostAsync("https://api.smspartner.fr/v1/rcs/scenario/to/send", content);

        if (response.IsSuccessStatusCode)
        {
            var result = await response.Content.ReadAsStringAsync();
            Console.WriteLine(result);
        }
        else
        {
            Console.WriteLine("POST request failed with status code: " + response.StatusCode);
        }
    }
}

Example with SMS fallback and scheduling

{
    "apiKey": "YOUR_API_KEY",
    "scenarioToken": "a1b2c3d4e5f6a7b8c9d0e1f2a3b4c5d6e7f8a9b0",
    "phoneNumbers": ["[phone]"],
    "tag": "cart-reminder",
    "scheduledAt": "+1 hour",
    "failover": {
        "message": "Your cart is waiting: https://example.com/cart",
        "sender": "MyBrand"
    }
}

What happens next

1. The scenario's entry message is sent to the provided numbers.

2. When a recipient clicks a suggestion, the RCS webhook automatically triggers the send of the next node of the scenario.

Response

json

{
   "success": true,
   "code": 200,
   "message_id": 123456,
   "nb_rcs": 2,
   "cost": 0.10,
   "cost_conversation": 0.04,
   "currency": "EUR"
}

Errors

json

{
    "success": false,
    "code": 64,
    "message": "The RCS scenario is not activated"
}

Error codes

Response code	Response
1	The API key is required
2	phoneNumbers is required
13	No default price to this destination
14	Number in the STOP list
50	scenarioToken is required (missing parameter)
55	No valid number to send to
63	RCS scenario not found: the token does not match any scenario in your account
64	The RCS scenario is not activated: the scenario exists but has not been validated / activated on the platform
65	The RCS scenario has no entry message / is empty: no valid first node (complete it on the platform)
96	IP not allowed
401	Account not authorized for RCS
403	User not authorized (invalid API key, disabled account…)

All other validations (numbers, scheduling, field sizes, credits…) are identical to a standard RCS send.