WordPress

Email checker for WordPress. Verify emails in contact forms, WooCommerce, and user registration.

Añade verificación de correo electrónico en tiempo real a tu sitio WordPress. Valida correos en formularios de contacto, registro y checkout de WooCommerce.

Métodos de Integración

Método	Mejor Para	Complejidad
Plugin	Configuración rápida	Baja
Contact Form 7	Usuarios de CF7	Baja
WPForms	Usuarios de WPForms	Baja
PHP Personalizado	Control total	Media

Método 1: Plugin de EmailVerify

Instala nuestro plugin oficial de WordPress para la integración más sencilla.

Instalación

Ve a Plugins → Añadir Nuevo
Busca "EmailVerify Email Verification"
Haz clic en Instalar Ahora y luego en Activar
Ve a Ajustes → EmailVerify
Introduce tu clave API

Configuración

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

Características

Verificación en tiempo real en todos los formularios
Bloquear correos desechables
Bloquear correos basados en roles
Mensajes de error personalizables
Integración con WooCommerce
Validación AJAX

Método 2: Contact Form 7

Añade verificación a los formularios de Contact Form 7.

Usando 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, 'Por favor introduce una dirección de correo válida.');
    }

    if ($verification['result']['disposable']) {
        $result->invalidate($tag, 'No se permiten correos desechables.');
    }

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

Configuración del Tag del Formulario

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

Método 3: WPForms

Integración con WPForms usando validación personalizada.

Validación 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] =
                    'Por favor introduce una dirección de correo válida.';
            }

            if ($verification['result']['disposable'] ?? false) {
                wpforms()->process->errors[$form_data['id']][$field_id] =
                    'No se permiten correos desechables.';
            }
        }
    }

    return $form_data;
}

Método 4: Integración PHP Personalizada

Para control completo, integra directamente con nuestra API.

Clase Helper

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

Uso

$bv = new EmailVerify();

// Verificación básica
$result = $bv->verify('user@example.com');

if ($result['data']['status'] === 'valid') {
    // El correo es válido
}

// Comprobaciones rápidas
if ($bv->is_valid('user@example.com')) {
    // Procesar correo válido
}

if ($bv->is_disposable('user@example.com')) {
    // Bloquear correo desechable
}

Registro de WordPress

Verifica correos durante el registro de usuarios.

// 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; // Permitir registro si la API falla
    }

    $data = $result['data'];

    if ($data['status'] === 'invalid') {
        $errors->add('invalid_email',
            '<strong>Error</strong>: Por favor introduce una dirección de correo válida.');
    }

    if ($data['result']['disposable'] ?? false) {
        $errors->add('disposable_email',
            '<strong>Error</strong>: No se permiten direcciones de correo temporales.');
    }

    return $errors;
}

Validación AJAX

Añade validación en tiempo real con JavaScript.

Endpoint 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' => 'El correo es requerido']);
    }

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

    if ($result['success']) {
        wp_send_json_success($result['data']);
    } else {
        wp_send_json_error(['message' => 'La verificación falló']);
    }
}

// Encolar 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, 'Por favor introduce un correo válido');
                } else if (data.result && data.result.disposable) {
                    showError($input, 'No se permiten correos desechables');
                } 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;
}

Almacenamiento en Caché

Almacena en caché los resultados de verificación para reducir las llamadas a la 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);

    // Almacenar en caché por 24 horas
    set_transient($cache_key, $result, DAY_IN_SECONDS);

    return $result;
}

Mejores Prácticas

1. Degradación Elegante

Siempre permite el envío del formulario si la API falla:

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

if (!$result['success']) {
    // Registrar el error pero no bloquear al usuario
    error_log('Error de API EmailVerify: ' . $result['error']);
    return; // Permitir envío
}

2. Limitación de Tasa

Previene abuso con limitación de tasa:

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

    if ($count >= 10) { // 10 verificaciones por minuto
        return false;
    }

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

3. Seguridad

Siempre sanitiza y valida las entradas:

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

if (!is_email($email)) {
    // Formato inválido, no es necesario llamar a la API
    return;
}

Recursos Relacionados

Integración con WooCommerce

Verificación de correo para e-commerce

SDK de PHP

Biblioteca oficial de PHP

Referencia de la API

Documentación completa de la API

WordPress

Integración con WooCommerce

SDK de PHP

Referencia de la API

On this page