EmailVerify LogoEmailVerify
Guias de IntegraçãoE-commerce

WooCommerce

Email checker for WooCommerce. Verify emails at checkout and in WordPress forms.

Adicione verificação de e-mail à sua loja WooCommerce para reduzir falhas na entrega, prevenir fraude e melhorar a comunicação com o cliente.

Métodos de Integração

MétodoMelhor ParaComplexidade
PluginConfiguração rápidaBaixa
Checkout HookVerificação em tempo realMédia
Order ProcessingVerificação em segundo planoMédia
REST APISoluções personalizadasAlta

Método 1: Plugin WordPress

Se você já configurou o plugin EmailVerify WordPress, a integração com WooCommerce é automática.

Ativar Suporte ao WooCommerce

  1. Vá para Configurações → EmailVerify
  2. Marque Ativar Integração com WooCommerce
  3. Configure as opções:
    • ✓ Verificar no checkout
    • ✓ Bloquear e-mails descartáveis
    • ✓ Mostrar status de verificação nos pedidos

Método 2: Validação de Checkout

Adicione verificação de e-mail ao processo de checkout do WooCommerce.

Validação no Servidor

<?php
// functions.php ou plugin personalizado

/**
 * Verifique e-mail no checkout do WooCommerce
 */
add_action('woocommerce_checkout_process', 'emailverify_checkout_validation');

function emailverify_checkout_validation() {
    $email = sanitize_email($_POST['billing_email']);

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

    $result = emailverify_verify_email($email);

    if (!$result['success']) {
        // Erro de API - permitir que o checkout continue
        return;
    }

    $data = $result['data'];

    // Bloquear e-mails inválidos
    if ($data['status'] === 'invalid') {
        wc_add_notice(
            __('Digite um endereço de e-mail válido para concluir seu pedido.', 'your-theme'),
            'error'
        );
    }

    // Bloquear e-mails descartáveis (opcional)
    if (get_option('emailverify_block_disposable', true)) {
        if ($data['result']['disposable'] ?? false) {
            wc_add_notice(
                __('Endereços de e-mail temporários não são aceitos. Use um e-mail permanente.', 'your-theme'),
                'error'
            );
        }
    }
}

/**
 * Auxiliar de chamada da API do EmailVerify
 */
function emailverify_verify_email($email) {
    $api_key = get_option('emailverify_api_key');

    // Verificar cache primeiro
    $cache_key = 'bv_email_' . md5($email);
    $cached = get_transient($cache_key);

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

    $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 ['success' => false, 'error' => $response->get_error_message()];
    }

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

    // Armazenar em cache por 24 horas
    set_transient($cache_key, $result, DAY_IN_SECONDS);

    return $result;
}

Validação AJAX em Tempo Real

Adicione feedback instantâneo conforme os clientes digitam seu e-mail.

<?php
// Enfileirar scripts
add_action('wp_enqueue_scripts', 'emailverify_wc_scripts');

function emailverify_wc_scripts() {
    if (!is_checkout()) {
        return;
    }

    wp_enqueue_script(
        'emailverify-checkout',
        get_template_directory_uri() . '/js/emailverify-checkout.js',
        ['jquery'],
        '1.0.0',
        true
    );

    wp_localize_script('emailverify-checkout', 'bv_checkout', [
        'ajax_url' => admin_url('admin-ajax.php'),
        'nonce' => wp_create_nonce('emailverify_checkout'),
    ]);
}

// Handler AJAX
add_action('wp_ajax_verify_checkout_email', 'emailverify_ajax_checkout_verify');
add_action('wp_ajax_nopriv_verify_checkout_email', 'emailverify_ajax_checkout_verify');

function emailverify_ajax_checkout_verify() {
    check_ajax_referer('emailverify_checkout', 'nonce');

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

    if (empty($email)) {
        wp_send_json_error(['message' => 'E-mail é obrigatório']);
    }

    $result = emailverify_verify_email($email);

    if ($result['success']) {
        wp_send_json_success($result['data']);
    } else {
        wp_send_json_error(['message' => 'Verificação falhou']);
    }
}
// js/emailverify-checkout.js
jQuery(function($) {
    var $billingEmail = $('#billing_email');
    var verifyTimeout;
    var $status = $('<span class="bv-status"></span>');

    $billingEmail.after($status);

    $billingEmail.on('blur change', function() {
        var email = $(this).val();

        if (!email || !isValidEmailFormat(email)) {
            $status.html('').removeClass('valid invalid verifying');
            return;
        }

        clearTimeout(verifyTimeout);

        verifyTimeout = setTimeout(function() {
            verifyEmail(email);
        }, 500);
    });

    function verifyEmail(email) {
        $status.html('<span class="spinner"></span> Verificando...').addClass('verifying');

        $.ajax({
            url: bv_checkout.ajax_url,
            method: 'POST',
            data: {
                action: 'verify_checkout_email',
                nonce: bv_checkout.nonce,
                email: email
            },
            success: function(response) {
                $status.removeClass('verifying');

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

                    if (data.status === 'valid') {
                        $status
                            .html('<span class="dashicons dashicons-yes"></span> E-mail verificado')
                            .addClass('valid')
                            .removeClass('invalid');
                    } else if (data.status === 'invalid') {
                        $status
                            .html('<span class="dashicons dashicons-no"></span> Digite um endereço de e-mail válido')
                            .addClass('invalid')
                            .removeClass('valid');
                    } else if (data.result && data.result.disposable) {
                        $status
                            .html('<span class="dashicons dashicons-warning"></span> Use um e-mail permanente')
                            .addClass('invalid')
                            .removeClass('valid');
                    }
                }
            },
            error: function() {
                $status.html('').removeClass('verifying valid invalid');
            }
        });
    }

    function isValidEmailFormat(email) {
        return /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(email);
    }
});
/* style.css */
.bv-status {
    display: block;
    margin-top: 5px;
    font-size: 13px;
}

.bv-status.verifying {
    color: #666;
}

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

.bv-status.invalid {
    color: #dc3545;
}

.bv-status .spinner {
    display: inline-block;
    width: 12px;
    height: 12px;
    border: 2px solid #ccc;
    border-top-color: #333;
    border-radius: 50%;
    animation: spin 1s linear infinite;
}

@keyframes spin {
    to { transform: rotate(360deg); }
}

Método 3: Processamento de Pedidos

Verifique e-mails após a colocação do pedido e armazene os resultados.

Salvar Dados de Verificação

<?php
/**
 * Verifique e-mail após a criação do pedido
 */
add_action('woocommerce_checkout_order_created', 'emailverify_verify_order_email');

function emailverify_verify_order_email($order) {
    $email = $order->get_billing_email();

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

    $result = emailverify_verify_email($email);

    if ($result['success']) {
        $data = $result['data'];

        // Armazenar dados de verificação como metadados do pedido
        $order->update_meta_data('_email_verification_status', $data['status']);
        $order->update_meta_data('_email_verification_score', $data['score'] ?? '');
        $order->update_meta_data('_email_is_disposable', $data['result']['disposable'] ? 'yes' : 'no');
        $order->update_meta_data('_email_verified_at', current_time('mysql'));
        $order->save();

        // Adicionar nota do pedido
        if ($data['status'] === 'invalid') {
            $order->add_order_note(
                sprintf(
                    __('Aviso: O e-mail do cliente %s falhou na verificação (Status: %s)', 'your-theme'),
                    $email,
                    $data['status']
                )
            );
        }
    }
}

/**
 * Exibir status de verificação nos detalhes do pedido
 */
add_action('woocommerce_admin_order_data_after_billing_address', 'emailverify_show_order_email_status');

function emailverify_show_order_email_status($order) {
    $status = $order->get_meta('_email_verification_status');

    if (empty($status)) {
        return;
    }

    $score = $order->get_meta('_email_verification_score');
    $disposable = $order->get_meta('_email_is_disposable');

    $status_class = $status === 'valid' ? 'status-completed' : 'status-on-hold';

    echo '<div class="email-verification-status">';
    echo '<h3>' . __('Verificação de E-mail', 'your-theme') . '</h3>';
    echo '<p><strong>' . __('Status:', 'your-theme') . '</strong> ';
    echo '<mark class="order-status ' . esc_attr($status_class) . '">' . esc_html(ucfirst($status)) . '</mark></p>';

    if ($score) {
        echo '<p><strong>' . __('Pontuação:', 'your-theme') . '</strong> ' . esc_html($score) . '</p>';
    }

    if ($disposable === 'yes') {
        echo '<p><span class="dashicons dashicons-warning" style="color: #d63638;"></span> ';
        echo __('E-mail descartável detectado', 'your-theme') . '</p>';
    }

    echo '</div>';
}

Adicionar Coluna da Lista de Pedidos

<?php
/**
 * Adicionar coluna de status de e-mail à lista de pedidos
 */
add_filter('manage_edit-shop_order_columns', 'emailverify_orders_column');

function emailverify_orders_column($columns) {
    $new_columns = [];

    foreach ($columns as $key => $value) {
        $new_columns[$key] = $value;

        if ($key === 'order_status') {
            $new_columns['email_status'] = __('E-mail', 'your-theme');
        }
    }

    return $new_columns;
}

add_action('manage_shop_order_posts_custom_column', 'emailverify_orders_column_content', 10, 2);

function emailverify_orders_column_content($column, $post_id) {
    if ($column !== 'email_status') {
        return;
    }

    $order = wc_get_order($post_id);
    $status = $order->get_meta('_email_verification_status');

    if (empty($status)) {
        echo '<span class="dashicons dashicons-minus" title="Não verificado"></span>';
        return;
    }

    if ($status === 'valid') {
        echo '<span class="dashicons dashicons-yes-alt" style="color: #28a745;" title="Válido"></span>';
    } else {
        echo '<span class="dashicons dashicons-dismiss" style="color: #dc3545;" title="Inválido"></span>';
    }

    $disposable = $order->get_meta('_email_is_disposable');
    if ($disposable === 'yes') {
        echo '<span class="dashicons dashicons-warning" style="color: #d63638;" title="Descartável"></span>';
    }
}

Método 4: Integração da API REST

Para WooCommerce headless ou fluxos de checkout personalizados.

Endpoint REST Personalizado

<?php
/**
 * Registrar endpoint da API REST para verificação de e-mail
 */
add_action('rest_api_init', 'emailverify_register_wc_endpoint');

function emailverify_register_wc_endpoint() {
    register_rest_route('emailverify/v1', '/verify-checkout', [
        'methods' => 'POST',
        'callback' => 'emailverify_rest_verify_checkout',
        'permission_callback' => '__return_true',
        'args' => [
            'email' => [
                'required' => true,
                'type' => 'string',
                'format' => 'email',
                'sanitize_callback' => 'sanitize_email',
            ],
        ],
    ]);
}

function emailverify_rest_verify_checkout($request) {
    $email = $request->get_param('email');

    // Limite de taxa
    $ip = $_SERVER['REMOTE_ADDR'];
    $rate_key = 'bv_rate_' . md5($ip);
    $rate_count = get_transient($rate_key) ?: 0;

    if ($rate_count >= 20) {
        return new WP_Error(
            'rate_limited',
            'Muitas solicitações de verificação',
            ['status' => 429]
        );
    }

    set_transient($rate_key, $rate_count + 1, MINUTE_IN_SECONDS);

    // Verificar e-mail
    $result = emailverify_verify_email($email);

    if (!$result['success']) {
        return new WP_Error(
            'verification_failed',
            'Falha na verificação de e-mail',
            ['status' => 503]
        );
    }

    $data = $result['data'];

    return new WP_REST_Response([
        'valid' => $data['status'] === 'valid',
        'status' => $data['status'],
        'disposable' => $data['result']['disposable'] ?? false,
        'score' => $data['score'] ?? null,
    ], 200);
}

Uso no Frontend

// Verificação de checkout headless
async function verifyCheckoutEmail(email) {
    const response = await fetch('/wp-json/emailverify/v1/verify-checkout', {
        method: 'POST',
        headers: {
            'Content-Type': 'application/json',
        },
        body: JSON.stringify({ email }),
    });

    if (!response.ok) {
        if (response.status === 429) {
            throw new Error('Muitas solicitações. Aguarde.');
        }
        throw new Error('Verificação falhou');
    }

    return response.json();
}

// Uso
try {
    const result = await verifyCheckoutEmail('customer@example.com');

    if (!result.valid) {
        showError('Digite um endereço de e-mail válido');
    } else if (result.disposable) {
        showError('Use um endereço de e-mail permanente');
    } else {
        proceedToPayment();
    }
} catch (error) {
    // Permitir checkout em caso de erro
    proceedToPayment();
}

Verificação em Lote de Clientes

Verifique clientes existentes em seu banco de dados.

Comando WP-CLI

<?php
/**
 * Comando WP-CLI para verificação em lote de clientes
 */
if (defined('WP_CLI') && WP_CLI) {
    WP_CLI::add_command('emailverify verify-customers', function($args, $assoc_args) {
        $batch_size = $assoc_args['batch'] ?? 100;
        $dry_run = isset($assoc_args['dry-run']);

        global $wpdb;

        // Obter clientes sem status de verificação
        $customers = $wpdb->get_results("
            SELECT DISTINCT pm.meta_value as email, pm.post_id as order_id
            FROM {$wpdb->postmeta} pm
            LEFT JOIN {$wpdb->postmeta} pm2 ON pm.post_id = pm2.post_id
                AND pm2.meta_key = '_email_verification_status'
            WHERE pm.meta_key = '_billing_email'
            AND pm.meta_value != ''
            AND pm2.meta_id IS NULL
            LIMIT {$batch_size}
        ");

        if (empty($customers)) {
            WP_CLI::success('Todos os clientes foram verificados!');
            return;
        }

        WP_CLI::log(sprintf('Encontrados %d clientes para verificar', count($customers)));

        $progress = \WP_CLI\Utils\make_progress_bar('Verificando', count($customers));

        $stats = ['valid' => 0, 'invalid' => 0, 'error' => 0];

        foreach ($customers as $customer) {
            $result = emailverify_verify_email($customer->email);

            if ($result['success']) {
                $status = $result['data']['status'];
                $stats[$status === 'valid' ? 'valid' : 'invalid']++;

                if (!$dry_run) {
                    update_post_meta($customer->order_id, '_email_verification_status', $result['data']['status']);
                    update_post_meta($customer->order_id, '_email_verification_score', $result['data']['score'] ?? '');
                }
            } else {
                $stats['error']++;
            }

            $progress->tick();

            // Limite de taxa
            usleep(100000); // atraso de 100ms
        }

        $progress->finish();

        WP_CLI::success(sprintf(
            'Verificação completa: %d válidos, %d inválidos, %d erros',
            $stats['valid'],
            $stats['invalid'],
            $stats['error']
        ));
    });
}

Uso

# Verificar 100 clientes (padrão)
wp emailverify verify-customers

# Verificar 500 clientes
wp emailverify verify-customers --batch=500

# Execução seca (sem alterações no banco de dados)
wp emailverify verify-customers --dry-run

Prevenção de Fraude

Use verificação de e-mail como parte da detecção de fraude.

<?php
/**
 * Sinalizar pedidos de alto risco com base na verificação de e-mail
 */
add_action('woocommerce_checkout_order_processed', 'emailverify_fraud_check', 10, 3);

function emailverify_fraud_check($order_id, $posted_data, $order) {
    $risk_score = 0;
    $risk_reasons = [];

    $email = $order->get_billing_email();
    $result = emailverify_verify_email($email);

    if ($result['success']) {
        $data = $result['data'];

        // E-mail inválido = alto risco
        if ($data['status'] === 'invalid') {
            $risk_score += 50;
            $risk_reasons[] = 'Endereço de e-mail inválido';
        }

        // E-mail descartável = alto risco
        if ($data['result']['disposable'] ?? false) {
            $risk_score += 40;
            $risk_reasons[] = 'E-mail descartável detectado';
        }

        // Pontuação baixa = risco médio
        if (($data['score'] ?? 1) < 0.5) {
            $risk_score += 20;
            $risk_reasons[] = 'Pontuação de e-mail baixa';
        }

        // E-mail baseado em função = risco leve
        if ($data['result']['role'] ?? false) {
            $risk_score += 10;
            $risk_reasons[] = 'Endereço de e-mail baseado em função';
        }
    }

    // Armazenar avaliação de risco
    $order->update_meta_data('_fraud_risk_score', $risk_score);
    $order->update_meta_data('_fraud_risk_reasons', $risk_reasons);

    // Sinalizar pedidos de alto risco para revisão manual
    if ($risk_score >= 50) {
        $order->set_status('on-hold', __('Alto risco de fraude - revisão manual necessária', 'your-theme'));

        // Notificar administrador
        $admin_email = get_option('admin_email');
        wp_mail(
            $admin_email,
            sprintf(__('Pedido de Alto Risco #%s Precisa de Revisão', 'your-theme'), $order_id),
            sprintf(
                __("O pedido #%s foi sinalizado como alto risco.\n\nPontuação de Risco: %d\nMotivos:\n- %s\n\nPor favor, revise o pedido.", 'your-theme'),
                $order_id,
                $risk_score,
                implode("\n- ", $risk_reasons)
            )
        );
    }

    $order->save();
}

Melhores Práticas

1. Degradação Graciosa

// Sempre permitir checkout se a API falhar
$result = emailverify_verify_email($email);

if (!$result['success']) {
    error_log('Erro na API EmailVerify: ' . ($result['error'] ?? 'Desconhecido'));
    return; // Não bloqueie o checkout
}

2. Armazene em Cache os Resultados

// Armazene em cache os resultados de verificação para reduzir chamadas de API
$cache_key = 'bv_email_' . md5($email);
$cached = get_transient($cache_key);

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

// ... fazer chamada de API ...

set_transient($cache_key, $result, DAY_IN_SECONDS);

3. Mensagens de Erro Claras

// Forneça mensagens de erro úteis e não técnicas
$messages = [
    'invalid' => __('Este endereço de e-mail parece ser inválido. Verifique e tente novamente.', 'your-theme'),
    'disposable' => __('Endereços de e-mail temporários não podem ser usados em pedidos. Use seu e-mail regular.', 'your-theme'),
];

Recursos Relacionados

Integração WordPress

Configuração geral do WordPress

Integração Shopify

Outra plataforma de e-commerce

Referência de API

Documentação completa da API

Shopify

Email checker for Shopify. Verify customer emails at checkout and in Shopify apps.

Magento

Email checker for Magento. Verify customer emails in Magento 2 checkout flow.

On this page

Métodos de IntegraçãoMétodo 1: Plugin WordPressAtivar Suporte ao WooCommerceMétodo 2: Validação de CheckoutValidação no ServidorValidação AJAX em Tempo RealMétodo 3: Processamento de PedidosSalvar Dados de VerificaçãoAdicionar Coluna da Lista de PedidosMétodo 4: Integração da API RESTEndpoint REST PersonalizadoUso no FrontendVerificação em Lote de ClientesComando WP-CLIUsoPrevenção de FraudeMelhores Práticas1. Degradação Graciosa2. Armazene em Cache os Resultados3. Mensagens de Erro ClarasRecursos Relacionados