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

Com esta automação, cada e-mail novo no Gmail é analisado pelo Gemini (a IA do Google) e um resumo é enviado para o WhatsApp pela API do Whaticket. O Zapier conecta as etapas.

Use para acompanhar e-mails importantes, identificar oportunidades de negócio ou receber alertas sem abrir a caixa de entrada o tempo todo.

O que muda para sua operação

Você recebe no WhatsApp um alerta dos e-mails importantes.
A IA gera um resumo e uma sugestão de resposta para cada e-mail.
Você sabe na hora se o e-mail exige alguma ação.
O monitoramento da caixa de entrada fica automático.

Antes de começar

Tenha uma conta no Zapier com a conta do Gmail conectada.
Tenha uma chave de API do Google AI Studio para usar o Gemini.
Gere um token de API na Whaticket: no menu à esquerda, clique em Integrações > aba Tokens > Novo token. Escolha um Perfil que tenha as permissões Criar e Iniciar do grupo Campanhas e copie a Chave. Ela só aparece uma vez.
Para criar o token, seu perfil precisa da permissão Criar do grupo Tokens de API.
Copie o ID da conexão de WhatsApp que vai enviar os alertas: em Conexões, abra a conexão em Editar e clique no ícone de copiar ao lado do título Editar Conexão.
A conexão precisa estar conectada no momento do envio.

Passo a passo:

Crie o Zap e configure o gatilho do Gmail

Acesse o Zapier e abra a seção Zaps.
Clique em Create para criar uma nova automação.
Selecione o app Gmail e o evento New Email.
Conecte sua conta do Gmail e clique em Continue.

Escolha o critério que vai disparar a automação: a caixa de entrada, um marcador específico ou uma busca personalizada.

Teste o gatilho

Clique em testar. O Zapier mostra exemplos de e-mails recentes.
Confira se aparecem os campos From Email, Subject e Body Plain.

Configure o Gemini no Zapier

Adicione uma nova etapa com o app Gemini e o evento Send Prompt.
No Google AI Studio, crie uma nova chave de API e copie.
No Zapier, conecte a conta colando essa chave.

Em Model, escolha o modelo do Gemini. O exemplo usa gemini-1.5-flash.
Em API Version, mantenha o valor padrão.

Escreva as instruções para a IA

A IA precisa analisar o e-mail, classificar o conteúdo, gerar um resumo e extrair os dados importantes. Use este exemplo de instrução. Mantenha os nomes dos campos como estão, porque o código da próxima etapa procura exatamente esses nomes:

Você é um assistente que processa e-mails do Gmail.
Sua tarefa:
Leia o e-mail recebido.
Classifique-o em uma destas categorias: SPAM, PROMOÇÃO, IMPORTANTE.
Se o e-mail for IMPORTANTE, gere um resumo breve (máximo 280 caracteres) e uma resposta sugerida profissional.
Extraia também:
remitente_nombre
remitente_email
links
telefonos
idioma_detectado
prioridad
requiere_accion
Responda somente em formato JSON, usando exatamente esses nomes de campo e também clasificacion, resumen e respuesta_sugerida.

Teste a etapa e confira se o Gemini devolve a resposta em formato JSON.

Separe os campos com uma etapa de código

Adicione uma nova etapa com o app Code e o evento Run Javascript.
Em Input Data, crie um campo chamado text e associe a ele a resposta gerada pelo Gemini.

Cole o código abaixo. Ele limpa o JSON gerado pela IA, separa os campos, extrai telefones e links e prepara os dados para o 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 e confira se os campos aparecem separados em Data Out.

Envie o alerta pela API da Whaticket

Adicione uma nova etapa com o app Webhooks by Zapier e o evento Custom Request.
Em Method, escolha POST.
Em URL, use https://api.whaticket.com/api/v1/messages.
Em Data Pass-Through, deixe false.

Em Data, cole o JSON abaixo. Troque o ID pelo ID da sua conexão e associe number e body aos campos das etapas anteriores (por exemplo, o número que vai receber o alerta e o resumo gerado pela IA).

{
 "connectionId": "ID_DA_SUA_CONEXAO",
 "messages": [
  {
   "number": "telefone_do_destinatario",
   "body": "Texto da mensagem"
  }
 ]
}

Em Unflatten, escolha Yes.
Em Headers, adicione Content-Type com o valor application/json.
Adicione também Authorization com o valor Bearer, um espaço e a chave do seu token da Whaticket.

Teste e ative o Zap

Clique em Test. Se tudo estiver certo, a resposta mostra messages scheduled.
Se aparecer um erro, o Zapier mostra o motivo para você corrigir.
Com o teste funcionando, clique em Turn on para ativar o Zap.

A partir daí, cada e-mail que atender ao critério configurado gera automaticamente um alerta no WhatsApp.

Perguntas frequentes

Onde a mensagem aparece na Whaticket?
A mensagem enviada pela API aparece como um chat na Whaticket. Se nenhuma atribuição for definida, o chat aparece inicialmente em Resolvidos.

O envio pela API consome créditos?
Só em conexões via QR Code. Conexões WABA ou Coexistência não consomem créditos. Se faltarem créditos, a resposta da API avisa quantos você tem e os envios param quando eles acabam. Para comprar mais, use Adicionar créditos de campanha. Os créditos não têm data de vencimento.

Meu JSON usa o campo whatsappId. Preciso mudar?
Não é obrigatório. A API continua aceitando whatsappId, mas o nome atual do campo é connectionId.

O que conferir se a automação não funcionar?
Confira se o JSON está bem estruturado, se o número está no formato certo (só dígitos, com código do país), se o token tem as permissões de Campanhas, se a conexão está conectada e se há créditos disponíveis quando a conexão é via QR Code. Se possível, conte com um desenvolvedor para validar o mapeamento dos campos.

A Whaticket se responsabiliza pelas plataformas externas?
Não. A Whaticket não se responsabiliza por erros de configuração, falta de créditos ou custos das plataformas externas usadas na integração (Zapier, Google).