Como criar uma campanha promocional com RCS e SendGrid em C#

Time to read:

March 31, 2026

Escrito por

Amanda Lange

Twilion

Revisado por

Dylan Frankcom

Twilion

Resumo gerado por IA

Combine o RCS e o SendGrid para criar uma campanha de marketing coesa.
Configure o RCS para mensagens interativas e o SendGrid para e-mails automatizados.
Integre ambos em um aplicativo .NET para oferecer alcance unificado.

Este resumo foi gerado por IA.

Como criar uma campanha promocional com RCS e SendGrid em C#

Em 2026, ficou mais difícil do que nunca capturar e prender a atenção de seus clientes. Uma campanha promocional não é apenas uma mensagem de texto ou um e-mail. É uma dança coordenada entre diferentes canais. O SMS é uma forma de enviar campanhas de marketing, e o e-mail é outra. Para causar um impacto maior, você pode combinar modelos de e-mail e recursos RCS para uma aparência mais unificada do seu marketing.

Neste breve tutorial, você aprenderá a usar o Twilio SendGrid e o RCS juntamente com o .NET 10 para criar uma campanha de marketing coesa. Você aprenderá a enviar e-mails aos seus clientes com o mesmo estilo e formato dos modelos utilizados nas mensagens RCS. Vamos começar.

O que é RCS?

Os cartões RCS são mensagens interativas e de rich media. O RCS aprimora o SMS tradicional ao oferecer suporte a recursos como IDs de remetente verificados e com identificação de marca, títulos, imagens e conteúdo interativo, oferecendo aos clientes uma experiência de envio de mensagens mais personalizada e envolvente.

Se você nunca usou RCS, confira nosso artigo RCS versus SMS para entender as diferenças entre esses canais de mensagens.

As mensagens RCS só estão disponíveis em dispositivos e operadoras compatíveis. Se seu destinatário não tiver suporte para RCS, a Twilio enviará automaticamente a mensagem de texto alternativa definida na seção twilio/text do seu modelo.

O que é SendGrid?

SendGrid é a plataforma de envio de e-mail da Twilio. O SendGrid permite elaborar, automatizar e entregar campanhas de marketing por e-mail impactantes. Você pode usar o SendGrid para automatizar suas campanhas com acionadores simples e configurar modelos de arrastar e soltar para facilitar a criação de e-mails de marketing.

Esses dois serviços podem funcionar muito bem em conjunto nas suas campanhas de marketing multicanal:

RCS (Rich Communication Services): é como o SMS, mas com mais recursos. O RCS permite carrosséis de imagens de alta resolução, botões de "Resposta sugerida" e identificação de marca verificada do remetente. É ótimo para cliques instantâneos por impulso.
SendGrid: o e-mail é mais adequado para contar histórias detalhadas. Se os seus clientes gostaram da imagem enviada por RCS, o e-mail pode apresentar o catálogo completo e a história da marca na seção "Sobre nossa marca".

Como criar nossa campanha RCS/SendGrid

Para começar, você precisará do seguinte:

Uma conta Twilio (inscreva-se aqui).
Uma conta SendGrid (você pode usar a mesma conta Twilio)
Um número de telefone Twilio para enviar SMS como alternativa ao serviço RCS.
Um dispositivo capaz de receber mensagens RCS.
A estrutura .NET instalada em sua máquina de desenvolvimento.

Como configurar seu remetente RCS

Este tutorial se baseia no tutorial Como enviar uma mensagem RCS com C# .NET e Twilio. Esse tutorial apresenta uma demonstração detalhada de como configurar um remetente RCS com capturas de tela. Para começar este tutorial, configure seu remetente RCS no Dashboard RCS da Twilio, conforme mostrado. Você precisará de um logotipo gráfico para seu remetente RCS, bem como de um dispositivo para testes. Configure seu dispositivo como um testador RCS para que você possa continuar testando o restante do tutorial.

Como configurar um modelo dinâmico do SendGrid

Você precisará criar um modelo dinâmico no SendGrid que corresponda à sua mensagem RCS. Faça login no dashboard SendGrid e acesse API de e-mail > Dynamic Templates (Modelos dinâmicos). Insira um nome legível para seu modelo e clique em Create (Criar). Você criará um modelo dinâmico para poder utilizar programaticamente a mesma estrutura de modelo tanto para sua mensagem RCS quanto para o e-mail correspondente enviado pelo SendGrid. Clique no botão Create a Dynamic Template (Criar um modelo dinâmico). Escolha um nome fácil de lembrar para o seu modelo e prossiga.

Agora que o modelo foi criado, clique na seta ao lado do nome do novo modelo para abrir o painel de edição. Você verá um Template ID (ID do modelo) aqui. Salve esse número de ID para mais tarde, pois você precisará dele para seu aplicativo de envio de e-mail.

Agora, para criar o restante do seu modelo, selecione Add Version (Adicionar versão). Selecione Blank Template (Modelo vazio). Isso oferece a opção de criar seu modelo com código ou com arrastar e soltar. Para este tutorial, você pode usar o recurso de arrastar e soltar, juntamente com a linguagem de templates Handlebars, para criar um modelo realmente dinâmico.

Escolha Design e o SendGrid abrirá um modelo de e-mail. Para o Subject (Assunto) do seu e-mail, digite {{subject}} para substituir o espaço reservado pelo valor dinâmico que você criará programaticamente. Da mesma forma, para o Preheader (pré-cabeçalho), escolha {{preheader}}.

Crie seu modelo usando espaços reservados e qualquer texto personalizado que você queira adicionar. Para adicionar uma imagem, use o módulo Image (Imagem) e escolha editar o HTML dessa imagem. Substitua o URL da imagem pela variável {{image_url}}, conforme mostrado aqui.

Este tutorial também tem uma opção para um botão que você pode adicionar. Arraste o elemento Botão para o seu modelo de e-mail e insira {{button_text}} no campo Button Text (Texto do botão) e {{button_url}} no campo Button URL (URL do botão).

Quando terminar, seu modelo SendGrid ficará assim:

the sendgrid template with all placeholders

Salve seu modelo.

É possível salvar várias versões de um modelo dinâmico com o mesmo ID. Para que sua solução de código funcione, certifique-se de que o modelo de código que você acabou de criar seja aquele definido como Ativo.

Seu aplicativo .NET para RCS e SendGrid

Seu aplicativo .NET unirá essas duas peças, enviando um e-mail e uma mensagem RCS de uma só vez.

Abra seu IDE e comece criando um novo aplicativo WebAPI .NET.

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

Seu projeto exigirá os seguintes pacotes 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 projeto, você usará várias variáveis de ambiente. Neste tutorial, essas variáveis serão adicionadas ao arquivo appsettings.json. Crie este arquivo na pasta do seu projeto. Adicione as seguintes linhas, substituindo os espaços reservados pelos valores necessários para seu aplicativo.

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

O SID da conta da Twilio e o token de autenticação são encontrados no dashboard da Twilio. O número no campo From é o número de envio das suas mensagens RCS. Para SendGrid, você precisará criar uma chave de API SendGrid que permita enviar e-mails. Se você estiver criando uma chave personalizada, certifique-se de que ela tenha permissões de envio de e-mail. Para obter seu ID de modelo dinâmico, vá para o dashboard do SendGrid e obtenha o ID do modelo que você criou. O campo FromEmail será o seu endereço de e-mail de remetente verificado, e o campo FromName pode conter qualquer valor legível por humanos. Para os destinatários, adicione o número de telefone e o endereço de e-mail que você usará para testes.

Há várias maneiras de proteger variáveis de ambiente em um projeto .NET. Essa demonstração está usando uma abordagem simplificada. Certifique-se de não enviar para o GitHub nem para qualquer outro sistema de controle de versão nenhum código que contenha suas variáveis de ambiente. Consulte este guia explicativo sobre como configurar variáveis de ambiente para obter mais informações sobre as práticas recomendadas para armazená-las com segurança.

Agora você está pronto para adicionar código ao seu projeto.

O primeiro passo é criar os modelos que serão utilizados pelo RCS e pelo e-mail.

Em um aplicativo totalmente estruturado, isso seria incluído em uma pasta. Para esta demonstração, no entanto, você apenas criará um arquivo de modelos rápidos para armazenar os modelos de que precisa.

Crie um arquivo, Models.cs, e adicione 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;
   }
}

Salve o arquivo de modelos.

Agora você voltará sua atenção para a lógica do programa do projeto. Em seu arquivo Program.cs, substitua o código existente pelo seguinte:

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

Isso começa obtendo as chaves de API e outras informações de segurança do arquivo appsettings.json que você criou. Uma linha de código opcional, deixada como comentário, permitiria que este aplicativo utilizasse variáveis de ambiente, caso você prefira essa abordagem. Depois que todos esses valores são coletados, o aplicativo cria um MessageService com base nesse modelo.

Agora, adicione o próximo bloco 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 bloco cria a mensagem RCS. Substitua o URL de teste pelo URL da imagem que deseja enviar ou deixe-o como está por enquanto para enviar um logotipo da Twilio.

Agora, continue seu Program.cs com este bloco 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}");
           }
       }

É aqui que você realmente envia sua mensagem RCS e seu e-mail. O conteúdo de ambos é distribuído para o modelo dinâmico de e-mail e para a mensagem RCS.

Finalize seu Program.cs adicionando os seguintes blocos:

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

Esse código utiliza os espaços reservados do modelo dinâmico que você configurou anteriormente para a mensagem RCS e para o e-mail e atribui valores a eles com base no seu código. Se tudo tiver sido configurado corretamente, agora você poderá executar seu aplicativo.

dotnet run

O aplicativo enviará um e-mail e uma mensagem RCS. O formato do e-mail corresponderá ao modelo dinâmico configurado anteriormente e a mensagem RCS incluirá as mesmas informações e gráficos.

Resolução de problemas

Se você tiver problemas com seu aplicativo, há algumas coisas a considerar.

Em primeiro lugar, certifique-se de que sua conta de usuário permita o envio de mensagens RCS e que seu dispositivo seja capaz de receber RCS. Lembre-se de configurar seu dispositivo receptor como um testador de RCS. O envio de RCS em massa pode exigir verificação ou certificação adicional, dependendo do seu país.

Se sua mensagem RCS não estiver sendo exibida como esperado, talvez você tenha se esquecido de usar uma imagem com uma URL pública. Você também pode consultar a documentação dos modelos de conteúdo TwilioCard para conhecer os recursos de cartão compatíveis.

Se o envio de e-mails pelo SendGrid não estiver funcionando, verifique o dashboard do SendGrid. Talvez seja necessário verificar seu remetente ou DNS do remetente. Verifique os logs de e-mail para confirmar o status do e-mail enviado e procure quaisquer possíveis códigos de erro.

Se o seu e-mail não estiver sendo exibido como esperado, talvez seja necessário fazer alguns ajustes no próprio modelo. Confira algumas dicas para usar o Editor de design no SendGrid.

O que vem a seguir?

Neste tutorial, você aprendeu a criar uma mensagem RCS e um e-mail SendGrid que funcionam juntos como parte de uma campanha unificada. Atualizações futuras deste aplicativo podem incluir imagens adicionais nos modelos, para que o e-mail e o RCS tenham aparências ligeiramente diferentes entre si. Outra possível atualização é escalonar a campanha, portanto, em vez de enviar e-mails e mensagens RCS simultaneamente, o e-mail só é enviado se o usuário não interagir com a mensagem RCS. Dessa forma, você pode evitar o envio de e-mails redundantes enquanto realiza testes A/B para descobrir quais estilos de abordagem de divulgação de produtos geram mais respostas dos usuários.

Para conhecer outras possibilidades do que você pode desenvolver com RCS, confira alguns destes outros artigos da Twilio:

Estamos ansiosos para ver a sua próxima criação!

Amanda Lange é engenheira .NET de conteúdo técnico. Ela se dedica a ensinar como desenvolver projetos incríveis com C# e .NET. Você pode entrar em contato com ela em amlange [arroba] twilio.com.

Publicações relacionadas

Recursos relacionados

Twilio Docs

De APIs a SDKs e aplicativos de amostra

Documentação de referência de API, SDKs, bibliotecas auxiliares, guias de início rápido e tutoriais para sua linguagem e plataforma.

Centro de Recursos

Os mais recentes e-books, relatórios do setor e webinars

Aprenda com especialistas em engajamento do cliente para melhorar sua própria comunicação.

Ahoy

Centro da comunidade de desenvolvedores da Twilio

Melhores práticas, exemplos de código e inspiração para criar comunicações e experiências de engajamento digital.