Verify emails in Go with Verifly

Email verification the Go way

Go's standard library is deliberately batteries-included, and net/http plus encoding/json cover everything you need to talk to a REST service. That philosophy pairs well with Verifly: there is no vendor SDK to vendor into your go.mod, no generics-heavy wrapper, just a struct definition and a decode call. You build a request, set a Bearer header, and unmarshal the response into a struct whose fields map to result, is_valid, and the boolean flags.

The reason a Go backend needs this at all is the same reason every backend does. Parsing an address with net/mail confirms the syntax and nothing more — it cannot tell you the mailbox behind ceo@acme.com was deprovisioned last quarter, that the domain is a disposable throwaway, or that you are looking at a role inbox. Verifly runs a live SMTP probe and answers with a result of deliverable, undeliverable, or risky alongside disposable, role, catch-all, and smtp flags. Decoded into a struct, that becomes an ordinary switch statement in your handler.

Go is a common choice for high-throughput services and CLIs, and Verifly's pricing suits both. Pay-as-you-go from $2 per 1,000 checks down to $0.60 per 1,000 at volume means a chatty ingestion pipeline and a one-off cleanup command bill the same way. Self-register for 100 free credits with no card and no captcha, then reuse the vf_ key across every binary you ship.

Batch-verify a slice of emails in Go

When you hold a slice of addresses, marshal them into a request body and POST to /verify/batch rather than spawning a goroutine per address. The endpoint takes an emails array and returns a results array in order, which you decode into a slice of structs and range over. This is both faster and cheaper than hammering the single endpoint concurrently.

emails := []string{
    "ada@example.com",
    "info@some-domain.com",
    "noreply@disposable.tld",
}
body, _ := json.Marshal(map[string][]string{"emails": emails})

req, _ := http.NewRequest("POST",
    "https://verifly.email/api/v1/verify/batch", bytes.NewReader(body))
req.Header.Set("Authorization", "Bearer vf_YOUR_KEY")
req.Header.Set("Content-Type", "application/json")

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

var out struct {
    Results []struct {
        Email      string `json:"email"`
        Result     string `json:"result"`
        Disposable bool   `json:"disposable"`
        Role       bool   `json:"role"`
    } `json:"results"`
}
json.NewDecoder(resp.Body).Decode(&out)

for _, r := range out.Results {
    if r.Result == "deliverable" {
        fmt.Println("keep:", r.Email)
    }
}

Validate at signup in an HTTP handler

The most valuable spot to verify in a Go web service is the registration handler. Use a client with an explicit timeout so a slow probe never stalls the request, and treat a network error as fail-open so signups are never blocked by an outage. Reject disposable addresses outright and warn on undeliverable ones before you persist the user.

var client = &http.Client{Timeout: 8 * time.Second}

func emailOK(email string) bool {
    req, _ := http.NewRequest("GET",
        "https://verifly.email/api/v1/verify?email="+url.QueryEscape(email), nil)
    req.Header.Set("Authorization", "Bearer vf_YOUR_KEY")

    resp, err := client.Do(req)
    if err != nil {
        return true // fail open on network error
    }
    defer resp.Body.Close()

    var r struct {
        Result     string `json:"result"`
        Disposable bool   `json:"disposable"`
    }
    json.NewDecoder(resp.Body).Decode(&r)
    if r.Disposable {
        return false
    }
    return r.Result != "undeliverable"
}