WordPress

Email checker for WordPress. Contact Form 7, WPForms, and custom PHP integration.

Ajoutez la vérification d'emails en temps réel à votre site WordPress. Validez les emails dans les formulaires de contact, l'inscription et le paiement WooCommerce.

Méthodes d'intégration

Méthode	Idéal pour	Complexité
Plugin	Configuration rapide	Faible
Contact Form 7	Utilisateurs CF7	Faible
WPForms	Utilisateurs WPForms	Faible
PHP personnalisé	Contrôle total	Moyenne

Méthode 1 : Plugin EmailVerify

Installez notre plugin WordPress officiel pour l'intégration la plus simple.

Installation

Allez dans Extensions → Ajouter
Recherchez "EmailVerify Email Verification"
Cliquez sur Installer maintenant puis Activer
Allez dans Réglages → EmailVerify
Entrez votre clé API

Configuration

// wp-config.php (optionnel)
define('EMAILVERIFY_API_KEY', 'bv_live_xxx');

Fonctionnalités

Vérification en temps réel sur tous les formulaires
Blocage des emails jetables
Blocage des emails génériques
Messages d'erreur personnalisables
Intégration WooCommerce
Validation AJAX

Méthode 2 : Contact Form 7

Ajoutez la vérification aux formulaires Contact Form 7.

Utilisation des hooks

// functions.php
add_filter('wpcf7_validate_email*', 'emailverify_cf7_validation', 20, 2);

function emailverify_cf7_validation($result, $tag) {
    $email = isset($_POST[$tag->name]) ? sanitize_email($_POST[$tag->name]) : '';

    if (empty($email)) {
        return $result;
    }

    $verification = emailverify_check_email($email);

    if ($verification['status'] === 'invalid') {
        $result->invalidate($tag, 'Veuillez entrer une adresse email valide.');
    }

    if ($verification['result']['disposable']) {
        $result->invalidate($tag, 'Les emails jetables ne sont pas autorisés.');
    }

    return $result;
}

function emailverify_check_email($email) {
    $api_key = defined('EMAILVERIFY_API_KEY')
        ? EMAILVERIFY_API_KEY
        : get_option('emailverify_api_key');

    $response = wp_remote_post('https://api.emailverify.ai/v1/verify', [
        'headers' => [
            'Authorization' => 'Bearer ' . $api_key,
            'Content-Type' => 'application/json',
        ],
        'body' => json_encode(['email' => $email]),
        'timeout' => 10,
    ]);

    if (is_wp_error($response)) {
        return ['status' => 'unknown'];
    }

    return json_decode(wp_remote_retrieve_body($response), true);
}

Configuration des balises de formulaire

[email* your-email class:emailverify-email]

Méthode 3 : WPForms

Intégrez avec WPForms en utilisant la validation personnalisée.

Validation PHP

// functions.php
add_filter('wpforms_process_before_form_data', 'emailverify_wpforms_validation', 10, 2);

function emailverify_wpforms_validation($form_data, $entry) {
    foreach ($entry['fields'] as $field_id => $value) {
        $field = $form_data['fields'][$field_id] ?? null;

        if ($field && $field['type'] === 'email' && !empty($value)) {
            $verification = emailverify_check_email($value);

            if ($verification['status'] === 'invalid') {
                wpforms()->process->errors[$form_data['id']][$field_id] =
                    'Veuillez entrer une adresse email valide.';
            }

            if ($verification['result']['disposable'] ?? false) {
                wpforms()->process->errors[$form_data['id']][$field_id] =
                    'Les emails jetables ne sont pas autorisés.';
            }
        }
    }

    return $form_data;
}

Méthode 4 : Intégration PHP personnalisée

Pour un contrôle complet, intégrez directement avec notre API.

Classe d'assistance

<?php
// includes/class-emailverify.php

class EmailVerify {
    private $api_key;
    private $api_url = 'https://api.emailverify.ai/v1';

    public function __construct($api_key = null) {
        $this->api_key = $api_key ?: get_option('emailverify_api_key');
    }

    public function verify($email) {
        $response = wp_remote_post($this->api_url . '/verify', [
            'headers' => [
                'Authorization' => 'Bearer ' . $this->api_key,
                'Content-Type' => 'application/json',
            ],
            'body' => json_encode(['email' => $email]),
            'timeout' => 10,
        ]);

        if (is_wp_error($response)) {
            return [
                'success' => false,
                'error' => $response->get_error_message(),
            ];
        }

        $body = json_decode(wp_remote_retrieve_body($response), true);
        return [
            'success' => true,
            'data' => $body,
        ];
    }

    public function is_valid($email) {
        $result = $this->verify($email);
        return $result['success'] && $result['data']['status'] === 'valid';
    }

    public function is_disposable($email) {
        $result = $this->verify($email);
        return $result['success'] && ($result['data']['result']['disposable'] ?? false);
    }
}

Utilisation

$bv = new EmailVerify();

// Vérification de base
$result = $bv->verify('user@example.com');

if ($result['data']['status'] === 'valid') {
    // L'email est valide
}

// Vérifications rapides
if ($bv->is_valid('user@example.com')) {
    // Traiter l'email valide
}

if ($bv->is_disposable('user@example.com')) {
    // Bloquer l'email jetable
}

Inscription WordPress

Vérifiez les emails lors de l'inscription des utilisateurs.

// functions.php
add_filter('registration_errors', 'emailverify_registration_check', 10, 3);

function emailverify_registration_check($errors, $sanitized_user_login, $user_email) {
    $bv = new EmailVerify();
    $result = $bv->verify($user_email);

    if (!$result['success']) {
        return $errors; // Autoriser l'inscription si l'API échoue
    }

    $data = $result['data'];

    if ($data['status'] === 'invalid') {
        $errors->add('invalid_email',
            '<strong>Erreur</strong> : Veuillez entrer une adresse email valide.');
    }

    if ($data['result']['disposable'] ?? false) {
        $errors->add('disposable_email',
            '<strong>Erreur</strong> : Les adresses email temporaires ne sont pas autorisées.');
    }

    return $errors;
}

Validation AJAX

Ajoutez la validation en temps réel avec JavaScript.

Point de terminaison PHP

// functions.php
add_action('wp_ajax_verify_email', 'emailverify_ajax_verify');
add_action('wp_ajax_nopriv_verify_email', 'emailverify_ajax_verify');

function emailverify_ajax_verify() {
    check_ajax_referer('emailverify_nonce', 'nonce');

    $email = sanitize_email($_POST['email'] ?? '');

    if (empty($email)) {
        wp_send_json_error(['message' => 'L\'email est requis']);
    }

    $bv = new EmailVerify();
    $result = $bv->verify($email);

    if ($result['success']) {
        wp_send_json_success($result['data']);
    } else {
        wp_send_json_error(['message' => 'La vérification a échoué']);
    }
}

// Mettre en file d'attente les scripts
add_action('wp_enqueue_scripts', 'emailverify_enqueue_scripts');

function emailverify_enqueue_scripts() {
    wp_enqueue_script('emailverify',
        get_template_directory_uri() . '/js/emailverify.js',
        ['jquery'],
        '1.0.0',
        true
    );

    wp_localize_script('emailverify', 'emailverify_ajax', [
        'url' => admin_url('admin-ajax.php'),
        'nonce' => wp_create_nonce('emailverify_nonce'),
    ]);
}

JavaScript

// js/emailverify.js
jQuery(function($) {
    $('input[type="email"]').on('blur', function() {
        var $input = $(this);
        var email = $input.val();

        if (!email) return;

        $input.addClass('verifying');

        $.post(emailverify_ajax.url, {
            action: 'verify_email',
            nonce: emailverify_ajax.nonce,
            email: email
        })
        .done(function(response) {
            $input.removeClass('verifying');

            if (response.success) {
                var data = response.data;

                if (data.status === 'invalid') {
                    showError($input, 'Veuillez entrer un email valide');
                } else if (data.result && data.result.disposable) {
                    showError($input, 'Les emails jetables ne sont pas autorisés');
                } else {
                    showSuccess($input);
                }
            }
        })
        .fail(function() {
            $input.removeClass('verifying');
        });
    });

    function showError($input, message) {
        $input.addClass('error').removeClass('valid');
        $input.next('.bv-message').remove();
        $input.after('<span class="bv-message error">' + message + '</span>');
    }

    function showSuccess($input) {
        $input.addClass('valid').removeClass('error');
        $input.next('.bv-message').remove();
        $input.after('<span class="bv-message valid">✓</span>');
    }
});

CSS

/* style.css */
input[type="email"].verifying {
    background-image: url('spinner.gif');
    background-position: right 10px center;
    background-repeat: no-repeat;
}

input[type="email"].error {
    border-color: #dc3545;
}

input[type="email"].valid {
    border-color: #28a745;
}

.bv-message {
    display: block;
    font-size: 12px;
    margin-top: 4px;
}

.bv-message.error {
    color: #dc3545;
}

.bv-message.valid {
    color: #28a745;
}

Mise en cache

Mettez en cache les résultats de vérification pour réduire les appels API.

function emailverify_check_email_cached($email) {
    $cache_key = 'bv_email_' . md5($email);
    $cached = get_transient($cache_key);

    if ($cached !== false) {
        return $cached;
    }

    $result = emailverify_check_email($email);

    // Mettre en cache pendant 24 heures
    set_transient($cache_key, $result, DAY_IN_SECONDS);

    return $result;
}

Bonnes pratiques

1. Dégradation gracieuse

Autorisez toujours la soumission du formulaire si l'API échoue :

$result = $bv->verify($email);

if (!$result['success']) {
    // Enregistrer l'erreur mais ne pas bloquer l'utilisateur
    error_log('Erreur API EmailVerify : ' . $result['error']);
    return; // Autoriser la soumission
}

2. Limitation du débit

Empêchez les abus avec la limitation du débit :

function emailverify_rate_limit($email) {
    $ip = $_SERVER['REMOTE_ADDR'];
    $key = 'bv_rate_' . md5($ip);
    $count = get_transient($key) ?: 0;

    if ($count >= 10) { // 10 vérifications par minute
        return false;
    }

    set_transient($key, $count + 1, MINUTE_IN_SECONDS);
    return true;
}

3. Sécurité

Assainissez et validez toujours les entrées :

$email = sanitize_email($_POST['email']);

if (!is_email($email)) {
    // Format invalide, pas besoin d'appeler l'API
    return;
}

Ressources associées

Intégration WooCommerce

Vérification d'emails e-commerce

SDK PHP

Bibliothèque PHP officielle

Référence API

Documentation API complète

WordPress

Intégration WooCommerce

SDK PHP

Référence API

On this page