Conecta tu ecommerce a Walletfy

Un plugin de una sola pieza. Se instala, se pega la API key en su pantalla de ajustes, y desde ese momento cada pedido marcado como Completado crea la tarjeta del cliente y le suma el sello.

Instalación

1. Descargá el plugin desde tu dashboard de Walletfy — Ajustes → API Keys → Descargar plugin de WooCommerce.
2. Subilo en WordPress Admin → Plugins → Añadir nuevo → Subir plugin, y activalo.
3. Andá a Ajustes → Walletfy y pegá tu API key.
4. Probá con un pedido marcado como completado.

<?php
/**
 * Plugin Name: Walletfy — Tarjetas de fidelidad
 * Description: Crea la tarjeta Wallet del cliente y suma sellos/puntos
 *              automáticamente cuando se completa un pedido en WooCommerce.
 */

if (!defined('ABSPATH')) exit;

define('WALLETFY_API_BASE', 'https://api.getwalletfy.com/public-api/v1');

function walletfy_api_request($endpoint, $body) {
    $api_key = get_option('walletfy_api_key');
    if (!$api_key) return null;

    $response = wp_remote_post(WALLETFY_API_BASE . $endpoint, [
        'headers' => [
            'Authorization' => 'Bearer ' . $api_key,
            'Content-Type'  => 'application/json',
        ],
        'body' => wp_json_encode($body),
        'timeout' => 10,
    ]);

    if (is_wp_error($response)) return null;
    return json_decode(wp_remote_retrieve_body($response), true);
}

// Al completar un pedido: crear cliente + sumar sello
add_action('woocommerce_order_status_completed', function ($order_id) {
    $order = wc_get_order($order_id);
    if (!$order) return;

    $email = $order->get_billing_email();
    $phone = $order->get_billing_phone();
    $name  = trim($order->get_billing_first_name() . ' ' . $order->get_billing_last_name());
    $total = (float) $order->get_total();

    if (!$email && !$phone) return;

    $customer = walletfy_api_request('/customers', [
        'name'  => $name ?: $email,
        'email' => $email ?: null,
        'phone' => $phone ?: null,
    ]);

    if (!$customer || empty($customer['customerId'])) return;

    walletfy_api_request('/stamps', [
        'customerId' => $customer['customerId'],
        'amount'     => $total,
    ]);
});

Shopify firma sus webhooks con HMAC pero no deja agregar un headerAuthorization personalizado en la configuración nativa — así que necesitás un pequeño servidor que reciba el webhook, verifique la firma, y recién ahí llame a Walletfy con tu API key.

const express = require("express");
const crypto = require("crypto");
const app = express();

const SHOPIFY_WEBHOOK_SECRET = process.env.SHOPIFY_WEBHOOK_SECRET;
const WALLETFY_API_KEY = process.env.WALLETFY_API_KEY;
const WALLETFY_API_BASE = "https://api.getwalletfy.com/public-api/v1";

function isValidShopifySignature(rawBody, hmacHeader) {
  if (!hmacHeader) return false;
  const digest = crypto
    .createHmac("sha256", SHOPIFY_WEBHOOK_SECRET)
    .update(rawBody)
    .digest("base64");
  return crypto.timingSafeEqual(Buffer.from(digest), Buffer.from(hmacHeader));
}

async function callWalletfy(endpoint, body) {
  const res = await fetch(`${WALLETFY_API_BASE}${endpoint}`, {
    method: "POST",
    headers: { Authorization: `Bearer ${WALLETFY_API_KEY}`, "Content-Type": "application/json" },
    body: JSON.stringify(body),
  });
  return res.json();
}

// Shopify firma el body CRUDO — se verifica ANTES de parsear el JSON
app.post(
  "/webhooks/shopify/orders-paid",
  express.raw({ type: "application/json" }),
  async (req, res) => {
    const hmacHeader = req.get("X-Shopify-Hmac-Sha256");
    if (!isValidShopifySignature(req.body, hmacHeader)) {
      return res.status(401).send("Invalid signature");
    }
    res.status(200).send("ok");

    const order = JSON.parse(req.body.toString("utf8"));
    const email = order.email || order.customer?.email;
    const name = [order.customer?.first_name, order.customer?.last_name].filter(Boolean).join(" ") || email;

    const customer = await callWalletfy("/customers", { name, email });
    if (!customer.customerId) return;

    await callWalletfy("/stamps", { customerId: customer.customerId, amount: parseFloat(order.total_price) });
  }
);

app.listen(process.env.PORT || 3001);

Si no querés mantener un servidor propio, mirá la opción de Zapier / Make más abajo — algunos planes de Shopify Flow también permiten un paso "Send HTTP request" con headers personalizados.

La opción más rápida si no querés depender de un desarrollador. Sirve para cualquier plataforma con conector en Zapier o Make — Shopify, WooCommerce, Tiendanube, etc.

Zapier — paso a paso

1. Trigger: elegí tu app de ecommerce → evento "New Paid Order".
2. Action 1: app Webhooks by Zapier → evento "POST".
3. URL: https://api.getwalletfy.com/public-api/v1/customers
4. Headers: Authorization: Bearer wfy_live_...
5. Data: mapeá name, email, phone desde los campos de la orden.
6. Action 2: otro paso Webhooks by Zapier → POST a /stamps, usando el customerId del Action 1 y el amount de la orden.

En Make (Integromat) es el mismo patrón: un módulo "HTTP → Make a request" por cada llamada, encadenados en el mismo escenario.

Si tu tienda corre con tu propio backend, llamá a la API directo desde donde confirmás el pago de la orden — sin intermediarios.

async function callWalletfy(endpoint, body) {
  const res = await fetch(`https://api.getwalletfy.com/public-api/v1${endpoint}`, {
    method: "POST",
    headers: {
      Authorization: `Bearer ${process.env.WALLETFY_API_KEY}`,
      "Content-Type": "application/json",
    },
    body: JSON.stringify(body),
  });
  return res.json();
}

// justo después de confirmar el pago de la orden
async function onOrderPaid(order) {
  const customer = await callWalletfy("/customers", {
    name: order.customerName,
    email: order.customerEmail,
    phone: order.customerPhone,
  });

  await callWalletfy("/stamps", { customerId: customer.customerId, amount: order.total });

  return customer.wallet; // { apple: { addUrl }, google: { addUrl } }
}

Referencia de endpoints

Los dos endpoints que usa cualquiera de las integraciones de arriba.

POST /customers

Crea o encuentra al cliente (por email o teléfono) y genera su tarjeta Wallet.

{
  "customerId": "...",
  "isNewCustomer": true,
  "wallet": {
    "apple": { "walletPassId": "...", "addUrl": "https://..." },
    "google": { "walletPassId": "...", "addUrl": "https://..." }
  }
}

POST /stamps

Suma un sello o puntos por una compra.

Igual que el escaneo en tienda, hay un límite de un sello cada 6 horas por cliente — pensado para evitar duplicados si un webhook reintenta la misma orden.

Autenticación

Todas las llamadas van con tu API key en el header:

Authorization: Bearer wfy_live_...

Disponible en los planes Pro y Smart. ¿Dudas con tu integración? Escribinos por WhatsApp.