Cómo crear una campaña promocional con RCS y SendGrid en C#

Time to read:

March 31, 2026

Redactado por

Amanda Lange

Twilion

Revisado por

Dylan Frankcom

Twilion

Resumen generado por IA

Combina RCS y SendGrid para una campaña de marketing coherente.
Configura RCS para mensajes interactivos y SendGrid para correos electrónicos automatizados.
Integra ambos en una aplicación .NET para ofrecer una difusión unificada.

Este resumen fue generado por IA.

Cómo crear una campaña promocional con RCS y SendGrid en C#

En 2026, es más difícil que nunca captar y mantener la atención de tus clientes. Una campaña promocional no es solo un mensaje de texto o un correo electrónico. Es una danza coordinada entre distintos canales. Los SMS son un enfoque para enviar mensajes push de marketing y el correo electrónico es otro. Para lograr un mayor impacto, puedes combinar plantillas de correo electrónico y recursos de RCS para lograr una apariencia y sensación más unificadas en tu marketing.

En este breve tutorial, aprenderás a utilizar Twilio Sendgrid y RCS junto con .NET 10 para crear una campaña de marketing coherente. Aprenderás a comunicarte con tus clientes mediante correos electrónicos de contacto que coincidan con tus mensajes RCS de contacto con el mismo estilo de plantilla. Empecemos.

¿Qué es RCS?

Las tarjetas RCS son mensajes multimedia enriquecidos e interactivos. Los servicios de comunicación enriquecida mejoran los SMS tradicionales gracias a que admiten funciones como ID de remitente verificados y de marca, títulos, imágenes y contenido interactivo, lo que proporciona una experiencia de mensajería más atractiva e interactiva para los consumidores.

Si nunca has utilizado RCS, consulta nuestro artículo de RCS frente a SMS para comprender las diferencias entre estos canales de mensajería.

La mensajería RCS solo está disponible en dispositivos y operadores móviles compatibles. Si tu destinatario no tiene compatibilidad con RCS, Twilio enviará automáticamente el mensaje de texto alternativo definido en la sección de texto/twilio de tu plantilla.

¿Qué es SendGrid?

SendGrid es la plataforma de envío de correo electrónico de Twilio. SendGrid te permite diseñar, automatizar y entregar fácilmente campañas de marketing impactantes por correo electrónico. Puedes utilizar SendGrid para automatizar tus campañas con activadores simples y configurar plantillas de arrastrar y soltar para facilitar la creación de correos electrónicos de marketing.

Estos dos servicios pueden funcionar bien en conjunto para tus campañas de marketing multicanal:

RCA (Servicios de comunicación enriquecida): son SMS, pero mejores. RCS permite carruseles de alta resolución, botones de "respuesta sugerida" e identificación verificada de la marca del remitente. Son excelentes para hacer clics instantáneos por impulso.
SendGrid: el correo electrónico es mejor para la narración de historias de formato largo. Si a tus clientes les gustó la foto de RCS, el correo electrónico les proporciona el catálogo completo y la historia "Acerca de nuestra marca".

Creación de nuestra campaña de RCS/SendGrid

Para comenzar, necesitarás lo siguiente:

Una cuenta de Twilio (regístrate aquí).
Una cuenta de SendGrid (puedes utilizar la misma cuenta de Twilio).
Un número de teléfono de Twilio para enviar SMS, como alternativa a tu servicio de RCS.
Un dispositivo capaz de recibir mensajes de RCS.
.NET Framework instalado en la máquina en la que desarrollas.

Configuración de tu remitente de RCS

Este tutorial se basa en el tutorial Cómo enviar un mensaje de RCS con C# .NET y Twilio. Ese tutorial explica una demostración detallada de cómo configurar un remitente de RCS con capturas de pantalla. Para comenzar con este tutorial, configura tu remitente de RCS en el panel de control de RCS de Twilio como se muestra. Necesitarás un logotipo gráfico para tu remitente de RCS, así como un dispositivo para realizar pruebas. Configura tu dispositivo como probador de RCS para que puedas seguir probando el resto del tutorial.

Configuración de una plantilla dinámica de SendGrid

Deberás crear una plantilla dinámica en SendGrid para que coincida con tu RCS. Inicia sesión en el panel de control de SendGrid y ve a la API de Email > Plantillas dinámicas. Ingresa un nombre para tu plantilla que puedan leer los humanos y haz clic en Crear. Vas a crear una plantilla dinámica, para que puedas utilizar programáticamente la misma estructura de plantilla tanto para tu mensaje de RCS como para tu correo electrónico de SendGrid correspondiente. Haz clic en el botón que dice Crear una plantilla dinámica. Elige un nombre para tu plantilla que sea fácil de recordar y luego continúa.

Ahora que se creó la plantilla, haz clic en la flecha junto al nombre de la nueva plantilla para abrir el panel de edición. Aquí verás una ID de plantilla. Guarda ese número de ID para más adelante, ya que lo necesitarás para tu aplicación de envío de correo electrónico.

Ahora, para crear el resto de tu plantilla, selecciona Agregar versión. A continuación, selecciona Plantilla en blanco. Esto te da la opción de crear tu plantilla con código o con arrastrar y soltar. Para este tutorial, puedes utilizar la función de arrastrar y soltar, junto con las plantillas de Handlebars para crear una plantilla verdaderamente dinámica.

Elige Diseño y SendGrid abrirá una plantilla de correo electrónico. Para el Asunto de tu correo electrónico, teclea {{subject}} para reemplazar el marcador de posición con el valor dinámico que crearás de forma programática. Del mismo modo, para el Encabezado previo, elige {{preheader}}.

Crea tu plantilla con marcadores de posición y cualquier texto personalizado que desees agregar. Para agregar una imagen, utiliza el módulo Imagen y elige editar el HTML de esa imagen. Reemplaza la URL de la imagen con la variable {{image_url}} como se muestra aquí.

Este tutorial también tiene una opción para un botón que puedes agregar. Arrastra el elemento Botón a tu plantilla de correo electrónico e ingresa {{button_text}} para el Texto del botón y {{button_url}} para la URL del botón.

Cuando termines, tu plantilla de SendGrid se verá así:

the sendgrid template with all placeholders

Guarda tu plantilla.

Es posible guardar varias versiones de una plantilla dinámica con la misma ID. Para que tu solución de código funcione, asegúrate de que la plantilla de código que acabas de crear sea la que está configurada como Activa.

Tu aplicación .NET para RCS y SendGrid

Tu aplicación .NET unirá ambas piezas, enviando un correo electrónico y RCS a la vez.

Abre tu IDE y comienza por crear una nueva aplicación WebAPI de .NET.

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

Tu proyecto requerirá los siguientes paquetes NuGet:

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

Para este proyecto, utilizarás varias variables de entorno. En este tutorial, esas variables se agregarán al archivo appsettings.json. Crea este archivo en la carpeta de tu proyecto. Agrega las siguientes líneas, reemplazando los marcadores de posición con los valores necesarios para tu aplicación.

{
 "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"
   }
 }
}

El SID de la cuenta de Twilio y el token de autenticación se encuentran en tu panel de control de Twilio. Tu número de remitente (FromNumber) es tu número de envío para RCS. Para SendGrid, deberás crear una clave de API de SendGrid que te permita enviar correo. Si estás creando una clave personalizada, asegúrate de que tenga permisos de envío por correo. Para obtener tu ID de plantilla dinámica, ve al panel de control de SendGrid y obtén la ID de la plantilla que creaste. El FromEmail será tu correo electrónico de remitente verificado, y el FromName puede ser cualquier valor legible para humanos. Para los destinatarios (Recipients), agrega el número de teléfono y la dirección de correo electrónico que utilizarás para las pruebas.

Hay varias formas de proteger las variables de entorno en un proyecto .NET. Esta demostración utiliza un enfoque simplificado. Asegúrate de no verificar ningún código en Github ni en ningún otro control de origen que contenga las variables de tu entorno. Consulta esta explicación para saber cómo establecer variables de entorno a fin de obtener más información sobre las prácticas recomendadas para almacenar variables de entorno de manera segura.

Ahora estás listo para agregar código a tu proyecto.

El primer paso es crear los modelos que el RCS y el correo electrónico van a utilizar.

En una aplicación completamente estructurada, esto se incluiría en una carpeta. Sin embargo, para esta demostración, solo crearás un archivo de modelos rápido para almacenar los modelos que necesitas.

Crea un archivo, Models.cs, y agrega este código:

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;
   }
}

Guarda el archivo de los modelos.

Ahora, centrarás tu atención en la lógica del programa del proyecto. En tu archivo Program.cs, reemplaza el código existente por lo siguiente:

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
           };

Esto comienza con la obtención de tus claves de API y otra información de seguridad del archivo appsettings.json que creaste. Una línea de código opcional, comentada, permitiría que esta aplicación utilice variables de entorno en su lugar, si prefieres esa opción. Una vez que se recopilan todos estos valores, la aplicación crea un MessageService basado en ese modelo.

Ahora agrega el siguiente bloque de código:

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"
           };

Este bloque crea el mensaje de RCS. Reemplaza la URL de prueba con la URL de la imagen que deseas enviar o déjala como está por ahora para enviar un logotipo de Twilio.

Ahora continúa tu Program.cs con este bloque de código:

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}");
           }
       }

Aquí estás enviando tu mensaje de RCS y correo electrónico. Esto toma el contenido de ambos y los distribuye a la plantilla dinámica de correo electrónico y al RCS.

Termina tu Program.cs agregando los siguientes bloques:

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;
       }
   }
}

Este código toma los marcadores de posición de plantilla dinámica que configuraste antes para RCS y para correo electrónico, y les asigna valores con base en tu código. Si todo se ha configurado correctamente, ahora puedes ejecutar tu aplicación.

dotnet run

La aplicación enviará un correo electrónico y un mensaje de RCS. El formato del correo electrónico coincidirá con la plantilla dinámica que configuraste anteriormente, y el mensaje de RCS incluirá la misma información y el mismo gráfico.

Solución de problemas

Si tienes problemas con tu aplicación, hay algunas cosas que debes tener en cuenta.

En primer lugar, asegúrate de que tu cuenta de usuario permita enviar RCS y que tu dispositivo sea capaz de recibir RCS. Recuerda configurar tu dispositivo receptor como probador de RCS. El envío de RCS en grandes cantidades puede requerir verificación o certificación adicional, dependiendo de tu país.

Si tu RCS no se está viendo como se esperaba, es posible que hayas olvidado utilizar una imagen con una URL pública. También puedes revisar la documentación de la plantilla de contenido de TwilioCard para conocer las funciones de tarjeta compatibles.

Si el correo electrónico de SendGrid no se envía, revisa tu panel de control de SendGrid. Es posible que necesites verificar tu remitente o DNS del remitente. Revisa los registros de correo electrónico para confirmar el estado de tu correo enviado y busca cualquier posible código de error.

Si tu correo electrónico no se está visualizando como se esperaba, es posible que debas realizar algunos ajustes en la plantilla en sí. Consulta algunos consejos para usar el Editor de diseño en SendGrid.

¿Qué sigue?

En este tutorial, aprendiste a crear un mensaje de RCS y un correo electrónico de SendGrid que funcionan juntos como parte de una campaña unificada. Las actualizaciones futuras a esta aplicación podrían incluir imágenes de plantilla adicionales para hacer que el correo electrónico y el RCS se vean ligeramente diferentes entre sí. Otra posible actualización es escalonar la campaña para que, en lugar de enviar correos electrónicos y RCS simultáneamente, el correo electrónico solo se envíe si el usuario no interactúa con el RCS. De esta manera, puedes evitar enviar correos electrónicos redundantes mientras haces pruebas A/B de qué usuarios responden más a qué estilo de difusión del producto.

Para obtener más información sobre cómo crear con RCS, consulta algunos de estos otros artículos de Twilio:

¡Nos emociona ver lo que crearás a continuación!

Amanda Lange es ingeniera de contenido técnico de .NET. Está aquí para enseñar cómo crear grandes cosas con la programación C# y .NET. Puedes comunicarte con ella en amlange [arroba] twilio.com.

Publicaciones relacionadas

Recursos relacionados

Twilio Docs

Desde API hasta SDK y aplicaciones de muestra

Documentación de referencia de API, SDK, bibliotecas auxiliares, inicios rápidos y tutoriales para su idioma y plataforma.

Centro de Recursos

Los últimos libros electrónicos, informes de la industria y seminarios web

Aprenda de los expertos en participación del cliente para mejorar su propia comunicación.

Ahoy

Centro de la comunidad de desarrolladores de Twilio

Mejores prácticas, ejemplos de códigos e inspiración para crear comunicaciones y experiencias de participación digital.