EmailVerify LogoEmailVerify
SDKs

PHP SDK

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

Das offizielle EmailVerify SDK für PHP bietet eine benutzerfreundliche Schnittstelle für die E-Mail-Verifizierung mit Laravel-Unterstützung.

Installieren

composer require emailverify/php-sdk

Anforderungen

  • PHP 8.0 oder höher
  • Composer
  • JSON-Erweiterung
  • cURL-Erweiterung

Schnellstart

<?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";

Konfiguration

Client-Optionen

$client = new Client(
    apiKey: getenv('EMAILVERIFY_API_KEY'),
    options: [
        'timeout' => 30,           // Request-Timeout in Sekunden
        'retries' => 3,            // Anzahl der Wiederholungsversuche
        'base_url' => 'https://api.emailverify.ai',
    ]
);

Umgebungskonfiguration

# .env
EMAILVERIFY_API_KEY=your_api_key_here

Einzelverifizierung

Grundlegende Verifizierung

$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 ? 'Ja' : 'Nein') . "\n";
echo "Disposable: " . ($result->result->disposable ? 'Ja' : 'Nein') . "\n";

Verifizierung mit Optionen

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

Antwortstruktur

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;
}

Massenverifizierung

Auftrag einreichen

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

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

Status prüfen

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

echo "Status: " . $status->status . "\n";
echo "Fortschritt: " . $status->processed . "/" . $status->total . "\n";
echo "Gültig: " . $status->valid . "\n";
echo "Ungültig: " . $status->invalid . "\n";

Ergebnisse abrufen

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

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

Mit Webhook

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

Guthaben-Verwaltung

$credits = $client->getCredits();

echo "Verfügbar: " . $credits->available . "\n";
echo "Verbraucht: " . $credits->used . "\n";
echo "Gesamt: " . $credits->total . "\n";

Fehlerbehandlung

Ausnahmetypen

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 "Ungültiger API-Schlüssel\n";
} catch (RateLimitException $e) {
    echo "Rate-Limit erreicht. Wiederholen nach " . $e->getRetryAfter() . " Sekunden\n";
} catch (ValidationException $e) {
    echo "Ungültige Eingabe: " . $e->getMessage() . "\n";
} catch (EmailVerifyException $e) {
    echo "API-Fehler: " . $e->getMessage() . "\n";
}

Laravel-Integration

Service Provider

Das Paket wird in Laravel 5.5+ automatisch erkannt. Für ältere Versionen zu config/app.php hinzufügen:

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

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

Konfiguration

Konfigurationsdatei veröffentlichen:

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

Konfigurationsdatei (config/emailverify.php):

<?php

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

Facade verwenden

use EmailVerify\Laravel\Facades\EmailVerify;

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

// Massenverifizierung
$job = EmailVerify::verifyBulk($emails);

// Guthaben prüfen
$credits = EmailVerify::getCredits();

Dependency 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' => 'Ungültige E-Mail-Adresse']);
        }

        // Registrierung fortsetzen...
    }
}

Validierungsregel

use EmailVerify\Laravel\Rules\ValidEmail;

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

Benutzerdefinierte Regel mit Optionen:

use EmailVerify\Laravel\Rules\ValidEmail;

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

Form Request

<?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' => 'Bitte geben Sie eine gültige E-Mail-Adresse an.',
        ];
    }
}

Warteschlangen-Verifizierung

<?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' => 'Ungültige E-Mail-Adresse'
                ], 422);
            }

            if ($result->result->disposable) {
                return response()->json([
                    'error' => 'Wegwerf-E-Mails sind nicht erlaubt'
                ], 422);
            }
        }

        return $next($request);
    }
}

Vollständige Beispiele

Registrierungsvalidierung

<?php

use EmailVerify\Client;

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

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

        // Ungültige E-Mails ablehnen
        if ($result->status === 'invalid') {
            return [
                'valid' => false,
                'reason' => 'invalid_email',
                'message' => 'Diese E-Mail-Adresse ist ungültig',
            ];
        }

        // Wegwerf-E-Mails ablehnen
        if ($result->result->disposable) {
            return [
                'valid' => false,
                'reason' => 'disposable',
                'message' => 'Bitte verwenden Sie eine permanente E-Mail-Adresse',
            ];
        }

        // Warnung bei rollenbasierten E-Mails
        if ($result->result->role) {
            return [
                'valid' => true,
                'warning' => 'role_based',
                'message' => 'Die Verwendung einer persönlichen E-Mail wird empfohlen',
            ];
        }

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

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

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

Massenlistenbereinigung

<?php

use EmailVerify\Client;

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

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

        // Auf Abschluss warten
        while (true) {
            $status = $this->client->getBulkJobStatus($job->id);

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

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

            sleep(5);
        }

        // Ergebnisse abrufen und kategorisieren
        $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),
            ],
        ];
    }
}

API-Endpunkt

<?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' => 'Methode nicht erlaubt']);
    exit;
}

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

if (!$email) {
    http_response_code(400);
    echo json_encode(['error' => 'E-Mail ist erforderlich']);
    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' => 'Verifizierung fehlgeschlagen']);
}

Best Practices

1. Ergebnisse cachen

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. Fehler elegant behandeln

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

Nächste Schritte

API-Referenz

Detaillierte API-Dokumentation

Laravel-Integration

Erweiterte Laravel-Muster

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

InstallierenAnforderungenSchnellstartKonfigurationClient-OptionenUmgebungskonfigurationEinzelverifizierungGrundlegende VerifizierungVerifizierung mit OptionenAntwortstrukturMassenverifizierungAuftrag einreichenStatus prüfenErgebnisse abrufenMit WebhookGuthaben-VerwaltungFehlerbehandlungAusnahmetypenLaravel-IntegrationService ProviderKonfigurationFacade verwendenDependency InjectionValidierungsregelForm RequestWarteschlangen-VerifizierungMiddlewareVollständige BeispieleRegistrierungsvalidierungMassenlistenbereinigungAPI-EndpunktBest Practices1. Ergebnisse cachen2. Fehler elegant behandelnNächste Schritte