Verify Lead and Contact emails in Salesforce

Why bad emails cost you inside Salesforce

Salesforce validates email fields for format only. A Lead can be created from a web-to-lead form, an import, or an API integration with a perfectly shaped address that has no mailbox behind it. That bad record then flows into campaigns, Pardot/Account Engagement journeys, and rep outreach, where it bounces, skews your engagement metrics, and burns your sending domain's reputation.

Because Salesforce sits at the center of your revenue data, a dirty email field is expensive: reps waste time on unreachable prospects, marketing pays to email dead addresses, and your reporting is quietly wrong. The cheapest place to catch this is at the moment a Lead or Contact is created, before the record fans out to every downstream system.

Verifly runs a live SMTP mailbox check and returns a deliverable / undeliverable / risky verdict with disposable, role, and catch-all flags. Salesforce can call it from an Apex HttpRequest callout in a trigger handler or from a Flow HTTP Callout action — both hit the same endpoint.

Verify a Lead email with an Apex callout

1. Grab a free Verifly key at verifly.email/api/v1/autonomous/register — 100 credits, no card, no captcha.
2. Create a Named Credential named Verifly pointing at https://verifly.email with a Bearer vf_ authorization header, so the key never sits in code.
3. Add https://verifly.email to Remote Site Settings if you aren't routing solely through the Named Credential.
4. Write an @future (callout=true) or Queueable Apex method that verifies the email, since callouts can't run inline in a before-insert trigger.
5. Store the verdict on a custom field (Email_Status__c) and, if you want a hard gate, block or reassign undeliverable records.

public class VeriflyService {
    @future(callout=true)
    public static void verifyLead(Id leadId, String email) {
        HttpRequest req = new HttpRequest();
        req.setEndpoint('callout:Verifly/api/v1/verify?email='
            + EncodingUtil.urlEncode(email, 'UTF-8'));
        req.setMethod('GET');
        req.setTimeout(20000);

        HttpResponse res = new Http().send(req);
        if (res.getStatusCode() != 200) {
            return; // fail open: don't wipe data on a verifier outage
        }

        Map<String, Object> body =
            (Map<String, Object>) JSON.deserializeUntyped(res.getBody());
        String verdict = (String) body.get('result');

        Lead ld = new Lead(Id = leadId, Email_Status__c = verdict);
        if (verdict == 'undeliverable' || body.get('disposable') == true) {
            ld.Email_Status__c = 'undeliverable';
        }
        update ld;
    }
}

The no-code path: a Flow HTTP Callout

If you'd rather stay declarative, a record-triggered Flow can do the same job. Add an HTTP Callout action (or an External Service) pointing at the Verifly Named Credential, pass the email as the query parameter, and map the returned result into your Email_Status__c field. A Decision element then routes undeliverable records to review or reassignment. This keeps verification in the hands of your ops admin without any Apex.

GET  https://verifly.email/api/v1/verify?email={!$Record.Email}
Authorization: Bearer vf_your_api_key    (via the Verifly Named Credential)

// Response body
{
  "email": "prospect@example.com",
  "result": "deliverable",   // map to Email_Status__c
  "disposable": false,
  "role": false,
  "catch_all": false
}