Email verification in Laravel

<?php
// app/Rules/DeliverableEmail.php
namespace App\Rules;

use Closure;
use Illuminate\Contracts\Validation\ValidationRule;
use Illuminate\Http\Client\ConnectionException;
use Illuminate\Support\Facades\Http;

class DeliverableEmail implements ValidationRule
{
    public function validate(string $attribute, mixed $value, Closure $fail): void
    {
        try {
            $response = Http::withHeaders(['X-API-Key' => config('services.zapbounce.key')])
                ->timeout(3)                    // a person is waiting on this form
                ->retry(1, 200, throw: false)
                ->post('https://app.zapbounce.com/api/v1/verify', ['emails' => [$value]]);
        } catch (ConnectionException) {
            return;   // fail open on a timeout. A slow verifier must not cost you a registration.
        }

        if ($response->failed()) {
            return;   // fail open here too
        }

        // Only block on a definite rejection. catch_all and unknown are not rejections.
        // disposable is an entry in the flags array beside the status, so it is checked separately.
        $result = $response->json('results.0');
        if ($result['status'] === 'invalid' || in_array('disposable', $result['flags'], true)) {
            $fail('That address will not receive mail. Check it for a typo.');
        }
    }
}

// app/Http/Requests/RegisterRequest.php
public function rules(): array
{
    return ['email' => ['required', 'email:rfc,dns', new DeliverableEmail]];
}

<?php
// app/Jobs/VerifyContactList.php
namespace App\Jobs;

class VerifyContactList implements ShouldQueue
{
    use Queueable;

    public int $tries = 3;
    public array $backoff = [30, 120, 600];

    public function __construct(public int $listId) {}

    public function handle(): void
    {
        $emails = Contact::where('list_id', $this->listId)
            ->whereNull('email_result')
            ->pluck('email')
            ->all();

        $job = Http::withHeaders([
                'X-API-Key'       => config('services.zapbounce.key'),
                'Idempotency-Key' => "list-{$this->listId}",
            ])
            ->post('https://app.zapbounce.com/api/v1/jobs', [
                'emails' => $emails,        // up to 50,000 per job
                'source' => 'api',
            ])
            ->throw()
            ->json();

        ContactList::whereKey($this->listId)->update(['job_id' => $job['id']]);

        // No webhook exists. A second queued job polls and releases itself until done.
        CollectJobResults::dispatch($this->listId, $job['id'])->delay(30);
    }
}

// app/Jobs/CollectJobResults.php
class CollectJobResults implements ShouldQueue
{
    use Queueable;

    public function __construct(public int $listId, public string $jobId) {}

    public function handle(): void
    {
        $http = Http::withHeaders(['X-API-Key' => config('services.zapbounce.key')])
            ->baseUrl('https://app.zapbounce.com/api/v1');

        $job = $http->get("jobs/{$this->jobId}")->throw()->json();

        if (! in_array($job['status'], ['completed', 'partial', 'failed', 'cancelled'], true)) {
            $this->release(30);   // back on the queue, try again in 30 seconds
            return;
        }

        $page = 1;
        do {
            $body = $http->get("jobs/{$this->jobId}/emails", ['page' => $page, 'pageSize' => 100])
                ->throw()->json();

            foreach ($body['items'] as $row) {
                Contact::where('email', $row['email'])->update(['email_result' => $row['status']]);
            }
        } while ($page++ < $body['meta']['totalPages']);
    }
}

<?php
use Illuminate\Http\Client\ConnectionException;
use Illuminate\Http\Client\RequestException;

function zapbounceVerify(string $email): array
{
    try {
        $response = Http::withHeaders(['X-API-Key' => config('services.zapbounce.key')])
            ->timeout(10)
            ->retry(
                5,
                // There is no Retry-After header. A 429 waits on X-RateLimit-Window-Seconds.
                fn (int $attempt, \Exception $e) => $e instanceof RequestException && $e->response->status() === 429
                    ? max(1, (int) $e->response->header('X-RateLimit-Window-Seconds')) * 1000 * $attempt
                    : (2 ** $attempt) * 250,
                // Retry 429 and 5xx. Never retry CREDITS_INSUFFICIENT (422): it fails the same way forever.
                fn (\Exception $e) => $e instanceof ConnectionException
                    || ($e instanceof RequestException && in_array($e->response->status(), [429, 500, 502, 503, 504])),
                throw: false,
            )
            ->post('https://app.zapbounce.com/api/v1/verify', ['emails' => [$email]]);
    } catch (ConnectionException) {
        // A timeout is not a bad address. Fail open.
        return ['email' => $email, 'status' => 'unknown', 'reasonCode' => 'TIMEOUT', 'flags' => []];
    }

    if ($response->failed()) {
        // { statusCode, code, message, requestId }. Log requestId: it makes a support thread a quick lookup.
        Log::warning('zapbounce failed', $response->json());

        if ($response->json('code') === 'CREDITS_INSUFFICIENT') {
            throw new OutOfCredits($response->json('message'));
        }
        $response->throw();
    }

    return $response->json('results.0');
}