EmailVerify LogoEmailVerify

Quickstart

Get started with email verification API in 5 minutes. Free API key, code examples, and email verification integration guide.

Get up and running with the EmailVerify API in just 5 minutes. This guide walks you through verifying your first email address.

Prerequisites

Before you begin, you'll need:

  • A EmailVerify account (Sign up free)
  • Basic knowledge of HTTP requests or familiarity with one of our supported languages

Step 1: Create an Account

  1. Visit EmailVerify and click Get Started
  2. Sign up with your email or Google/GitHub account
  3. Verify your email address

Step 2: Get Your API Key

  1. Log in to your EmailVerify dashboard
  2. Navigate to the API Keys section
  3. Click Create New Key
  4. Give your key a descriptive name (e.g., "Development", "Production")
  5. Copy your API key and store it securely

Never expose your API key in client-side code or public repositories. Use environment variables to store your key securely.

Step 3: Verify Your First Email

Choose your preferred method to make your first verification request:

curl -X POST https://api.emailverify.ai/v1/verify/single \
  -H "EMAILVERIFY-API-KEY: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"email": "test@example.com"}'
const response = await fetch('https://api.emailverify.ai/v1/verify/single', {
  method: 'POST',
  headers: {
    'EMAILVERIFY-API-KEY': process.env.EMAILVERIFY_API_KEY,
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    email: 'test@example.com',
  }),
});

const result = await response.json();
console.log(result);
import os
import requests

response = requests.post(
    'https://api.emailverify.ai/v1/verify/single',
    headers={
        'EMAILVERIFY-API-KEY': os.environ['EMAILVERIFY_API_KEY'],
        'Content-Type': 'application/json',
    },
    json={'email': 'test@example.com'}
)

result = response.json()
print(result)
package main

import (
    "bytes"
    "encoding/json"
    "fmt"
    "net/http"
    "os"
)

func main() {
    data := map[string]string{"email": "test@example.com"}
    body, _ := json.Marshal(data)

    req, _ := http.NewRequest("POST",
        "https://api.emailverify.ai/v1/verify/single",
        bytes.NewBuffer(body))

    req.Header.Set("EMAILVERIFY-API-KEY", os.Getenv("EMAILVERIFY_API_KEY"))
    req.Header.Set("Content-Type", "application/json")

    client := &http.Client{}
    resp, _ := client.Do(req)
    defer resp.Body.Close()

    var result map[string]interface{}
    json.NewDecoder(resp.Body).Decode(&result)
    fmt.Println(result)
}
<?php
$apiKey = getenv('EMAILVERIFY_API_KEY');

$ch = curl_init('https://api.emailverify.ai/v1/verify/single');
curl_setopt_array($ch, [
    CURLOPT_POST => true,
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => [
        'EMAILVERIFY-API-KEY: ' . $apiKey,
        'Content-Type: application/json',
    ],
    CURLOPT_POSTFIELDS => json_encode(['email' => 'test@example.com']),
]);

$response = curl_exec($ch);
curl_close($ch);

$result = json_decode($response, true);
print_r($result);

Step 4: Understand the Response

A successful verification returns a response like this:

{
  "success": true,
  "code": "0",
  "message": "Success",
  "data": {
    "email": "test@example.com",
    "status": "valid",
    "score": 0.95,
    "is_deliverable": true,
    "is_disposable": false,
    "is_catchall": false,
    "is_role": false,
    "is_free": false,
    "domain": "example.com",
    "mx_records": ["has_mx_records"],
    "smtp_check": true,
    "reason": null,
    "credits_used": 1
  }
}

Key Response Fields

FieldTypeDescription
statusstringOverall status: valid, invalid, unknown, catchall, role, disposable
is_deliverablebooleanWhether the email can receive messages
is_disposablebooleanWhether it's a temporary/disposable email
is_rolebooleanWhether it's a role-based address (info@, support@)
is_catchallbooleanWhether the domain accepts all emails
scorenumberConfidence score from 0 to 1 (higher is better)

Status Values Explained

StatusScoreMeaningRecommended Action
valid0.9+Email exists and can receive messagesSafe to send
invalid0.1Email doesn't exist or can't receive messagesRemove from list
unknown0.5Couldn't determine statusRetry later or use caution
catchall0.7Domain accepts all emailsMonitor for bounces
role0.6Role-based email (info@, support@)Usually deliverable
disposable0.3Temporary email serviceConsider removing

For easier integration, install one of our official SDKs:

npm install @emailverify/sdk
import { EmailVerify } from '@emailverify/sdk';

const client = new EmailVerify({
  apiKey: process.env.EMAILVERIFY_API_KEY,
});

const result = await client.verify('test@example.com');
console.log(result.data.status); // 'valid'
pip install emailverify
from emailverify import Client
import os

client = Client(api_key=os.environ['EMAILVERIFY_API_KEY'])
result = client.verify('test@example.com')
print(result.data.status)  # 'valid'
go get github.com/emailverify/go-sdk
import emailverify "github.com/emailverify/go-sdk"

client := emailverify.NewClient(os.Getenv("EMAILVERIFY_API_KEY"))
result, err := client.Verify(ctx, "test@example.com")
fmt.Println(result.Data.Status) // "valid"
composer require emailverify/php-sdk
use EmailVerify\Client;

$client = new Client(getenv('EMAILVERIFY_API_KEY'));
$result = $client->verify('test@example.com');
echo $result->data->status; // 'valid'

What's Next?

Now that you've verified your first email, explore more features:

Common Use Cases

Form Validation

Verify emails in real-time during user registration:

const onEmailBlur = async (email) => {
  const result = await client.verify(email);

  if (result.data.status === 'invalid') {
    showError('Please enter a valid email');
  } else if (result.data.is_disposable) {
    showError('Disposable emails are not allowed');
  }
};

List Cleaning

Clean your email list before sending campaigns:

for email in email_list:
    result = client.verify(email)
    if result.data.status == 'valid':
        clean_list.append(email)
    else:
        remove_list.append(email)

Lead Qualification

Score leads based on email quality:

const qualifyLead = (result) => {
  let score = result.data.score * 50; // Base score

  if (!result.data.is_free) score += 20;      // Business email
  if (!result.data.is_role) score += 15;      // Personal address
  if (!result.data.is_disposable) score += 15; // Permanent email

  return score;
};

Need Help?

On this page