Encontrar um Email Profissional

Pesquise um endereço de email profissional verificado para qualquer prospeto usando apenas o primeiro nome, apelido e domínio da empresa — com a API Email Finder da Piloterr.

Visão geral

Este guia mostra como encontrar e verificar um endereço de email profissional para um prospeto. Use-o em pipelines de vendas outbound para enriquecer automaticamente registos de contacto antes de enviar uma sequência.

Pré-requisitos

Uma chave de API Piloterr — obtenha uma em app.piloterr.com
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

Encontrar um endereço de email

Chame GET /v2/email/finder com first_name, last_name e domain.

import requests

API_KEY  = "YOUR_API_KEY"
response = requests.get(
    "https://api.piloterr.com/v2/email/finder",
    headers={"x-api-key": API_KEY},
    params={"first_name": "Patrick", "last_name": "Collison", "domain": "stripe.com"},
)
result = response.json()
print(result)

const API_KEY = "YOUR_API_KEY";

const params   = new URLSearchParams({ first_name: "Patrick", last_name: "Collison", domain: "stripe.com" });
const response = await fetch(`https://api.piloterr.com/v2/email/finder?${params}`, {
  headers: { "x-api-key": API_KEY },
});
const result = await response.json();
console.log(result);

<?php
$apiKey = "YOUR_API_KEY";
$params = http_build_query(["first_name" => "Patrick", "last_name" => "Collison", "domain" => "stripe.com"]);

$ch = curl_init("https://api.piloterr.com/v2/email/finder?{$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{
        "first_name": {"Patrick"}, "last_name": {"Collison"}, "domain": {"stripe.com"},
    }
    req, _ := http.NewRequest("GET", "https://api.piloterr.com/v2/email/finder?"+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.http.*;

var client  = HttpClient.newHttpClient();
var request = HttpRequest.newBuilder()
    .uri(URI.create("https://api.piloterr.com/v2/email/finder?first_name=Patrick&last_name=Collison&domain=stripe.com"))
    .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 body = await client.GetStringAsync(
    "https://api.piloterr.com/v2/email/finder?first_name=Patrick&last_name=Collison&domain=stripe.com");
Console.WriteLine(body);

#[tokio::main]
async fn main() -> Result<(), reqwest::Error> {
    let result = reqwest::Client::new()
        .get("https://api.piloterr.com/v2/email/finder")
        .header("x-api-key", "YOUR_API_KEY")
        .query(&[("first_name", "Patrick"), ("last_name", "Collison"), ("domain", "stripe.com")])
        .send().await?.json::<serde_json::Value>().await?;

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

Analisar o resultado

A resposta inclui email, confidence (0–100), status (valid, risky, invalid) e o padrão de email detetado.

email      = result.get("email")
confidence = result.get("confidence")
status     = result.get("status")

if email and confidence >= 70:
    print(f"✓ Encontrado: {email} (confiança: {confidence}%, estado: {status})")
else:
    print(f"✗ Email não encontrado ou confiança baixa (estado: {status})")

const { email, confidence, status } = result;

if (email && confidence >= 70) {
  console.log(`✓ Encontrado: ${email} (confiança: ${confidence}%, estado: ${status})`);
} else {
  console.log(`✗ Email não encontrado ou confiança baixa (estado: ${status})`);
}

$email      = $result["email"] ?? null;
$confidence = $result["confidence"] ?? 0;
$status     = $result["status"] ?? "desconhecido";

if ($email && $confidence >= 70) {
    echo "✓ Encontrado: {$email} (confiança: {$confidence}%, estado: {$status})\n";
} else {
    echo "✗ Email não encontrado ou confiança baixa (estado: {$status})\n";
}

email      := result["email"]
confidence := result["confidence"]
status     := result["status"]

if email != nil && confidence.(float64) >= 70 {
    fmt.Printf("✓ Encontrado: %v (confiança: %.0f%%, estado: %v)\n", email, confidence, status)
} else {
    fmt.Printf("✗ Email não encontrado ou confiança baixa (estado: %v)\n", status)
}

import org.json.*;

var r          = new JSONObject(response.body());
var email      = r.optString("email", null);
var confidence = r.optInt("confidence", 0);
var status     = r.optString("status", "desconhecido");

if (email != null && confidence >= 70) {
    System.out.printf("✓ Encontrado: %s (confiança: %d%%, estado: %s)%n", email, confidence, status);
} else {
    System.out.printf("✗ Email não encontrado ou confiança baixa (estado: %s)%n", status);
}

using System.Text.Json;

var r          = JsonDocument.Parse(body).RootElement;
var email      = r.TryGetProperty("email",      out var e) ? e.GetString()  : null;
var confidence = r.TryGetProperty("confidence", out var c) ? c.GetInt32()   : 0;
var status     = r.TryGetProperty("status",     out var s) ? s.GetString()  : "desconhecido";

if (email != null && confidence >= 70)
    Console.WriteLine($"✓ Encontrado: {email} (confiança: {confidence}%, estado: {status})");
else
    Console.WriteLine($"✗ Email não encontrado ou confiança baixa (estado: {status})");

let email      = result["email"].as_str().unwrap_or("");
let confidence = result["confidence"].as_i64().unwrap_or(0);
let status     = result["status"].as_str().unwrap_or("desconhecido");

if !email.is_empty() && confidence >= 70 {
    println!("✓ Encontrado: {} (confiança: {}%, estado: {})", email, confidence, status);
} else {
    println!("✗ Email não encontrado ou confiança baixa (estado: {})", status);
}

Enriquecer uma lista de prospetos a partir de um CSV

Carregue um CSV de prospetos, encontre os seus emails e escreva os resultados de volta.

import csv, time, requests

API_KEY = "YOUR_API_KEY"

def find_email(first: str, last: str, domain: str) -> dict:
    r = requests.get("https://api.piloterr.com/v2/email/finder",
        headers={"x-api-key": API_KEY},
        params={"first_name": first, "last_name": last, "domain": domain})
    return r.json()

prospects = [
    {"first_name": "Patrick", "last_name": "Collison",  "domain": "stripe.com"},
    {"first_name": "Sam",     "last_name": "Altman",    "domain": "openai.com"},
    {"first_name": "Tobi",    "last_name": "Lutke",     "domain": "shopify.com"},
]

with open("prospetos_enriquecidos.csv", "w", newline="") as f:
    fieldnames = ["first_name", "last_name", "domain", "email", "confidence", "status"]
    writer     = csv.DictWriter(f, fieldnames=fieldnames)
    writer.writeheader()

    for p in prospects:
        result = find_email(p["first_name"], p["last_name"], p["domain"])
        writer.writerow({**p, "email": result.get("email", ""), "confidence": result.get("confidence", 0), "status": result.get("status", "")})
        time.sleep(0.5)

print("Concluído! Resultados guardados em prospetos_enriquecidos.csv")

import { writeFileSync } from "fs";

const API_KEY    = "YOUR_API_KEY";
const prospects  = [
  { first_name: "Patrick", last_name: "Collison", domain: "stripe.com" },
  { first_name: "Sam",     last_name: "Altman",   domain: "openai.com" },
  { first_name: "Tobi",    last_name: "Lutke",    domain: "shopify.com" },
];
const rows: string[] = ["first_name,last_name,domain,email,confidence,status"];

for (const p of prospects) {
  const params = new URLSearchParams({ first_name: p.first_name, last_name: p.last_name, domain: p.domain });
  const res    = await fetch(`https://api.piloterr.com/v2/email/finder?${params}`, {
    headers: { "x-api-key": API_KEY },
  });
  const r = await res.json();
  rows.push(`${p.first_name},${p.last_name},${p.domain},${r.email ?? ""},${r.confidence ?? 0},${r.status ?? ""}`);
  await new Promise(resolve => setTimeout(resolve, 500));
}

writeFileSync("prospetos_enriquecidos.csv", rows.join("\n"));
console.log("Concluído! Resultados guardados em prospetos_enriquecidos.csv");

<?php
$apiKey    = "YOUR_API_KEY";
$prospects = [
    ["first_name" => "Patrick", "last_name" => "Collison",  "domain" => "stripe.com"],
    ["first_name" => "Sam",     "last_name" => "Altman",    "domain" => "openai.com"],
    ["first_name" => "Tobi",    "last_name" => "Lutke",     "domain" => "shopify.com"],
];

$fp = fopen("prospetos_enriquecidos.csv", "w");
fputcsv($fp, ["first_name", "last_name", "domain", "email", "confidence", "status"]);

foreach ($prospects as $p) {
    $ch = curl_init("https://api.piloterr.com/v2/email/finder?" . http_build_query($p));
    curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
    curl_setopt($ch, CURLOPT_HTTPHEADER, ["x-api-key: {$apiKey}"]);
    $r = json_decode(curl_exec($ch), true);
    curl_close($ch);
    fputcsv($fp, [$p["first_name"], $p["last_name"], $p["domain"],
        $r["email"] ?? "", $r["confidence"] ?? 0, $r["status"] ?? ""]);
    usleep(500000);
}
fclose($fp);
echo "Concluído! Resultados guardados em prospetos_enriquecidos.csv\n";

package main

import (
    "encoding/csv"
    "encoding/json"
    "io"
    "net/http"
    "net/url"
    "os"
    "strconv"
    "time"
)

type Prospeto struct{ FirstName, LastName, Domain string }

func findEmail(apiKey string, p Prospeto) map[string]any {
    params := url.Values{"first_name": {p.FirstName}, "last_name": {p.LastName}, "domain": {p.Domain}}
    req, _ := http.NewRequest("GET", "https://api.piloterr.com/v2/email/finder?"+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 r map[string]any
    json.Unmarshal(body, &r)
    return r
}

func main() {
    apiKey    := "YOUR_API_KEY"
    prospects := []Prospeto{
        {"Patrick", "Collison", "stripe.com"},
        {"Sam", "Altman", "openai.com"},
        {"Tobi", "Lutke", "shopify.com"},
    }

    f, _ := os.Create("prospetos_enriquecidos.csv")
    w    := csv.NewWriter(f)
    w.Write([]string{"first_name", "last_name", "domain", "email", "confidence", "status"})

    for _, p := range prospects {
        r          := findEmail(apiKey, p)
        confidence := strconv.FormatFloat(r["confidence"].(float64), 'f', 0, 64)
        w.Write([]string{p.FirstName, p.LastName, p.Domain,
            r["email"].(string), confidence, r["status"].(string)})
        time.Sleep(500 * time.Millisecond)
    }
    w.Flush()
    f.Close()
}

import java.net.URI;
import java.net.http.*;
import java.nio.file.*;
import java.util.*;
import org.json.*;

public class Main {
    public static void main(String[] args) throws Exception {
        var client    = HttpClient.newHttpClient();
        var apiKey    = "YOUR_API_KEY";
        var prospects = List.of(
            Map.of("first_name","Patrick","last_name","Collison","domain","stripe.com"),
            Map.of("first_name","Sam",    "last_name","Altman",  "domain","openai.com"),
            Map.of("first_name","Tobi",   "last_name","Lutke",   "domain","shopify.com"));
        var lines = new ArrayList<String>();
        lines.add("first_name,last_name,domain,email,confidence,status");

        for (var p : prospects) {
            var url = "https://api.piloterr.com/v2/email/finder?first_name=" + p.get("first_name")
                + "&last_name=" + p.get("last_name") + "&domain=" + p.get("domain");
            var req  = HttpRequest.newBuilder().uri(URI.create(url))
                .header("x-api-key", apiKey).GET().build();
            var resp = client.send(req, HttpResponse.BodyHandlers.ofString());
            var r    = new JSONObject(resp.body());
            lines.add(String.join(",", p.get("first_name"), p.get("last_name"), p.get("domain"),
                r.optString("email",""), String.valueOf(r.optInt("confidence")), r.optString("status","")));
            Thread.sleep(500);
        }
        Files.write(Path.of("prospetos_enriquecidos.csv"), lines);
        System.out.println("Concluído! Resultados guardados em prospetos_enriquecidos.csv");
    }
}

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

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

var prospects = new[] {
    (first: "Patrick", last: "Collison", domain: "stripe.com"),
    (first: "Sam",     last: "Altman",   domain: "openai.com"),
    (first: "Tobi",    last: "Lutke",    domain: "shopify.com"),
};
var lines = new List<string> { "first_name,last_name,domain,email,confidence,status" };

foreach (var p in prospects)
{
    var body = await client.GetStringAsync(
        $"https://api.piloterr.com/v2/email/finder?first_name={p.first}&last_name={p.last}&domain={p.domain}");
    var r          = JsonDocument.Parse(body).RootElement;
    var email      = r.TryGetProperty("email",      out var e) ? e.GetString()  : "";
    var confidence = r.TryGetProperty("confidence", out var c) ? c.GetInt32().ToString() : "0";
    var status     = r.TryGetProperty("status",     out var s) ? s.GetString()  : "";
    lines.Add($"{p.first},{p.last},{p.domain},{email},{confidence},{status}");
    await Task.Delay(500);
}

File.WriteAllLines("prospetos_enriquecidos.csv", lines);
Console.WriteLine("Concluído! Resultados guardados em prospetos_enriquecidos.csv");

use reqwest::Client;
use serde_json::Value;
use std::{fs::File, io::Write, time::Duration};
use tokio::time::sleep;

#[tokio::main]
async fn main() -> Result<(), reqwest::Error> {
    let client    = Client::new();
    let api_key   = "YOUR_API_KEY";
    let prospects = vec![
        ("Patrick", "Collison", "stripe.com"),
        ("Sam",     "Altman",   "openai.com"),
        ("Tobi",    "Lutke",    "shopify.com"),
    ];

    let mut file = File::create("prospetos_enriquecidos.csv").unwrap();
    writeln!(file, "first_name,last_name,domain,email,confidence,status").unwrap();

    for (first, last, domain) in &prospects {
        let r = client.get("https://api.piloterr.com/v2/email/finder")
            .header("x-api-key", api_key)
            .query(&[("first_name", first), ("last_name", last), ("domain", domain)])
            .send().await?.json::<Value>().await?;
        writeln!(file, "{},{},{},{},{},{}",
            first, last, domain,
            r["email"].as_str().unwrap_or(""),
            r["confidence"].as_i64().unwrap_or(0),
            r["status"].as_str().unwrap_or("")).unwrap();
        sleep(Duration::from_millis(500)).await;
    }
    println!("Concluído! Resultados guardados em prospetos_enriquecidos.csv");
    Ok(())
}

Use apenas emails com confidence >= 70 e status == "valid" em contacto frio. Endereços com menor confiança arriscam rejeições que prejudicam a reputação do seu domínio.