Scénario RCS

Cette requête démarre un scénario RCS pour une liste de numéros à partir de son identifiant (token).

Pour activer cette fonctionnalité merci de contacter l’équipe technique

Présentation

Un scénario RCS est un dialogue automatisé configuré sur la plateforme : un message d’entrée, des suggestions cliquables, et des réponses du bot selon les choix du destinataire.

Cette route démarre un scénario pour une liste de numéros en fournissant simplement son identifiant (scenarioToken), sans avoir à reconstruire son contenu. Une fois le message d’entrée envoyé, la suite du dialogue (réponses du bot aux clics) est gérée automatiquement côté plateforme.

L’identifiant peut aussi être collé dans nos modules et connecteurs (PrestaShop, WooCommerce, Zapier, Make…) partout où un « identifiant de scénario RCS » est demandé.

L’identifiant désigne uniquement le scénario à démarrer. Il n’expire pas, n’est pas un secret d’authentification et n’est reconnu que pour le compte propriétaire du scénario (résolution basée sur la apiKey). La apiKey reste obligatoire.

L’identifiant se récupère dans Scénarios RCS (/dashboard/rcs/scenario), colonne « Identifiant API », bouton Copier l’identifiant.

URL

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

Rate limit : 30 requêtes / 60 secondes (voir Limites de débit))

La plateforme n’envoie pas de SMS commerciaux entre 20h et 8h en semaine et les dimanches et jours fériés (restriction légale). Si un message SMS est envoyé, le message est en pause jusqu’au prochain jour ouvrable à 8h. Vous n’envoyez pas de SMS commerciaux ? Contactez nous pour désactiver cette restriction : [e-mail]

Paramètres obligatoires

Nom	Valeur
apiKey	Votre clé API
scenarioToken	Identifiant du scénario RCS à démarrer. Le scénario doit être validé / activé sur la plateforme.
phoneNumbers	Numéros de téléphone des destinataires. Pour l’envoi vers plusieurs destinataires les numéros doivent être séparés par des virgules. La limite d’envoi sur une seule requête est de 500 numéros. Ils peuvent être : au format national (06xxxxxxxx) ou international (+336xxxxxxxx), pour des numéros français. au format international (+496xxxxxxxx), pour des numéros hors France.

Vous n’envoyez pas de richContent : le contenu vient du scénario.

Paramètres optionnels

Nom	Valeur
tag	Étiquette libre pour retrouver l’envoi (3 à 20 caractères, sans espace).
scheduledDeliveryDate	(Déprécié) Date d’envoi au format dd/mm/YYYY (envoi différé).
time	(Déprécié) Heure d’envoi (format 0-24). Si scheduledDeliveryDate est défini, ce paramètre est obligatoire.
minute	(Déprécié) Minute d’envoi (format 0-55, par intervalle de cinq minutes). Si scheduledDeliveryDate est défini, ce paramètre est obligatoire.
scheduledAt	Envoi différé en une seule valeur : date absolue (2026-05-20 10:15, 20/05/2026 10:15, ISO 8601…) ou délai relatif (+2 hours, +3 jours…). Remplace scheduledDeliveryDate / time / minute. La date obtenue doit être dans le futur et au maximum 3 mois à l’avance.
sandbox	true = simulation, aucun envoi réel.
urlDlr	URL de callback pour les accusés de réception.
urlResponse	URL de callback pour les réponses / interactions.
failover	SMS de repli si le RCS n’est pas délivré : { "message": "...", "sender": "..." }.

Requêtes

PHP

<?php
        // Prepare data for POST request
        $fields = array(
            'apiKey'=> 'YOUR API KEY',
            'scenarioToken'=> 'SCENARIO_TOKEN',
            'phoneNumbers'=> '+336xxxxxxxx',
            'tag'=> 'relance-panier',
            'failover'=> array(
                'sender'=> 'MaMarque',
                'message'=> 'Votre panier vous attend : https://exemple.com/panier'
            )
        );


        $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 = "VOTRE_APIKEY"

    #start rcs scenario
    url = base_url & "rcs/scenario/to/send"
    #note : utiliser une librairie JSON en production, par exemple :
    #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');

// Préparer les données pour la requête POST
let data = JSON.stringify({
  apiKey: 'YOUR API KEY',
  // identifiant du scénario RCS créé et activé dans votre compte SMS Partner
  scenarioToken: 'SCENARIO_TOKEN',
  phoneNumbers: '+336XXXXXXXX',
  tag: 'relance-panier',
  failover: {
    sender: 'MaMarque',
    message: 'Votre panier vous attend : https://exemple.com/panier'
  }
});

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("Erreur: " + 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);
        }
    }
}

Exemple avec repli SMS et programmation

{
    "apiKey": "VOTRE_CLE_API",
    "scenarioToken": "a1b2c3d4e5f6a7b8c9d0e1f2a3b4c5d6e7f8a9b0",
    "phoneNumbers": ["[phone]"],
    "tag": "relance-panier",
    "scheduledAt": "+1 hour",
    "failover": {
        "message": "Votre panier vous attend : https://exemple.com/panier",
        "sender": "MaMarque"
    }
}

Ce qui se passe ensuite

1. Le message d’entrée du scénario est envoyé aux numéros fournis.

2. Quand un destinataire clique sur une suggestion, le webhook RCS déclenche automatiquement l’envoi du nœud suivant du scénario.

Réponse

json

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

Erreurs

json

{
    "success": false,
    "code": 64,
    "message": "Le scénario RCS n'est pas activé"
}

Code erreurs

Code de réponse	Réponse
1	La Clé API est requise
2	phoneNumbers est requis
13	Aucun prix par défaut vers cette destination
14	Numéro dans la liste STOP
50	scenarioToken est requis (paramètre absent)
55	Aucun numéro valide à envoyer
63	Scénario RCS introuvable : le token ne correspond à aucun scénario de votre compte
64	Le scénario RCS n’est pas activé : le scénario existe mais n’a pas été validé / activé sur la plateforme
65	Le scénario RCS n’a pas de message d’entrée / est vide : aucun premier nœud valide (à compléter sur la plateforme)
96	IP non autorisée
401	Compte non autorisé pour le RCS
403	Utilisateur non autorisé (clé API invalide, compte désactivé…)

Les autres validations (numéros, programmation, tailles de champs, crédits…) restent identiques à un envoi RCS classique.