EmailVerify LogoEmailVerify
SDKs

PHP SDK

PHP email checker SDK. Composer install, verify emails with PHP. Code examples included.

Le SDK officiel EmailVerify pour PHP fournit une interface facile à utiliser pour la vérification d'emails avec support Laravel.

Installation

composer require emailverify/php-sdk

Prérequis

  • PHP 8.0 ou supérieur
  • Composer
  • Extension JSON
  • Extension cURL

Démarrage Rapide

<?php

use EmailVerify\Client;

$client = new Client(getenv('EMAILVERIFY_API_KEY'));

$result = $client->verify('user@example.com');
echo "Status: " . $result->status . "\n";
echo "Score: " . $result->score . "\n";

Configuration

Options du Client

$client = new Client(
    apiKey: getenv('EMAILVERIFY_API_KEY'),
    options: [
        'timeout' => 30,           // Délai de requête en secondes
        'retries' => 3,            // Nombre de tentatives
        'base_url' => 'https://api.emailverify.ai',
    ]
);

Configuration d'Environnement

# .env
EMAILVERIFY_API_KEY=your_api_key_here

Vérification Unique

Vérification Basique

$result = $client->verify('user@example.com');

echo "Email: " . $result->email . "\n";
echo "Status: " . $result->status . "\n";
echo "Score: " . $result->score . "\n";
echo "Deliverable: " . ($result->result->deliverable ? 'Yes' : 'No') . "\n";
echo "Disposable: " . ($result->result->disposable ? 'Yes' : 'No') . "\n";

Vérification avec Options

$result = $client->verify('user@example.com', [
    'smtp_check' => true,
    'timeout' => 5,
]);

Structure de Réponse

class VerificationResult {
    public string $email;
    public string $status;        // 'valid', 'invalid', 'unknown', 'accept_all'
    public ResultDetails $result;
    public float $score;
    public ?string $reason;
}

class ResultDetails {
    public ?bool $deliverable;
    public bool $valid_format;
    public bool $valid_domain;
    public bool $valid_mx;
    public bool $disposable;
    public bool $role;
    public bool $catchall;
    public bool $free;
    public ?bool $smtp_valid;
}

Vérification en Masse

Soumettre une Tâche

$emails = [
    'user1@example.com',
    'user2@example.com',
    'user3@example.com',
];

$job = $client->verifyBulk($emails);
echo "Job ID: " . $job->id . "\n";

Vérifier le Statut

$status = $client->getBulkJobStatus($job->id);

echo "Status: " . $status->status . "\n";
echo "Progress: " . $status->processed . "/" . $status->total . "\n";
echo "Valid: " . $status->valid . "\n";
echo "Invalid: " . $status->invalid . "\n";

Obtenir les Résultats

$results = $client->getBulkJobResults($job->id);

foreach ($results as $result) {
    echo $result->email . ": " . $result->status . "\n";
}

Avec Webhook

$job = $client->verifyBulk($emails, [
    'webhook_url' => 'https://your-domain.com/webhooks/emailverify',
]);

Gestion des Crédits

$credits = $client->getCredits();

echo "Available: " . $credits->available . "\n";
echo "Used: " . $credits->used . "\n";
echo "Total: " . $credits->total . "\n";

Gestion des Erreurs

Types d'Exceptions

use EmailVerify\Client;
use EmailVerify\Exceptions\AuthenticationException;
use EmailVerify\Exceptions\RateLimitException;
use EmailVerify\Exceptions\ValidationException;
use EmailVerify\Exceptions\EmailVerifyException;

try {
    $result = $client->verify('invalid-email');
} catch (AuthenticationException $e) {
    echo "Invalid API key\n";
} catch (RateLimitException $e) {
    echo "Rate limited. Retry after " . $e->getRetryAfter() . " seconds\n";
} catch (ValidationException $e) {
    echo "Invalid input: " . $e->getMessage() . "\n";
} catch (EmailVerifyException $e) {
    echo "API error: " . $e->getMessage() . "\n";
}

Intégration Laravel

Fournisseur de Service

The package auto-discovers in Laravel 5.5+. For older versions, add to config/app.php:

'providers' => [
    EmailVerify\Laravel\EmailVerifyServiceProvider::class,
],

'aliases' => [
    'EmailVerify' => EmailVerify\Laravel\Facades\EmailVerify::class,
],

Configuration

Publish the config file:

php artisan vendor:publish --provider="EmailVerify\Laravel\EmailVerifyServiceProvider"

Config file (config/emailverify.php):

<?php

return [
    'api_key' => env('EMAILVERIFY_API_KEY'),
    'timeout' => env('EMAILVERIFY_TIMEOUT', 30),
    'retries' => env('EMAILVERIFY_RETRIES', 3),
];

Utilisation de la Façade

use EmailVerify\Laravel\Facades\EmailVerify;

// Single verification
$result = EmailVerify::verify('user@example.com');

// Bulk verification
$job = EmailVerify::verifyBulk($emails);

// Check credits
$credits = EmailVerify::getCredits();

Dépendance Injection

use EmailVerify\Client;

class UserController extends Controller
{
    public function __construct(
        private Client $emailVerify
    ) {}

    public function register(Request $request)
    {
        $result = $this->emailVerify->verify($request->email);

        if ($result->status === 'invalid') {
            return back()->withErrors(['email' => 'Invalid email address']);
        }

        // Continue registration...
    }
}

Règle de Validation

use EmailVerify\Laravel\Rules\ValidEmail;

$request->validate([
    'email' => ['required', 'email', new ValidEmail()],
]);

Custom rule with options:

use EmailVerify\Laravel\Rules\ValidEmail;

$request->validate([
    'email' => [
        'required',
        'email',
        new ValidEmail([
            'reject_disposable' => true,
            'reject_role' => false,
            'min_score' => 0.7,
        ]),
    ],
]);

Requête de Formulaire

<?php

namespace App\Http\Requests;

use EmailVerify\Laravel\Rules\ValidEmail;
use Illuminate\Foundation\Http\FormRequest;

class RegisterRequest extends FormRequest
{
    public function rules(): array
    {
        return [
            'name' => ['required', 'string', 'max:255'],
            'email' => [
                'required',
                'email',
                'unique:users',
                new ValidEmail([
                    'reject_disposable' => true,
                ]),
            ],
            'password' => ['required', 'min:8', 'confirmed'],
        ];
    }

    public function messages(): array
    {
        return [
            'email.valid_email' => 'Please provide a valid email address.',
        ];
    }
}

Vérification en File d'Attente

<?php

namespace App\Jobs;

use EmailVerify\Client;
use Illuminate\Bus\Queueable;
use Illuminate\Contracts\Queue\ShouldQueue;
use Illuminate\Foundation\Bus\Dispatchable;
use Illuminate\Queue\InteractsWithQueue;
use Illuminate\Queue\SerializesModels;

class VerifyUserEmail implements ShouldQueue
{
    use Dispatchable, InteractsWithQueue, Queueable, SerializesModels;

    public function __construct(
        private int $userId,
        private string $email
    ) {}

    public function handle(Client $client): void
    {
        $result = $client->verify($this->email);

        \App\Models\User::where('id', $this->userId)->update([
            'email_verified' => $result->status === 'valid',
            'email_score' => $result->score,
            'email_disposable' => $result->result->disposable,
        ]);
    }
}

// Dispatch
VerifyUserEmail::dispatch($user->id, $user->email);

Middleware

<?php

namespace App\Http\Middleware;

use EmailVerify\Client;
use Closure;
use Illuminate\Http\Request;

class VerifyEmailMiddleware
{
    public function __construct(
        private Client $client
    ) {}

    public function handle(Request $request, Closure $next)
    {
        if ($request->has('email')) {
            $result = $this->client->verify($request->email);

            if ($result->status === 'invalid') {
                return response()->json([
                    'error' => 'Invalid email address'
                ], 422);
            }

            if ($result->result->disposable) {
                return response()->json([
                    'error' => 'Disposable emails are not allowed'
                ], 422);
            }
        }

        return $next($request);
    }
}

Exemples Complets

Validation d'Inscription

<?php

use EmailVerify\Client;

class EmailValidator
{
    public function __construct(
        private Client $client
    ) {}

    public function validateForRegistration(string $email): array
    {
        $result = $this->client->verify($email);

        // Reject invalid emails
        if ($result->status === 'invalid') {
            return [
                'valid' => false,
                'reason' => 'invalid_email',
                'message' => 'This email address is invalid',
            ];
        }

        // Reject disposable emails
        if ($result->result->disposable) {
            return [
                'valid' => false,
                'reason' => 'disposable',
                'message' => 'Please use a permanent email address',
            ];
        }

        // Warn about role-based emails
        if ($result->result->role) {
            return [
                'valid' => true,
                'warning' => 'role_based',
                'message' => 'Using a personal email is recommended',
            ];
        }

        return [
            'valid' => true,
            'score' => $result->score,
        ];
    }
}

// Usage
$validator = new EmailValidator($client);
$validation = $validator->validateForRegistration('user@example.com');

if (!$validation['valid']) {
    echo $validation['message'];
}

Nettoyage de Liste en Masse

<?php

use EmailVerify\Client;

class ListCleaner
{
    public function __construct(
        private Client $client
    ) {}

    public function cleanList(array $emails): array
    {
        // Submit bulk job
        $job = $this->client->verifyBulk($emails);

        // Poll for completion
        while (true) {
            $status = $this->client->getBulkJobStatus($job->id);

            if ($status->status === 'completed') {
                break;
            }

            if ($status->status === 'failed') {
                throw new \Exception('Bulk job failed');
            }

            sleep(5);
        }

        // Get and categorize results
        $results = $this->client->getBulkJobResults($job->id);

        $valid = [];
        $invalid = [];
        $risky = [];

        foreach ($results as $result) {
            if ($result->status === 'invalid') {
                $invalid[] = $result->email;
            } elseif ($result->result->disposable || $result->result->role) {
                $risky[] = $result->email;
            } else {
                $valid[] = $result->email;
            }
        }

        return [
            'valid' => $valid,
            'invalid' => $invalid,
            'risky' => $risky,
            'stats' => [
                'total' => count($emails),
                'valid_count' => count($valid),
                'invalid_count' => count($invalid),
                'risky_count' => count($risky),
            ],
        ];
    }
}

Point de Terminaison API

<?php
// api/verify.php

header('Content-Type: application/json');

use EmailVerify\Client;

$client = new Client(getenv('EMAILVERIFY_API_KEY'));

if ($_SERVER['REQUEST_METHOD'] !== 'POST') {
    http_response_code(405);
    echo json_encode(['error' => 'Method not allowed']);
    exit;
}

$input = json_decode(file_get_contents('php://input'), true);
$email = $input['email'] ?? null;

if (!$email) {
    http_response_code(400);
    echo json_encode(['error' => 'Email is required']);
    exit;
}

try {
    $result = $client->verify($email);
    echo json_encode([
        'email' => $result->email,
        'status' => $result->status,
        'score' => $result->score,
        'deliverable' => $result->result->deliverable,
    ]);
} catch (\Exception $e) {
    http_response_code(500);
    echo json_encode(['error' => 'Verification failed']);
}

Meilleures Pratiques

1. Mettre en Cache les Résultats

use Illuminate\Support\Facades\Cache;

function verifyWithCache(Client $client, string $email): VerificationResult
{
    $cacheKey = 'email_verification_' . md5($email);

    return Cache::remember($cacheKey, 3600, function () use ($client, $email) {
        return $client->verify($email);
    });
}

2. Gérer les Erreurs Avec Élégance

function safeVerify(Client $client, string $email): ?VerificationResult
{
    try {
        return $client->verify($email);
    } catch (RateLimitException $e) {
        Log::warning('Rate limited', ['retry_after' => $e->getRetryAfter()]);
        return null;
    } catch (EmailVerifyException $e) {
        Log::error('Verification failed', ['error' => $e->getMessage()]);
        return null;
    }
}

Prochaines Étapes

Référence API

Documentation détaillée de l'API

Intégration Laravel

Patterns Laravel avancés

Go SDK

Go email checker SDK. Install, configure, verify emails with Golang. Code examples included.

Java SDK

Java email checker SDK. Maven/Gradle setup, verify emails with Java. Code examples included.

On this page

InstallationPrérequisDémarrage RapideConfigurationOptions du ClientConfiguration d'EnvironnementVérification UniqueVérification BasiqueVérification avec OptionsStructure de RéponseVérification en MasseSoumettre une TâcheVérifier le StatutObtenir les RésultatsAvec WebhookGestion des CréditsGestion des ErreursTypes d'ExceptionsIntégration LaravelFournisseur de ServiceConfigurationUtilisation de la FaçadeDépendance InjectionRègle de ValidationRequête de FormulaireVérification en File d'AttenteMiddlewareExemples CompletsValidation d'InscriptionNettoyage de Liste en MassePoint de Terminaison APIMeilleures Pratiques1. Mettre en Cache les Résultats2. Gérer les Erreurs Avec ÉléganceProchaines Étapes