Découvrez comment créer une campagne promotionnelle en associant le RCS et SendGrid grâce au langage C#

Time to read:

March 31, 2026

Rédigé par

Amanda Lange

Twilion

Révisé par

Dylan Frankcom

Twilion

Résumé généré par l’IA

Combinez la messagerie RCS et SendGrid afin de concevoir une campagne marketing cohérente sur l’ensemble de vos canaux de communication.
Configurez les services de messagerie RCS pour la diffusion de messages interactifs et SendGrid pour l’automatisation des envois d’e-mails.
L’intégration de ces deux technologies au sein d’une application .NET permet de coordonner vos communications promotionnelles et de garantir une expérience homogène sur les différents canaux utilisés.

Ce résumé a été généré par l’IA.

Découvrez comment créer une campagne promotionnelle en associant le RCS et SendGrid grâce au langage C#

En 2026, réussir à attirer l’attention de vos clients et, plus encore, à maintenir leur intérêt n’a jamais été aussi difficile. Pour faire la différence, une campagne promotionnelle ne peut plus se résumer à un SMS envoyé d’un côté ou à un e-mail diffusé de l’autre. Tout l’enjeu consiste désormais à faire fonctionner ces différents canaux en parfaite complémentarité, au service d’une communication cohérente et efficace. Si les SMS permettent de transmettre directement des messages promotionnels, les e-mails offrent un moyen supplémentaire de communiquer avec votre audience. En associant des modèles d’e-mails aux fonctionnalités enrichies de la messagerie RCS, vous pouvez donner une nouvelle dimension à vos campagnes et proposer une expérience de marque homogène, reconnaissable et soignée, quel que soit le canal emprunté.

Dans ce tutoriel, nous vous montrerons comment tirer parti de la complémentarité entre Twilio SendGrid et la messagerie RCS avec .NET 10 pour donner vie à une campagne marketing cohérente et parfaitement coordonnée. Vous découvrirez comment associer vos communications par e-mail à vos messages RCS, en vous appuyant sur des modèles qui partagent une même identité visuelle et une présentation harmonisée. Découvrons ensemble comment procéder.

Qu'est-ce que le RCS ?

Les cartes RCS sont des messages enrichis qui permettent d’intégrer des contenus multimédias et des fonctionnalités interactives. Là où les SMS traditionnels se limitent à des fonctionnalités relativement simples, le RCS ouvre la voie à des communications beaucoup plus riches et personnalisées. Il permet notamment d’afficher une identité d’expéditeur vérifiée et aux couleurs de votre marque, d’intégrer des titres et des images, ou encore de proposer des contenus interactifs qui invitent les destinataires à participer davantage aux échanges.

Si vous ne connaissez pas encore cette technologie, nous vous recommandons de consulter notre article consacré aux différences entre le RCS et les SMS, afin de mieux comprendre les caractéristiques et les possibilités offertes par chacun de ces canaux de communication.

La messagerie RCS est uniquement disponible sur les appareils et les réseaux des opérateurs compatibles. Si le destinataire ne dispose pas d’un appareil ou d’un service compatible avec le RCS, Twilio procédera automatiquement à l’envoi du message SMS de substitution configuré dans la section twilio/text du modèle utilisé.

Qu’est-ce que SendGrid ?

SendGrid est la plateforme d’envoi d’e-mails de Twilio. Elle vous permet de concevoir, d’automatiser et de diffuser facilement des campagnes de marketing par e-mail efficaces et percutantes. Grâce à SendGrid, vous pouvez automatiser vos campagnes en définissant de simples déclencheurs et utiliser des modèles personnalisables par glisser-déposer pour simplifier la création de vos e-mails promotionnels.

Ces deux services offrent des fonctionnalités complémentaires qui peuvent être associées afin de concevoir et de déployer des campagnes marketing cohérentes sur différents canaux de communication :

RCS (Rich Communication Services ou services de communication enrichie) : le RCS enrichit les fonctionnalités de la messagerie SMS traditionnelle. Il permet notamment l’intégration de carrousels d’images haute résolution, de boutons proposant des réponses prédéfinies, ainsi que l’affichage d’une identité d’expéditeur vérifiée et personnalisée à l’image de la marque. Ces fonctionnalités favorisent les interactions directes avec les destinataires et permettent de les inciter à réagir rapidement aux messages promotionnels.
SendGrid : l’e-mail offre quant à lui un espace privilégié pour approfondir la relation avec vos clients et raconter l’histoire de votre marque. Une photo diffusée par RCS a suscité leur intérêt ? Prolongez cette première interaction en leur envoyant un e-mail qui leur permettra d’explorer l’ensemble de votre catalogue, de découvrir votre univers et d’en apprendre davantage sur les valeurs et l’histoire de votre marque.

Mise en place d’une campagne marketing intégrant RCS et SendGrid

Avant de commencer, assurez-vous de disposer des éléments suivants :

Un compte Twilio (inscrivez-vous ici pour en créer un).
Un compte SendGrid (vous pouvez utiliser votre compte Twilio existant).
Un numéro de téléphone Twilio capable d’envoyer des SMS, afin de disposer d’une solution de repli lorsque les messages RCS ne peuvent pas être remis à leurs destinataires.
Un appareil compatible avec la réception de messages RCS.
L’environnement de développement .NET installé sur votre ordinateur.

Configuration de l’expéditeur RCS

Ce tutoriel fait suite à notre guide intitulé Comment envoyer un message RCS avec C# .NET et Twilio, dans lequel vous trouverez une présentation détaillée de la procédure de configuration d’un expéditeur RCS, accompagnée de captures d’écran illustrant les différentes étapes. Avant de poursuivre, procédez à la configuration de votre expéditeur RCS depuis le tableau de bord RCS de Twilio, conformément à l’exemple présenté ci-dessous. Cette opération nécessite notamment de disposer d’un logo sous forme de fichier image, destiné à identifier votre expéditeur, ainsi que d’un appareil compatible pour les opérations de test. Vous devrez ensuite enregistrer cet appareil en tant que testeur RCS (RCS Tester) afin de pouvoir vérifier le bon fonctionnement des différentes fonctionnalités présentées dans la suite du tutoriel.

Configuration d’un modèle dynamique SendGrid

Vous devrez créer un modèle dynamique dans SendGrid, dont la présentation et l’identité visuelle correspondront à celles des messages RCS utilisés dans votre campagne. Connectez-vous au tableau de bord SendGrid, puis accédez à la rubrique Email API > Dynamic Templates (modèles dynamiques). Attribuez à votre modèle un nom clair et facilement identifiable, puis cliquez sur Créer (Create). Nous allons maintenant mettre en place un modèle dynamique qui vous permettra de vous appuyer sur une même structure, réutilisable par programmation, pour concevoir à la fois vos messages RCS et les e-mails qui les accompagnent. Cliquez sur le bouton Create a Dynamic Template (Créer un modèle dynamique). Attribuez à votre modèle un nom suffisamment explicite pour pouvoir le retrouver facilement, puis poursuivez la procédure.

Une fois votre modèle créé, cliquez sur la flèche située à côté de son nom pour afficher le volet de modification. À cette étape, l’identifiant unique de votre modèle (Template ID) s’affiche dans l’interface. Veillez à conserver cet identifiant, car il sera nécessaire pour référencer le modèle depuis votre application d’envoi d’e-mails.

Pour procéder à la configuration du reste du modèle, cliquez sur Add Version, (Ajouter une version) puis sélectionnez Blank Template (modèle vierge). SendGrid vous propose alors deux méthodes de création : la conception du modèle directement à l’aide de code ou l’utilisation d’un éditeur graphique reposant sur une interface de glisser-déposer. Dans le cadre de ce tutoriel, nous allons privilégier cette seconde approche et l’associer au système de modèles Handlebars afin de créer un modèle véritablement dynamique, dont le contenu pourra être personnalisé à l’aide de variables.

Sélectionnez ensuite Design (Conception) : SendGrid ouvrira l’éditeur dans lequel vous pourrez commencer à personnaliser votre modèle d’e-mail. Dans le champ objet de votre e-mail, saisissez {{subject}}, cette expression définit un emplacement réservé dont le contenu sera remplacé par la valeur dynamique transmise par votre application lors de la génération de l’e-mail. Procédez de la même manière pour le champ pré-en-tête, qui correspond au texte d’aperçu de votre e-mail, en y saisissant {{preheader}}.

Vous pouvez maintenant poursuivre la personnalisation de votre modèle en ajoutant les différents espaces réservés qui accueilleront vos contenus dynamiques, ainsi que les textes de votre choix. Pour ajouter une image, insérez le module Image, puis accédez à l’option permettant de modifier le code HTML associé à cet élément. Remplacez l’URL de l’image par la variable {{image_url}}, conformément à l’exemple présenté ci-dessous.

Il est également possible d’intégrer un bouton au modèle dans le cadre de ce tutoriel. Faites glisser l’élément Bouton vers l’emplacement souhaité dans votre modèle d’e-mail, puis renseignez le champ Texte du bouton avec {{button_text}} et le champ URL du bouton avec {{button_url}}.

Une fois votre modèle entièrement configuré, vous devriez obtenir un résultat semblable à celui présenté ci-dessous :

the sendgrid template with all placeholders

N’oubliez pas d’enregistrer votre modèle pour conserver toutes vos modifications.

SendGrid vous permet de créer et d’enregistrer plusieurs versions d’un même modèle dynamique, sans avoir à leur attribuer des identifiants différents. Pour que votre solution fonctionne correctement, assurez-vous que la version du modèle que vous venez de créer est bien celle qui est définie comme active.

Création de votre application .NET associant RCS et SendGrid

L’application .NET assurera l’intégration de ces deux services au sein d’une même solution, permettant ainsi l’envoi simultané de messages RCS et d’e-mails.

Ouvrez votre environnement de développement intégré (IDE), puis commencez par créer un nouveau projet d’API Web .NET.

mkdir RcsEmailSender
cd RcsEmailSender
dotnet new console
dotnet new sln
dotnet sln add RcsEmailSender.csproj

Vous aurez besoin des packages NuGet suivants pour mettre en place les différentes fonctionnalités de l’application :

dotnet add package SendGrid
dotnet add package Twilio
dotnet add package Microsoft.Extensions.Configuration
dotnet add package Microsoft.Extensions.Configuration.Json
dotnet add package Microsoft.Extensions.Configuration.EnvironmentVariables

Ce projet requiert également la définition de plusieurs paramètres de configuration. Pour les besoins de ce tutoriel, ces paramètres seront déclarés dans le fichier appsettings.json, que vous devrez créer dans le répertoire de votre projet. Commencez par créer ce fichier dans le dossier de votre projet. Insérez les lignes de configuration suivantes dans ce fichier, en remplaçant les valeurs de substitution par les informations propres à votre application.

{
 "MessageServices": {
   "Twilio": {
     "AccountSid": "YOUR_TWILIO_ACCOUNT_SID",
     "AuthToken": "YOUR_TWILIO_AUTH_TOKEN",
     "FromNumber": "+15551234567"
   },
   "SendGrid": {
     "ApiKey": "YOUR_SENDGRID_API_KEY",
     "FromEmail": "no-reply@example.com",
     "FromName": "Example Sender",
     "TemplateId": "d-XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"
   },
   "Recipients": {
     "PhoneNumber": "+15557654321",
     "Email": "recipient@example.com"
   }
 }
}

Vous trouverez le SID de votre compte Twilio (Account SID) et votre jeton d’authentification (Auth Token) dans votre tableau de bord Twilio. Le numéro spécifié dans le paramètre From correspond au numéro d’expéditeur utilisé pour l’envoi des messages RCS. Pour permettre l’envoi d’e-mails via SendGrid, vous devrez générer une clé API disposant des autorisations appropriées. Si vous optez pour une clé API personnalisée, veillez à ce que les droits d’accès Mail Send lui soient explicitement accordés. L’identifiant de votre modèle dynamique (Dynamic Template ID) peut être récupéré depuis le tableau de bord SendGrid, en consultant les informations associées au modèle créé lors des étapes précédentes. Le paramètre FromEmail doit être renseigné avec une adresse e-mail d’expéditeur préalablement vérifiée dans SendGrid. Le paramètre FromName, quant à lui, peut contenir tout nom explicite et facilement identifiable. Dans la section Recipients (destinataires), indiquez le numéro de téléphone et l’adresse e-mail des destinataires que vous utiliserez pour réaliser les tests de votre application.

Plusieurs mécanismes permettent de sécuriser le stockage et l’utilisation des variables d’environnement dans un projet .NET. Cette démonstration repose sur une approche volontairement simplifiée. Il est néanmoins essentiel de ne jamais intégrer à un dépôt GitHub, ni à aucun autre système de gestion de versions, du code contenant des variables d’environnement ou des données de configuration sensibles. Pour obtenir davantage d’informations sur les bonnes pratiques en matière de stockage sécurisé, nous vous invitons à consulter notre guide expliquant comment définir et gérer les variables d’environnement.

Vous pouvez désormais commencer à intégrer le code nécessaire au fonctionnement de votre projet.

La première étape consiste à définir les modèles de données qui seront exploités par les fonctionnalités d’envoi de messages RCS et d’e-mails.

Dans un projet de plus grande envergure, ces modèles seraient généralement organisés dans un dossier qui leur est réservé, afin de conserver une architecture claire et facile à maintenir. Pour cette démonstration, nous allons privilégier la simplicité et les regrouper dans un seul fichier, qui contiendra toutes les définitions dont nous aurons besoin pour la suite du tutoriel.

Créez un fichier intitulé Models.cs et insérez-y le code ci-dessous :

using System;
namespace RcsEmailSender
{
   // Configuration class for storing API keys and credentials
   public class MessageServiceConfig
   {
       public string TwilioAccountSid { get; set; } = string.Empty;
       public string TwilioAuthToken { get; set; } = string.Empty;
       public string TwilioFromNumber { get; set; } = string.Empty;
       public string SendGridApiKey { get; set; } = string.Empty;
       public string SendGridFromEmail { get; set; } = string.Empty;
       public string SendGridFromName { get; set; } = string.Empty;
       public string SendGridTemplateId { get; set; } = string.Empty;
       public string RecipientPhoneNumber { get; set; } = string.Empty;
       public string RecipientEmail { get; set; } = string.Empty;
   }
   // Consolidated message model for both RCS and Email
   public class MessageContent
   {
       public string Title { get; set; } = string.Empty;
       public string Body { get; set; } = string.Empty;
       public string ImageUrl { get; set; } = string.Empty;
       public string ButtonText { get; set; } = string.Empty;
       public string ButtonUrl { get; set; } = string.Empty;
   }
}

Enregistrez le fichier contenant les définitions de vos modèles de données.

Vous pouvez désormais passer à l’implémentation de la logique applicative du projet. Pour cela, ouvrez le fichier Program.cs et remplacez l’intégralité du code existant par le code suivant :

using Microsoft.Extensions.Configuration;
using SendGrid;
using SendGrid.Helpers.Mail;
using Twilio;
using Twilio.Rest.Api.V2010.Account;
using Twilio.Types;
namespace RcsEmailSender
{
   class Program
   {
       static async Task Main(string[] args)
       {
           // Set up configuration system
                var configuration = new ConfigurationBuilder()
               .SetBasePath(Directory.GetCurrentDirectory())
               .AddJsonFile("appsettings.json", optional: false, reloadOnChange: true)
               //.AddEnvironmentVariables("RCS_EMAIL_") // Allows overriding with environment variables prefixed with RCS_EMAIL_
               .Build();
           // Load config from configuration
           var config = new MessageServiceConfig
           {
               TwilioAccountSid = configuration["MessageServices:Twilio:AccountSid"] ?? string.Empty,
               TwilioAuthToken = configuration["MessageServices:Twilio:AuthToken"] ?? string.Empty,
               TwilioFromNumber = configuration["MessageServices:Twilio:FromNumber"] ?? string.Empty,
               SendGridApiKey = configuration["MessageServices:SendGrid:ApiKey"] ?? string.Empty,
               SendGridFromEmail = configuration["MessageServices:SendGrid:FromEmail"] ?? string.Empty,
               SendGridFromName = configuration["MessageServices:SendGrid:FromName"] ?? string.Empty,
               SendGridTemplateId = configuration["MessageServices:SendGrid:TemplateId"] ?? string.Empty,
               RecipientPhoneNumber = configuration["MessageServices:Recipients:PhoneNumber"] ?? string.Empty,
               RecipientEmail = configuration["MessageServices:Recipients:Email"] ?? string.Empty
           };

Cette première partie du programme assure la récupération des clés API et des autres informations de sécurité nécessaires à l’application, à partir du fichier de configuration appsettings.json créé lors des étapes précédentes. Une ligne de code facultative, présente sous forme de commentaire, permet également de prévoir l’utilisation de variables d’environnement comme autre source de configuration, si vous souhaitez privilégier cette approche. Une fois ces informations réunies, l’application s’en sert pour créer une instance de MessageService, à partir du modèle contenant les paramètres nécessaires à son fonctionnement.

Ajoutez maintenant le bloc de code suivant :

var messageContent = new MessageContent
           {
               Title = "Owl Air Elite Status",
               Body = "Congratulations! You've reached Elite status. Add code ELITE10 for 10% off your next flight. Book at twilio.com or call +15551234567",
               ImageUrl = "https://rcs-4036.twil.io/image.png", // Image URL for testing
               ButtonText = "Book Now",
               ButtonUrl = "https://twilio.com"
           };

Ce nouveau bloc de code permet de construire le message RCS que nous souhaitons envoyer. Vous pouvez dès à présent le personnaliser en remplaçant l’URL de test par celle de l’image de votre choix. Si vous préférez conserver la configuration proposée pour cette première démonstration, laissez simplement l’URL telle quelle : le message utilisera alors le logo Twilio comme image.

Complétez votre fichier Program.cs en y insérant le bloc de code suivant :

try
           {
               //Send RCS message
               var rcsResult = await SendRcsMessage(config, messageContent);
               Console.WriteLine($"RCS message sent: {rcsResult}");
               // Send Email
               var emailResult = await SendEmailWithDynamicTemplate(config, messageContent);
               Console.WriteLine($"Email sent: {emailResult}");
           }
           catch (Exception ex)
           {
               Console.WriteLine($"Error sending messages: {ex.Message}");
           }
       }

Cette partie du programme assure l’envoi effectif des messages RCS et des e-mails. Elle prend en charge les contenus associés à ces deux types de communication et les transmet aux composants correspondants, à savoir le modèle dynamique utilisé pour la génération des e-mails et le service de messagerie RCS.

Pour finaliser l’implémentation du fichier Program.cs, ajoutez les blocs de code ci-dessous :

static async Task<string> SendRcsMessage(MessageServiceConfig config, MessageContent content)
       {
           TwilioClient.Init(config.TwilioAccountSid, config.TwilioAuthToken);
           var message = await MessageResource.CreateAsync(
               body: $"{content.Title}\n\n{content.Body}\n\nClick here: {content.ButtonUrl}",
               from: new PhoneNumber(config.TwilioFromNumber),
               to: new PhoneNumber(config.RecipientPhoneNumber),
               mediaUrl: new List<Uri> { new Uri(content.ImageUrl) } 
           );
           return message.Sid;
       }
       // Method to send email using SendGrid with dynamic template
       static async Task<bool> SendEmailWithDynamicTemplate(MessageServiceConfig config, MessageContent content)
       {
           // Initialize SendGrid client
           var client = new SendGridClient(config.SendGridApiKey);
           var from = new EmailAddress(config.SendGridFromEmail, config.SendGridFromName);
           var to = new EmailAddress(config.RecipientEmail);
           var msg = new SendGridMessage();
           msg.SetFrom(from);
           msg.AddTo(to);

           msg.SetTemplateId(config.SendGridTemplateId);
           // Define template data with proper naming that matches the SendGrid template
           var templateData = new
           {
               subject = content.Title,
               preheader = "Special offer inside!", // Optional preheader text
               title = content.Title,
               body_text = content.Body,
               image_url = content.ImageUrl,
               button_text = content.ButtonText,
               button_url = content.ButtonUrl,
               sender_name = config.SendGridFromName
           };
           msg.SetTemplateData(templateData);
           // Send the message
           var response = await client.SendEmailAsync(msg);
           return response.IsSuccessStatusCode;
       }
   }
}

ce code permet de renseigner les espaces réservés aux contenus dynamiques que vous avez définis précédemment pour les messages RCS et les e-mails, en leur attribuant les valeurs correspondantes directement depuis votre application. Si vous avez correctement suivi toutes les étapes de configuration, vous pouvez maintenant exécuter votre application.

dotnet run

Celle-ci procédera à l’envoi d’un e-mail et d’un message RCS. L’e-mail reprendra la présentation du modèle dynamique que vous avez configuré précédemment, tandis que le message RCS contiendra les mêmes informations et le même visuel. Vous obtiendrez ainsi deux communications cohérentes, adaptées à leurs canaux de diffusion respectifs.

Dépannage et résolution des problèmes

Si vous rencontrez des problèmes lors de l’exécution de votre application, plusieurs éléments doivent être pris en compte afin d’en identifier l’origine.

En premier lieu, vérifiez que votre compte utilisateur dispose des autorisations nécessaires pour envoyer des messages RCS et que l’appareil destinataire prend bien en charge cette technologie. Assurez-vous également d’avoir préalablement enregistré cet appareil en tant que testeur RCS (RCS Tester). Par ailleurs, selon les exigences réglementaires ou les procédures applicables dans votre pays, l’envoi de messages RCS en grand nombre peut être soumis à des étapes supplémentaires de vérification ou de certification.

Enfin, si vos messages RCS ne s’affichent pas correctement ou si certains éléments visuels ne correspondent pas au résultat attendu, pensez à vérifier l’adresse des images utilisées. Celles-ci doivent être accessibles au moyen d’une URL publique pour pouvoir s’afficher correctement dans les messages. Vous pouvez également vous reporter à la documentation relative au modèle de contenu TwilioCard afin de consulter les fonctionnalités prises en charge par ce type de carte.

Si l’envoi des e-mails via SendGrid échoue, consultez votre tableau de bord SendGrid afin d’identifier l’origine du problème. Une vérification de votre identité d’expéditeur ou de la configuration DNS de votre domaine d’envoi peut notamment être nécessaire. Examinez les journaux d’envoi (Email Logs) pour contrôler le statut des e-mails transmis et identifier les éventuels codes d’erreur associés.

Si le contenu ou la présentation de vos e-mails ne correspond pas au résultat souhaité, quelques retouches apportées directement au modèle peuvent suffire. Pour vous aider, n’hésitez pas à consulter nos conseils sur l’utilisation de l’éditeur visuel Design Editor de SendGrid.

Pour aller plus loin

Dans ce tutoriel, vous avez découvert comment créer un message RCS et un e-mail avec SendGrid, puis les associer au sein d’une même campagne afin de proposer des communications cohérentes sur ces deux canaux. Parmi les évolutions envisageables pour cette application figure notamment l’intégration d’images supplémentaires dans les modèles, afin d’introduire certaines différences visuelles entre les communications par e-mail et les messages RCS. Vous pourriez également faire évoluer votre campagne vers une communication plus progressive et mieux adaptée aux réactions de vos clients. Au lieu de déclencher simultanément l’envoi des messages RCS et des e-mails, l’application pourrait être configurée pour n’envoyer un e-mail qu’en l’absence d’interaction du destinataire avec le message RCS préalablement transmis. Cette approche permettrait non seulement d’éviter de multiplier inutilement les communications, mais aussi de mieux comprendre les préférences de votre audience. Grâce à des tests A/B, vous pouvez déterminer quels types de communications promotionnelles suscitent le plus d’intérêt auprès des différents profils de clients.

Pour découvrir d’autres possibilités de développement avec la messagerie RCS, nous vous invitons à consulter les articles Twilio suivants :

Nous avons hâte de découvrir les prochains projets que vous réaliserez !

Amanda Lange est ingénieure .NET spécialisée dans la conception et la rédaction de contenus techniques. Elle accompagne les développeurs dans leur apprentissage des technologies C# et .NET afin de les aider à concevoir et à créer des applications performantes. Elle est joignable à l’adresse amlange [ at] twilio.com.

Articles associés

Ressources connexes

Twilio Docs

Des API aux SDK en passant par les exemples d'applications

Documentation de référence sur l'API, SDK, bibliothèques d'assistance, démarrages rapides et didacticiels pour votre langage et votre plateforme.

Centre de ressources

Les derniers ebooks, rapports de l'industrie et webinaires

Apprenez des experts en engagement client pour améliorer votre propre communication.

Ahoy

Le hub de la communauté des développeurs de Twilio

Meilleures pratiques, exemples de code et inspiration pour créer des expériences de communication et d'engagement numérique.