Como automatizar alertas de e-mail no WhatsApp com Gmail, Gemini e Whaticket

🔷 Este artigo explica como criar uma automação que permite receber notificações de novos e-mails diretamente no WhatsApp. Usando o Gmail, Gemini AI, Zapier e a API do Whaticket, você pode gerar um resumo automático do e-mail recebido e enviá-lo como um alerta para sua conta do WhatsApp configurada.

Esse fluxo de trabalho é especialmente útil para monitorar e-mails importantes, detectar oportunidades de negócios ou receber alertas sem precisar ficar checando a caixa de entrada o tempo todo.

🟢 O que essa automação permite?

Essa integração conecta diferentes ferramentas para transformar um e-mail em uma notificação automática do WhatsApp.

Sempre que um novo e-mail chegar no Gmail, o Zapier ativará o fluxo, o Gemini analisará o conteúdo do e-mail usando inteligência artificial e o Whaticket enviará o resumo diretamente para o WhatsApp configurado.

▪️ Receba alertas de e-mails importantes no WhatsApp.
▪️ Gere resumos automáticos usando inteligência artificial.
▪️ Identificar se um e-mail requer alguma ação.
▪️ Automatize o monitoramento de e-mails importantes.

🟢 Ferramentas utilizadas na automação

⚙️ Gmail

O Gmail é um serviço de e-mail baseado na nuvem, desenvolvido pelo Google. Ele oferece uma versão gratuita com recursos básicos e planos empresariais dentro do Google Workspace, com armazenamento expandido, domínios personalizados e ferramentas administrativas.

⚙️ Gêmeos IA

Gemini é um modelo de inteligência artificial desenvolvido pelo Google. Ele permite analisar textos, gerar resumos, classificar conteúdo e extrair informações relevantes. Pode ser integrado ao Zapier via API.

⚙️ Zapier

O Zapier é uma plataforma de automação sem código que conecta diferentes aplicativos. Ele permite criar fluxos de trabalho automatizados, chamados Zaps, que executam ações quando um evento específico ocorre.

⚙️ API de envio do Whaticket

A API Send permite enviar mensagens do WhatsApp a partir de integrações externas.

▪️ Cada mensagem enviada consome créditos.
▪️ Os créditos são adquiridos dentro dos planos disponíveis.
▪️ Os empréstimos não têm data de vencimento.

🟢 Requisitos antes de começar

Antes de começar a automação, você precisa ter:

▪️ Uma conta do Zapier .
▪️ Uma conta do Gmail conectada ao Zapier.
▪️ Acesso ao Whaticket com o envio de API ativado.
▪️ Token da API gerado no Whaticket.
▪️ ID de conexão do WhatsApp disponível em
Whaticket → Conexões → Editar → ícone de pasta.

🟢 Automação passo a passo

🔵 Integre o Gmail ao Zapier

Acesse o Zapier.
Acesse a seção Zaps .
Clique em Criar para criar uma nova automação.

Configure o evento de gatilho

Selecione o aplicativo Gmail .

Evento de disparo → Novo e-mail

Conecte a conta do Gmail com as credenciais correspondentes.

Clique em Continuar .

Selecione a bandeja ou a etiqueta

Escolha o critério que irá acionar a automação.

Por exemplo:

▪️ Caixa de entrada.
▪️ Um rótulo específico.
▪️ Uma busca personalizada.

Isso permitirá que a automação seja ativada quando um e-mail que atenda a esse critério chegar.

Teste o gatilho

O Zapier mostrará exemplos de e-mails recentes.

Verifique se os seguintes campos aparecem:

▪️ Por e-mail
▪️ Assunto
▪️ Corpo liso

🟢 Analise e-mails com inteligência artificial

🔵 Configure o Gemini no Zapier

Adicione uma nova etapa ao fluxo usando o Gemini.

Evento de ação → Enviar mensagem

Conecte a conta usando a chave da API de IA do Google.

Configuração do Gemini Step no Zapier.

Crie a chave da API

Acesse o site do Google AI Studio.

Criar uma nova chave de API.

Copie a chave e cole-a no Zapier.

Configure o modelo

Modelo → gemini-1.5-flash

Versão da API → mantenha o valor padrão.

Instruções para configurar o sistema

O objetivo da inteligência artificial é:

▪️ Analise o e-mail recebido.
▪️ Classifique o conteúdo.
▪️ Gere um resumo.
▪️ Extrair dados importantes.

Exemplo de instruções para Gemini:

Eres un asistente que procesa correos de Gmail.

Tu tarea:

Lee el correo recibido.
Clasifícalo en una de estas categorías:

SPAM
PROMOCIÓN
IMPORTANTE

Si el correo es IMPORTANTE, genera un resumen breve (máximo 280 caracteres) y una respuesta sugerida profesional.

Extrae además:

remitente_nombre
remitente_email
links
telefonos
idioma_detectado
prioridad
requiere_accion

Teste a etapa de IA

Execute o teste.

Verifique se o Gemini gera uma resposta em formato JSON.

🟢 Separe os campos gerados por IA

🔵 Adicione uma etapa de código no Zapier

Adicione uma nova etapa usando:

Aplicativo → Código

Evento de ação → Executar JavaScript

Esta etapa permite processar o JSON gerado pelo Gemini e separar os campos para uso posterior.

Configuração de etapas de código via Zapier.

Configure os dados de entrada.

Em Dados de Entrada

Adicione um campo chamado:

texto

Atribua o campo de saída gerado pelo Gemini.

Adicione o código JavaScript

Este código é usado para:

▪️ Limpar o JSON gerado pela IA
▪️ separar os campos
▪️ Extrair números de telefone e links
▪️ Prepare os dados para envio ao WhatsApp

 'use strict';



 /**

 * Extrae el bloque JSON desde un texto del modelo (Gemini),

 * eliminando cercas de código tipo ```json ... ``` o ``` ... ```.

 */

 function extractJsonBlock(raw = '') {

  let candidate = raw;

  const fenceJson = raw.match(/```json\s*([\s\S]*?)```/i);

  const fenceAny  = raw.match(/```([\s\S]*?)```/);

  if (fenceJson) candidate = fenceJson[1].trim();

  else if (fenceAny) candidate = fenceAny[1].trim();

  return candidate;

 }



 /** Quita comas finales antes de } o ] para evitar errores de parseo */

 function fixTrailingCommas(s = '') {

  return s.replace(/,\s*([}\]])/g, '$1');

 }



 /** Normaliza comillas “tipográficas” a comillas estándar */

 function normalizeQuotes(s = '') {

  return s.replace(/[“”]/g, '"').replace(/[‘’]/g, "'");

 }



 /** Deja solo dígitos (útil para teléfonos) */

 const onlyDigits = (s) => (s || '').replace(/\D+/g, '');



 /** Asegura un array */

 const arr = (v) => Array.isArray(v) ? v : (v == null ? [] : [v]);



 // ----- Entrada del paso anterior -----

 const raw = inputData.text || '';

 let candidate = extractJsonBlock(raw);

 if (!candidate.trim()) candidate = raw.trim();



 // Intentos de parseo (sin romper el contenido)

 let data = null;

 const attempts = [

  (s) => JSON.parse(s),

  (s) => JSON.parse(normalizeQuotes(s)),

  (s) => JSON.parse(fixTrailingCommas(normalizeQuotes(s))),

 ];



 for (const tryParse of attempts) {

  try {

    data = tryParse(candidate);

    break;

  } catch (e) { /* sigue probando */ }

 }



 // Si no se pudo parsear, devolvemos estructura vacía + crudo para depurar

 if (!data || typeof data !== 'object') {

  return {

    parse_ok: false,

    json_pretty: '',

    json_raw: candidate,

    classification: '',

    resumen: '',

    respuesta_sugerida: '',

    remitente_nombre: '',

    remitente_email: '',

    asunto_original: '',

    idioma_detectado: '',

    prioridad: '',

    requiere_accion: '',

    links: '',

    links_json: '[]',

    phones_all: '',

    phones_json: '[]',

    phone_primary_digits: '',

    phone_primary_plus: ''

  };

 }



 // ----- Normalización de claves -----

 const pick = (...keys) => {

  for (const k of keys) {

    if (data[k] != null && data[k] !== '') return data[k];

  }

  return '';

 };



 const classification   = pick('clasificacion', 'clasificación') || '';

 const resumen          = pick('resumen', 'summary', 'resumo', 'texto');

 const respuesta        = pick('respuesta_sugerida', 'respuesta', 'reply_sugerida');

 const remitenteNombre  = pick('remitente_nombre', 'from_name', 'remitente');

 const remitenteEmail   = pick('remitente_email', 'from_email', 'email');

 const asunto           = pick('asunto_original', 'subject', 'asunto');

 const idioma           = pick('idioma_detectado', 'idioma', 'language');

 const prioridad        = pick('prioridad', 'priority');

 let requiereAccion     = pick('requiere_accion', 'requiere_acción', 'requires_action');



 // Normaliza booleanos escritos como texto

 if (typeof requiereAccion === 'string') {

  requiereAccion = /true|sí|si|yes/iu.test(requiereAccion);

 } else {

  requiereAccion = !!requiereAccion;

 }



 // Links (CSV y JSON)

 const linksArr = arr(data.links).filter(Boolean).map(String);

 const linksCsv = linksArr.join(', ');



 // Teléfonos: solo dígitos, longitud 10–15, sin "+"

 let phonesArr = arr(data.telefonos).map(v => onlyDigits(String(v)));

 phonesArr = phonesArr.filter(p => p.length >= 10 && p.length <= 15);



 // Principal y variante con "+"

 const phonePrimary = phonesArr[0] || '';

 const phonePlus    = phonePrimary ? `+${phonePrimary}` : '';



 // ----- Salida lista para mapear en el siguiente paso -----

 return {

  parse_ok: true,

  json_pretty: JSON.stringify(data, null, 2),

  json_raw: candidate,



  classification: String(classification || ''),

  resumen: String(resumen || ''),

  respuesta_sugerida: String(respuesta || ''),



  remitente_nombre: String(remitenteNombre || ''),

  remitente_email: String(remitenteEmail || ''),

  asunto_original: String(asunto || ''),

  idioma_detectado: String(idioma || ''),

  prioridad: String(prioridad || ''),

  requiere_accion: requiereAccion,



  links: linksCsv,

  links_json: JSON.stringify(linksArr),



  phones_all: phonesArr.join(','),

  phones_json: JSON.stringify(phonesArr),

  phone_primary_digits: phonePrimary,

  phone_primary_plus: phonePlus

 };

Teste a etapa de JavaScript

Execute o teste.

Verifique se os campos aparecem corretamente separados na saída de dados .

🟢 Implementação do Whaticket

🔵 Adicionar ação Webhooks

Adicione uma nova etapa usando:

Aplicativo → Webhooks do Zapier

Evento → Solicitação personalizada

Configurando Webhooks no Zapier.

Configurações principais

Method
POST

URL
https://api.whaticket.com/api/v1/messages

Data Pass-Through
false

Corpo do pedido

Insira o seguinte JSON no corpo da requisição.

Os campos podem ser mapeados utilizando os dados obtidos nas etapas anteriores.

 {
  "whatsappId": "AQUI_VA_EL_ID_DE_TU_WHATSAPP",
  "messages": [
    {
      "number": "telefono_limpio",
      "body": "Mensaje de prueba a enviar por contacto"
    }
  ]
 }

🟢 Configurações adicionais

Dentro da ação de configuração:

Unflatten → Yes

Headers

Content-Type: application/json

Authorization:

Bearer TU_TOKEN_DE_API_DE_WHATICKET

🟢 Automação de testes

Clique em Testar .

Se a integração funcionar corretamente, uma resposta semelhante à seguinte será exibida:

Mensagens agendadas.

Se ocorrer um erro, o Zapier mostrará o motivo para que você possa corrigi-lo.

🟢 Automação de publicação

Se o teste funcionar corretamente:

Ative o Zap clicando em Ligar .

A partir desse momento:

Sempre que um e-mail que atenda às condições configuradas for recebido, uma notificação será enviada automaticamente para o WhatsApp.

🟢 Onde a mensagem aparece no Whaticket?

A mensagem enviada via API aparecerá no Whaticket como um ticket.

Caso nenhuma atribuição específica seja definida, o ticket aparecerá inicialmente na seção de resolvidos.

🟢 Recomendações importantes

▪️ Verifique se há créditos disponíveis na API de Envio.
▪️ Confirme se o JSON está estruturado corretamente.
▪️ Verifique se o número de telefone está formatado corretamente.
▪️ Teste todo o fluxo antes de ativá-lo em produção.

💡 Recomendação

Se possível, recomenda-se contar com o apoio de um desenvolvedor para validar o mapeamento de campos e a estrutura JSON durante a integração.

🟢 Resumo

▪️ Objetivo: receber um alerta no WhatsApp quando um e-mail importante chegar.

▪️ Ferramentas utilizadas:
Gmail → Gemini AI → JavaScript → API Whaticket Enviar.

▪️ Resultado:
Um resumo automático do e-mail será enviado para o WhatsApp como notificação.

Importante: A Whaticket não se responsabiliza por erros de configuração, falta de créditos ou custos associados a plataformas externas utilizadas na integração.

Tem mais alguma dúvida? Não se preocupe, estamos aqui para ajudar. Entre em contato com nossa equipe clicando no botão "Suporte" localizado no menu à esquerda da nossa plataforma.