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

1. Acesse o Zapier.
2. Acesse a seção Zaps .
3. 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.