Verifica delle email in Shopify

Shopify non espone un hook precedente alla registrazione nel negozio, ma puoi verificare le email con due approcci complementari:

App Proxy — un endpoint sul tuo server chiamato dal JavaScript del tuo negozio prima dell'invio del modulo di registrazione
Webhook customers/create — un webhook che scatta dopo la creazione del cliente e ti permette di etichettare o marcare gli account non validi

Questo tutorial copre entrambi i modelli.

Prerequisiti

Un negozio Shopify e un account Partner
Un'applicazione in Node.js (Express o simili) pubblicata su un indirizzo pubblico
Una chiave API di Mailbeam (iscriviti gratis)

Opzione A — App Proxy (in tempo reale, prima della registrazione)

Un App Proxy instrada le richieste da {tuo-negozio}.myshopify.com/apps/verify-email al tuo server.

Configura l'App Proxy

Nelle impostazioni della tua app di Shopify Partner → App proxy:

Subpath: apps
Subpath prefix: verify-email
Proxy URL: https://tuo-server.com/api/verify-email

L'endpoint del proxy

// server/routes/shopifyVerify.js
import express from "express";
// Non ci sono ancora SDK: questo è il wrapper di 12 righe di /docs/quickstart.
import { verifyEmail } from "./lib/mailbeam";

const router = express.Router();

router.post("/api/verify-email", async (req, res) => {
  const { email } = req.body;

  if (!email) {
    return res.json({ valid: false, error: "L'email è obbligatoria." });
  }

  try {
    const { valid, score, reason } = await verifyEmail(email);

    if (!valid || score < 60) {
      const message =
        reason === "disposable_domain"
          ? "Usa un indirizzo email permanente."
          : "Inserisci un indirizzo email valido.";
      return res.json({ valid: false, error: message });
    }

    res.json({ valid: true });
  } catch {
    // Lascia passare: non bloccare la registrazione
    res.json({ valid: true });
  }
});

export default router;

JavaScript nel negozio

Aggiungi questo al modello di registrazione del tuo tema Shopify:

// assets/mailbeam-verify.js
(function () {
  const form = document.querySelector('form[action="/account"]');
  const emailInput = document.querySelector('input[name="customer[email]"]');

  if (!form || !emailInput) return;

  form.addEventListener('submit', async function (event) {
    // Intercetta solo i moduli di registrazione
    const actionInput = form.querySelector('input[name="form_type"]');
    if (!actionInput || actionInput.value !== 'create_customer') return;

    event.preventDefault();

    const email = emailInput.value.trim();

    try {
      const res = await fetch('/apps/verify-email', {
        method: 'POST',
        headers: { 'Content-Type': 'application/json' },
        body: JSON.stringify({ email }),
      });

      const { valid, error } = await res.json();

      if (!valid) {
        showError(emailInput, error || 'Usa un indirizzo email valido.');
        return;
      }
    } catch {
      // Lascia passare in caso di errori di rete
    }

    form.submit();
  });

  function showError(input, message) {
    let errorEl = document.getElementById('mailbeam-email-error');
    if (!errorEl) {
      errorEl = document.createElement('p');
      errorEl.id = 'mailbeam-email-error';
      errorEl.style.cssText = 'color: red; font-size: 0.875rem; margin-top: 0.25rem;';
      input.parentNode.insertBefore(errorEl, input.nextSibling);
    }
    errorEl.textContent = message;
    input.focus();
  }
})();

Opzione B — webhook customers/create (dopo la registrazione)

Questo modello gira dopo che Shopify ha creato il cliente. È utile per etichettare gli account sospetti:

// server/routes/shopifyWebhook.js
import crypto from "crypto";
// Non ci sono ancora SDK: questo è il wrapper di 12 righe di /docs/quickstart.
import { verifyEmail } from "./lib/mailbeam";

router.post("/webhooks/customers/create", express.raw({ type: "application/json" }), async (req, res) => {
  // Verifica la firma del webhook
  const hmac = req.headers["x-shopify-hmac-sha256"];
  const hash = crypto
    .createHmac("sha256", process.env.SHOPIFY_WEBHOOK_SECRET)
    .update(req.body)
    .digest("base64");

  if (hmac !== hash) {
    return res.status(401).send("Unauthorized");
  }

  const customer = JSON.parse(req.body.toString());
  const { email, id: customerId } = customer;

  try {
    const { valid, score } = await verifyEmail(email);

    if (!valid || score < 40) {
      // Etichetta il cliente per una revisione
      await tagShopifyCustomer(customerId, ["suspicious-email", "requires-review"]);
    }
  } catch {
    // Registra l'errore ma non far fallire il webhook
    console.error("[Mailbeam] errore di verifica");
  }

  res.status(200).send("OK");
});

Buone pratiche

Usa l'App Proxy per la prevenzione in tempo reale e il webhook per l'audit
Restituisci sempre { valid: true } nei blocchi catch: lascia passare
La verifica HMAC di Shopify è obbligatoria sui webhook (buona pratica di sicurezza)