API de validação de e-mail em tempo real para formulários de cadastro

Valide os endereços no momento em que os usuários enviam o formulário: servidor de e-mail e existência da caixa em uma única chamada, com indicadores de descartável e de função para você decidir o que aceitar. Nossa API de validação de e-mail bloqueia dados ruins antes que entrem e mantém contas falsas fora do seu banco de dados.

Handler de cadastro no backendDecisão do formulário
// 1. Receive submitted form data
const { email } = req.body;

// 2. Validate via API
const { data } = await checkEmail(email);

// 3. Make real-time form decision
if (data.status === 'undeliverable') {
  return res.status(400).json({ error: 'Please enter a valid, active email address.' });
}
if (data.details.attributes.disposable) {
  return res.status(400).json({ error: 'Temporary or disposable emails are not allowed.' });
}

// 4. Proceed with account registration
await createUser({ email });

1.000 créditos grátis, sem cartão. Os créditos nunca expiram.

Por que uma regex sozinha não é validação de e-mail

Uma expressão regular confere apenas a estrutura do texto: se existe um @, se o formato do domínio parece plausível e se os caracteres estão dentro das faixas ASCII padrão. A regex responde apenas se uma entrada parece um endereço de e-mail, não se alguém consegue receber mensagens nele.

Digitar user@example.com ou asdf12345@gmail.com passa sem problema em qualquer regex compatível com o RFC. Mesmo assim, um dos domínios pode não ter servidores de e-mail ativos, e a outra caixa pode não existir.

Nossa API de validação de e-mail com resposta JSON vai muito além das expressões regulares. Em uma única requisição, ela confere os registros DNS, consulta os servidores MX, se conecta ao servidor de e-mail de destino para testar se a caixa responde e compara o domínio com listas extensas de domínios descartáveis.

Padrões de regex rígidos também causam rejeições falsas. Expressões personalizadas costumam rejeitar domínios de topo pouco comuns como .studio ou .cloud, caracteres internacionais válidos ou endereços legítimos com pontuação incomum. Nossa API trata automaticamente toda a sintaxe do RFC 5322, então você não precisa manter bibliotecas de regex frágeis no seu código.

1

Verificação de sintaxe

Encontra erros de digitação básicos, TLDs ausentes, pontuação proibida e problemas de espaço antes de qualquer consulta de rede externa.

2

Verificação de DNS e MX

Confere se o domínio está registrado e encontra os servidores de e-mail configurados que podem aceitar mensagens recebidas.

3

Verificação da caixa

Fala diretamente com o servidor de e-mail remoto para confirmar se aquela caixa existe e pode receber mensagens.

O que bloquear, marcar ou permitir no cadastro

Cada negócio tem requisitos de cadastro diferentes. Um SaaS B2B para empresas pode exigir e-mails corporativos, enquanto um app social para consumidores aceita endereços pessoais do Gmail. Esta é a tabela de decisão recomendada com base nos atributos reais da resposta da API:

Resultado da APICondição do campoO que o formulário deve fazer
Inválidostatus === "undeliverable"Bloquear na hora. Mostrar: "Digite um endereço de e-mail válido e ativo."
Descartáveldetails.attributes.disposable === trueBloquear ou pedir outro endereço. Mostrar: "Endereços de e-mail temporários não são permitidos."
Conta de funçãodetails.attributes.role_account === truePermitir; marcar em formulários B2B. Avisar os gerentes de conta ou enviar para o grupo geral de leads.
E-mail gratuitodetails.attributes.free_email === truePermitir em apps B2C; exigir e-mail corporativo em formulários de demo ou de teste B2B.
Catch-alldetails.attributes.catch_all === trueConferir catch_all_verdict: se for "valid", permitir; se for "invalid", bloquear; se for null, permitir o cadastro.
Desconhecidostatus === "unknown"Aceitar e verificar de novo mais tarde (reembolsado). Em caso de falha, deixar passar (fail-open), para nunca bloquear usuários legítimos.

Adicione validação de e-mail ao seu formulário de cadastro

Siga esta sequência de quatro passos para integrar a validação em tempo real com segurança. Como as requisições exigem sua chave de API privada, faça a verificação a partir do seu servidor backend.

Por que o padrão fail-open importa: formulários de cadastro são sensíveis a atrasos. Se uma chamada a uma API externa sofrer latência de rede, bloquear o formulário pode fazer você perder um cliente real. Com um tempo limite curto e o cadastro seguindo automaticamente, usuários legítimos não são recusados, e o seu backend coloca o endereço em uma fila para verificação em segundo plano depois.

1

O formulário envia para o seu backend

Quando um visitante envia os dados de cadastro, o navegador transmite o endereço de e-mail para o endpoint da sua aplicação.

2

O backend chama a API de validação

Seu servidor envia uma requisição POST síncrona para a Giggal usando sua chave privada guardada em uma variável de ambiente.

3

O backend aplica a tabela de decisão

Leia os atributos do JSON. Se o e-mail for descartável ou não entregável, devolva ao navegador uma mensagem de erro clara.

4

Deixar passar quando o tempo esgota

Se a comunicação com a API esgotar o tempo limite, aplique fail-open: aceite o cadastro e coloque um job em segundo plano na fila para verificar depois.

Exemplos de código de implementação

Backend: Node.js (rota Express)apenas no servidor
// server.js (Express Route)
const timeoutMs = 5000; // adjust to what your form can tolerate

app.post('/api/signup', async (req, res) => {
  const { email, password } = req.body;

  try {
    const apiRes = await fetch('https://api.giggal.ai/v1/verify', {
      method: 'POST',
      headers: {
        'Authorization': `Bearer ${process.env.GIGGAL_API_KEY}`,
        'Content-Type': 'application/json',
      },
      body: JSON.stringify({ email }),
      signal: AbortSignal.timeout(timeoutMs), // fail-open timeout
    });

    const result = await apiRes.json();
    if (result.success) {
      const { status, details } = result.data;

      // Decision checks
      if (status === 'undeliverable') {
        return res.status(400).json({ error: 'This email address does not exist.' });
      }
      if (details.attributes.disposable) {
        return res.status(400).json({ error: 'Disposable email addresses are not accepted.' });
      }
    }
  } catch (err) {
    // Fail open: log timeout and let user proceed
    console.warn('Email check timed out, failing open:', err.message);
  }

  // Create user in database
  const user = await db.users.create({ email, password });
  return res.json({ success: true, userId: user.id });
});
Backend: Python (rota Flask)apenas no servidor
# app.py (Flask Route)
import os, requests
from flask import Flask, request, jsonify

app = Flask(__name__)
timeout_seconds = 5  # adjust to what your form can tolerate

@app.route("/api/signup", methods=["POST"])
def signup():
    email = request.json.get("email")

    try:
        resp = requests.post(
            "https://api.giggal.ai/v1/verify",
            headers={"Authorization": f"Bearer {os.environ['GIGGAL_API_KEY']}"},
            json={"email": email},
            timeout=timeout_seconds  # fail open on timeout
        )
        data = resp.json().get("data", {})
        if data.get("status") == "undeliverable":
            return jsonify({"error": "Email address is invalid."}), 400
        if data.get("details", {}).get("attributes", {}).get("disposable"):
            return jsonify({"error": "Disposable emails are prohibited."}), 400
    except requests.exceptions.RequestException:
        # Fail open: proceed with signup on timeout
        pass

    # Complete user registration
    return jsonify({"success": True})
Frontend: cliente no navegador (chama o seu próprio backend)script no cliente
// Frontend form submit handler
const form = document.querySelector('#signup-form');

form.addEventListener('submit', async (e) => {
  e.preventDefault();
  const email = document.querySelector('#email-input').value;

  const res = await fetch('/api/signup', {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({ email }),
  });

  const payload = await res.json();
  if (!res.ok) {
    showFormError(payload.error); // Show friendly user feedback
  } else {
    redirectToDashboard();
  }
});

Importante: nunca chame o endpoint da API da Giggal diretamente de scripts no cliente. Mantenha suas credenciais protegidas no seu servidor.

Bloqueie cadastros descartáveis e falsos

Caixas temporárias distorcem as métricas do seu produto, consomem cotas de teste grátis e nunca viram clientes pagantes. Nosso serviço identifica e marca padrões de cadastro de alto risco.

Caixas descartáveis

Comparadas com a nossa base ativa de mais de 100.000 domínios temporários. Saiba como identificamos caixas descartáveis com o nosso verificador de e-mail descartável.

Detecção de alias com sinal de mais

Marca aliases criados com o sinal de mais (user+trial@domain.com), para impedir que uma mesma pessoa crie várias contas de teste.

Detecção de caixas no-reply

Detecta caixas automáticas e de envio em massa que descartam as mensagens recebidas, para que ninguém se cadastre com endereços que não respondem.

Não corrija automaticamente os erros de digitação

Nunca altere em silêncio o que o usuário digitou (por exemplo, trocar gnail.com por gmail.com automaticamente). Se um endereço não passar na validação, mostre uma mensagem clara para o usuário conferir o que digitou. Se você reescrever em silêncio, pode enviar links de ativação de conta ou recibos de cobrança para outra pessoa.

Onde validar e-mails em tempo real

Valide endereços de e-mail em qualquer formulário do seu produto em que os usuários enviam dados.

Formulários de cadastro de usuários

Evite spam de cadastro e ajude os e-mails de boas-vindas e os links de verificação a chegarem a caixas ativas.

Checkout de e-commerce

Garanta que avisos de envio, recibos e confirmações de pedido cheguem aos clientes sem falhas de entrega.

Pedidos de contato e de demo

Filtre entradas falsas de concorrentes e verifique os domínios das empresas antes de passar os contatos para os vendedores.

Assinaturas de newsletter

Proteja a reputação do seu domínio de envio: rejeite entradas malformadas e cadastros de bots no opt-in.

Automações com webhook

Dispare a validação automaticamente nos webhooks dos seus formulários com nossas integrações com Zapier e n8n.

Alterações no perfil da conta

Verifique os novos endereços quando usuários alteram o perfil ou o contato de cobrança.

Campos da resposta que você vai usar no cadastro

Uma referência curta dos principais campos JSON necessários para aplicar a lógica de validação do formulário.

Campo JSONTipoUso no cadastro
data.is_validbooleanVerificação booleana rápida. É true quando as verificações do domínio e da caixa passam.
data.statusstringStatus principal de entrega: "deliverable", "undeliverable", "unknown".
data.deliverability_scorenumber (0-100)Pontuação de qualidade com base nas respostas da caixa, na estabilidade do MX e nas verificações de reputação.
data.details.attributes.disposablebooleanÉ true quando o domínio é um serviço conhecido de caixas temporárias ou descartáveis.
data.details.attributes.free_emailbooleanÉ true para provedores pessoais (Gmail, Outlook). Exija domínios corporativos em formulários B2B.
data.details.attributes.role_accountbooleanÉ true para endereços de organização como info@, admin@ ou support@.
data.catch_all_verdict"valid" | "invalid" | nullResolução de domínios catch-all na mesma chamada. Recupere leads válidos sem descartá-los.

Para ver todas as definições de endpoints, os esquemas de parâmetros e os códigos de erro, consulte a referência completa da API.

Preços da API de validação de e-mail

Pague apenas pelas validações que você faz, sem mínimos mensais nem fidelidade. Cada chamada de validação à API consome 1 crédito, com as verificações de catch-all incluídas na mesma chamada. Resultados desconhecidos são reembolsados automaticamente, e seus primeiros 1.000 créditos são totalmente grátis.

Créditos
3.000créditos
PreçoUS$ 0,0017 / crédito
Economia
-
Total
US$ 5,00compra única
Créditos
10.000créditos
PreçoUS$ 0,0010 / crédito
Economia
Economize 41 %
Total
US$ 9,90compra única
Créditos
30.000créditos
PreçoUS$ 0,0009 / crédito
Economia
Economize 44 %
Total
US$ 28,00compra única
Créditos
50.000créditos
PreçoUS$ 0,0008 / crédito
Economia
Economize 53 %
Total
US$ 39,00compra única
Créditos
100.000créditosMais escolhido
PreçoUS$ 0,0008 / crédito
Economia
Economize 54 %
Total
US$ 76,00compra única
Créditos
300.000créditos
PreçoUS$ 0,0007 / crédito
Economia
Economize 56 %
Total
US$ 222,00compra única
Créditos
500.000créditos
PreçoUS$ 0,0007 / crédito
Economia
Economize 57 %
Total
US$ 360,00compra única
Créditos
800.000créditos
PreçoUS$ 0,0007 / crédito
Economia
Economize 58 %
Total
US$ 559,00compra única
Créditos
1.000.000créditos
PreçoUS$ 0,0007 / crédito
Economia
Economize 59 %
Total
US$ 680,00compra única

Veja todos os planos por volume e os descontos da assinatura mensal na nossa página de preços.

Perguntas frequentes sobre a API de validação de e-mail

Respostas para dúvidas comuns de implementação sobre formulários de cadastro e validação em tempo real.

Sim. Cada conta nova recebe 1.000 créditos grátis no cadastro, sem cartão de crédito. Você pode gerar uma chave de API no seu painel de desenvolvedor e começar a testar a validação de formulários em tempo real na hora. Os créditos grátis nunca expiram e dão acesso completo a todos os atributos e verificações de validação.

Não. Chamar a API direto do JavaScript no cliente exporia sua chave de API secreta a qualquer pessoa que inspecionasse as requisições de rede do navegador. Envie sempre os dados do formulário primeiro para o seu próprio servidor backend ou para uma função serverless, e deixe o seu servidor fazer a requisição para https://api.giggal.ai/v1/verify.

Nenhuma mensagem é enviada. A API verifica se a caixa existe. Ela encerra a conexão antes de transmitir qualquer dado ou conteúdo do e-mail, então seus usuários não recebem nada na caixa de entrada.

Sim. Cada verificação compara o domínio com a nossa base de mais de 100.000 domínios de e-mail descartáveis e temporários. Se houver correspondência, details.attributes.disposable retorna true e o status passa a ser undeliverable, para que o seu backend possa bloquear contas temporárias.

Depende do seu modelo de negócio. Em apps para consumidores, contas de função como support@ ou info@ podem representar organizações legítimas. Em um SaaS B2B self-service, em que é preciso saber quem é cada usuário, muitas empresas marcam ou proíbem contas de função genéricas para evitar o compartilhamento de login.

Domínios catch-all aceitam qualquer endereço de destinatário sem condição, o que deixa as verificações comuns inconclusivas. Nossa API faz a verificação completa de catch-all na mesma chamada para saber se a caixa existe. Se a verificação de catch-all retornar "valid", você pode permitir o cadastro com segurança; se retornar "invalid", o endereço vai dar bounce e o cadastro deve ser barrado.

Recomendamos usar o padrão fail-open. Se a chamada do seu backend sofrer um timeout de rede ou um erro de conexão, deixe o cadastro ser concluído em vez de bloquear um possível cliente. Coloque o endereço não validado na fila do seu processo em segundo plano para verificar o status de entrega mais tarde.

Escolha uma API de validação de e-mail quando precisar de verificações em tempo real em formulários de cadastro na web, para barrar erros de digitação, caixas descartáveis e bots no envio do formulário. Escolha uma API de verificação de e-mail quando for auditar bases de marketing existentes, sincronizar contatos do CRM ou limpar arquivos de e-mail em massa antes de enviar campanhas.

Proteja seus formulários de cadastro hoje

1.000 créditos grátis, sem cartão.

Teste grátis Os créditos não expiram Reembolso dos Desconhecidos