Validar Email no Registo

Verifique se um endereço de email é real e pode receber mensagens no momento do registo usando a API de validação de email Veille — incluindo verificações de sintaxe, DNS e caixa de correio.

Visão geral

Este guia mostra como executar uma validação completa de email antes de aceitar um registo: verificação de sintaxe, consulta de registos DNS/MX, e acessibilidade SMTP. A API devolve um risk_score (0 = seguro, 100 = alto risco) que pode usar para encaminhar utilizadores para etapas de verificação adicionais.

Pré-requisitos

Uma chave de API Veille — obtenha uma em app.veille.io
Instale as dependências para o seu idioma:

pip install requests

Sem dependências adicionais — utiliza a API fetch nativa (Node 18+).

Extensão curl ativada (ativa por padrão).

Sem dependências adicionais — utiliza net/http (Go 1.18+).

Sem dependências adicionais — utiliza java.net.http (Java 11+).

Sem dependências adicionais — utiliza System.Net.Http (.NET 6+).

# Cargo.toml
[dependencies]
reqwest = { version = "0.12", features = ["json"] }
tokio = { version = "1", features = ["full"] }
serde_json = "1"

Passos

Validar um endereço de email

Chame GET /v1/email com o parâmetro email.

import requests

API_KEY  = "YOUR_API_KEY"
response = requests.get(
    "https://api.veille.io/v1/email",
    headers={"x-api-key": API_KEY},
    params={"email": "[email protected]"},
)
result = response.json()
print(result)

const API_KEY = "YOUR_API_KEY";

const params   = new URLSearchParams({ email: "[email protected]" });
const response = await fetch(`https://api.veille.io/v1/email?${params}`, {
  headers: { "x-api-key": API_KEY },
});
const result = await response.json();
console.log(result);

<?php
$apiKey = "YOUR_API_KEY";
$params = http_build_query(["email" => "[email protected]"]);

$ch = curl_init("https://api.veille.io/v1/email?{$params}");
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, ["x-api-key: {$apiKey}"]);
$result = json_decode(curl_exec($ch), true);
curl_close($ch);
print_r($result);

package main

import (
    "encoding/json"
    "fmt"
    "io"
    "net/http"
    "net/url"
)

func main() {
    params := url.Values{"email": {"[email protected]"}}
    req, _ := http.NewRequest("GET", "https://api.veille.io/v1/email?"+params.Encode(), nil)
    req.Header.Set("x-api-key", "YOUR_API_KEY")

    resp, _ := http.DefaultClient.Do(req)
    defer resp.Body.Close()
    body, _ := io.ReadAll(resp.Body)

    var result map[string]any
    json.Unmarshal(body, &result)
    fmt.Println(result)
}

import java.net.URI;
import java.net.URLEncoder;
import java.net.http.*;
import java.nio.charset.StandardCharsets;

var client  = HttpClient.newHttpClient();
var email   = URLEncoder.encode("[email protected]", StandardCharsets.UTF_8);
var request = HttpRequest.newBuilder()
    .uri(URI.create("https://api.veille.io/v1/email?email=" + email))
    .header("x-api-key", "YOUR_API_KEY")
    .GET().build();

var response = client.send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

using System.Net.Http;

using var client = new HttpClient();
client.DefaultRequestHeaders.Add("x-api-key", "YOUR_API_KEY");

var email = Uri.EscapeDataString("[email protected]");
var body  = await client.GetStringAsync($"https://api.veille.io/v1/email?email={email}");
Console.WriteLine(body);

#[tokio::main]
async fn main() -> Result<(), reqwest::Error> {
    let result = reqwest::Client::new()
        .get("https://api.veille.io/v1/email")
        .header("x-api-key", "YOUR_API_KEY")
        .query(&[("email", "[email protected]")])
        .send().await?.json::<serde_json::Value>().await?;

    println!("{:#?}", result);
    Ok(())
}

Interpretar o resultado

Campos chave: is_valid, is_deliverable, is_disposable, is_role_account, risk_score, did_you_mean (sugestão de correção tipográfica).

print(f"Válido         : {result['is_valid']}")
print(f"Entregável     : {result['is_deliverable']}")
print(f"Descartável    : {result['is_disposable']}")
print(f"Conta funcional: {result['is_role_account']}")
print(f"Pontuação risco: {result['risk_score']}/100")
if result.get("did_you_mean"):
    print(f"Quis dizer     : {result['did_you_mean']}?")

console.log(`Válido         : ${result.is_valid}`);
console.log(`Entregável     : ${result.is_deliverable}`);
console.log(`Descartável    : ${result.is_disposable}`);
console.log(`Conta funcional: ${result.is_role_account}`);
console.log(`Pontuação risco: ${result.risk_score}/100`);
if (result.did_you_mean) console.log(`Quis dizer     : ${result.did_you_mean}?`);

echo "Válido         : " . ($result["is_valid"]       ? "true" : "false") . "\n";
echo "Entregável     : " . ($result["is_deliverable"]  ? "true" : "false") . "\n";
echo "Descartável    : " . ($result["is_disposable"]   ? "true" : "false") . "\n";
echo "Pontuação risco: {$result['risk_score']}/100\n";
if (!empty($result["did_you_mean"])) echo "Quis dizer     : {$result['did_you_mean']}?\n";

fmt.Printf("Válido         : %v\nEntregável     : %v\nDescartável    : %v\nPontuação risco: %v/100\n",
    result["is_valid"], result["is_deliverable"], result["is_disposable"], result["risk_score"])
if typo, ok := result["did_you_mean"].(string); ok && typo != "" {
    fmt.Println("Quis dizer:", typo+"?")
}

import org.json.*;

var r = new JSONObject(response.body());
System.out.printf("Válido         : %b%nEntregável     : %b%nDescartável    : %b%nPontuação risco: %d/100%n",
    r.getBoolean("is_valid"), r.getBoolean("is_deliverable"),
    r.getBoolean("is_disposable"), r.getInt("risk_score"));
if (r.has("did_you_mean")) System.out.println("Quis dizer: " + r.getString("did_you_mean") + "?");

using System.Text.Json;

var r = JsonDocument.Parse(body).RootElement;
Console.WriteLine($"Válido         : {r.GetProperty("is_valid").GetBoolean()}");
Console.WriteLine($"Entregável     : {r.GetProperty("is_deliverable").GetBoolean()}");
Console.WriteLine($"Descartável    : {r.GetProperty("is_disposable").GetBoolean()}");
Console.WriteLine($"Pontuação risco: {r.GetProperty("risk_score").GetInt32()}/100");
if (r.TryGetProperty("did_you_mean", out var typo) && typo.GetString() is { } t and not "")
    Console.WriteLine($"Quis dizer     : {t}?");

println!("Válido         : {}", result["is_valid"]);
println!("Entregável     : {}", result["is_deliverable"]);
println!("Descartável    : {}", result["is_disposable"]);
println!("Pontuação risco: {}/100", result["risk_score"]);
if let Some(typo) = result["did_you_mean"].as_str() {
    if !typo.is_empty() { println!("Quis dizer: {}?", typo); }
}

Construir um fluxo de registo por nível de risco

Use risk_score para encaminhar utilizadores: bloqueie endereços de alto risco, sugira correções de erros tipográficos e aplique verificação adicional a contas funcionais.

import requests

API_KEY = "YOUR_API_KEY"

def validate_email(email: str) -> dict:
    r = requests.get("https://api.veille.io/v1/email",
        headers={"x-api-key": API_KEY}, params={"email": email})
    return r.json()

def register(email: str) -> dict:
    v = validate_email(email)

    if not v.get("is_valid"):
        return {"ok": False, "error": "Este endereço de email é inválido."}

    if v.get("is_disposable"):
        return {"ok": False, "error": "Endereços de email temporários não são aceites."}

    if v.get("did_you_mean"):
        return {"ok": False, "suggestion": f"Quis dizer {v['did_you_mean']}?"}

    if v.get("risk_score", 0) >= 70:
        return {"ok": False, "error": "Este email tem uma pontuação de risco elevada. Por favor, use outro endereço."}

    if v.get("is_role_account"):
        return {"ok": True, "flag": "role_account", "message": "Por favor, verifique o seu email."}

    return {"ok": True, "message": "Registo efetuado com sucesso!"}

for test_email in ["[email protected]", "[email protected]", "[email protected]", "[email protected]"]:
    print(f"{test_email}: {register(test_email)}")

const API_KEY = "YOUR_API_KEY";

async function validateEmail(email: string) {
  const params = new URLSearchParams({ email });
  const res    = await fetch(`https://api.veille.io/v1/email?${params}`, {
    headers: { "x-api-key": API_KEY },
  });
  return res.json();
}

async function register(email: string) {
  const v = await validateEmail(email);
  if (!v.is_valid)       return { ok: false, error: "Endereço de email inválido." };
  if (v.is_disposable)   return { ok: false, error: "Emails temporários não aceites." };
  if (v.did_you_mean)    return { ok: false, suggestion: `Quis dizer ${v.did_you_mean}?` };
  if (v.risk_score >= 70) return { ok: false, error: "Pontuação de risco elevada — use outro endereço." };
  if (v.is_role_account) return { ok: true,  flag: "role_account", message: "Por favor, verifique o seu email." };
  return { ok: true, message: "Registo efetuado com sucesso!" };
}

for (const email of ["[email protected]", "[email protected]", "[email protected]", "[email protected]"]) {
  console.log(email, await register(email));
}

<?php
function validateEmail(string $apiKey, string $email): array {
    $params = http_build_query(["email" => $email]);
    $ch = curl_init("https://api.veille.io/v1/email?{$params}");
    curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
    curl_setopt($ch, CURLOPT_HTTPHEADER, ["x-api-key: {$apiKey}"]);
    $result = json_decode(curl_exec($ch), true);
    curl_close($ch);
    return $result;
}

function register(string $apiKey, string $email): array {
    $v = validateEmail($apiKey, $email);
    if (!($v["is_valid"]      ?? false)) return ["ok" => false, "error" => "Email inválido."];
    if ($v["is_disposable"]   ?? false)  return ["ok" => false, "error" => "Emails temporários não aceites."];
    if (!empty($v["did_you_mean"]))      return ["ok" => false, "suggestion" => "Quis dizer {$v['did_you_mean']}?"];
    if (($v["risk_score"]     ?? 0) >= 70) return ["ok" => false, "error" => "Pontuação de risco elevada."];
    if ($v["is_role_account"] ?? false)  return ["ok" => true,  "flag" => "role_account"];
    return ["ok" => true, "message" => "Registo efetuado com sucesso!"];
}

foreach (["[email protected]", "[email protected]", "[email protected]"] as $email) {
    print_r(["email" => $email, "result" => register("YOUR_API_KEY", $email)]);
}

package main

import (
    "encoding/json"
    "fmt"
    "io"
    "net/http"
    "net/url"
)

const APIKey = "YOUR_API_KEY"

func validate(email string) map[string]any {
    params := url.Values{"email": {email}}
    req, _ := http.NewRequest("GET", "https://api.veille.io/v1/email?"+params.Encode(), nil)
    req.Header.Set("x-api-key", APIKey)
    resp, _ := http.DefaultClient.Do(req)
    defer resp.Body.Close()
    body, _ := io.ReadAll(resp.Body)
    var v map[string]any
    json.Unmarshal(body, &v)
    return v
}

func register(email string) string {
    v := validate(email)
    if !(v["is_valid"].(bool))    { return "❌ Email inválido." }
    if v["is_disposable"].(bool)  { return "❌ Email temporário não aceite." }
    if typo, ok := v["did_you_mean"].(string); ok && typo != "" {
        return "⚠️  Quis dizer " + typo + "?"
    }
    if v["risk_score"].(float64) >= 70 { return "❌ Pontuação de risco elevada." }
    return "✅ Registo efetuado com sucesso!"
}

func main() {
    for _, email := range []string{"[email protected]", "[email protected]", "[email protected]"} {
        fmt.Printf("%s: %s\n", email, register(email))
    }
}

import java.net.URI;
import java.net.URLEncoder;
import java.net.http.*;
import java.nio.charset.StandardCharsets;
import org.json.*;

public class Main {
    static HttpClient client = HttpClient.newHttpClient();
    static String API_KEY   = "YOUR_API_KEY";

    static JSONObject validate(String email) throws Exception {
        var encoded = URLEncoder.encode(email, StandardCharsets.UTF_8);
        var req     = HttpRequest.newBuilder()
            .uri(URI.create("https://api.veille.io/v1/email?email=" + encoded))
            .header("x-api-key", API_KEY).GET().build();
        var resp    = client.send(req, HttpResponse.BodyHandlers.ofString());
        return new JSONObject(resp.body());
    }

    static String register(String email) throws Exception {
        var v = validate(email);
        if (!v.getBoolean("is_valid"))      return "❌ Email inválido.";
        if (v.getBoolean("is_disposable"))  return "❌ Email temporário não aceite.";
        if (v.has("did_you_mean"))          return "⚠️  Quis dizer " + v.getString("did_you_mean") + "?";
        if (v.getInt("risk_score") >= 70)   return "❌ Pontuação de risco elevada.";
        return "✅ Registo efetuado com sucesso!";
    }

    public static void main(String[] args) throws Exception {
        for (var email : new String[]{"[email protected]", "[email protected]", "[email protected]"}) {
            System.out.printf("%s: %s%n", email, register(email));
        }
    }
}

using System.Net.Http;
using System.Text.Json;

var apiKey = "YOUR_API_KEY";
using var client = new HttpClient();
client.DefaultRequestHeaders.Add("x-api-key", apiKey);

async Task<JsonElement> Validate(string email)
{
    var encoded = Uri.EscapeDataString(email);
    var body    = await client.GetStringAsync($"https://api.veille.io/v1/email?email={encoded}");
    return JsonDocument.Parse(body).RootElement;
}

async Task<string> Register(string email)
{
    var v = await Validate(email);
    if (!v.GetProperty("is_valid").GetBoolean())                      return "❌ Email inválido.";
    if (v.GetProperty("is_disposable").GetBoolean())                  return "❌ Email temporário não aceite.";
    if (v.TryGetProperty("did_you_mean", out var t) && t.GetString() is { Length: > 0 } typo)
                                                                      return $"⚠️  Quis dizer {typo}?";
    if (v.GetProperty("risk_score").GetInt32() >= 70)                 return "❌ Pontuação de risco elevada.";
    return "✅ Registo efetuado com sucesso!";
}

foreach (var email in new[] { "[email protected]", "[email protected]", "[email protected]" })
    Console.WriteLine($"{email}: {await Register(email)}");

use reqwest::Client;
use serde_json::Value;

const API_KEY: &str = "YOUR_API_KEY";

async fn validate(client: &Client, email: &str) -> Value {
    client.get("https://api.veille.io/v1/email")
        .header("x-api-key", API_KEY)
        .query(&[("email", email)])
        .send().await.unwrap().json::<Value>().await.unwrap()
}

async fn register(client: &Client, email: &str) -> &'static str {
    let v = validate(client, email).await;
    if !v["is_valid"].as_bool().unwrap_or(false)     { return "❌ Email inválido."; }
    if  v["is_disposable"].as_bool().unwrap_or(false) { return "❌ Email temporário não aceite."; }
    if  v["risk_score"].as_i64().unwrap_or(0) >= 70  { return "❌ Pontuação de risco elevada."; }
    "✅ Registo efetuado com sucesso!"
}

#[tokio::main]
async fn main() -> Result<(), reqwest::Error> {
    let client = Client::new();
    for email in ["[email protected]", "[email protected]", "[email protected]"] {
        println!("{}: {}", email, register(&client, email).await);
    }
    Ok(())
}

Contas funcionais (admin@, info@, support@) são frequentemente monitorizadas por várias pessoas — ou não monitorizadas de todo. Sinalize-as para revisão manual em vez de bloquear diretamente, para evitar perder registos B2B legítimos.