Webhooks de la API de revendedores

Eventos de webhook, payloads, verificación de la firma HMAC en Python y Node, reintentos con backoff, reglas de seguridad de la URL y deduplicación por id de evento.

Crear un webhook

POST /webhooks (permiso webhooks): una URL solo https y una lista de eventos que no esté vacía. Como máximo 5 webhooks. Idempotency-Key es opcional: una repetición devuelve el mismo webhook, sin el secreto. last_delivered_at es la hora de la última respuesta 2xx de tu servidor (null hasta que haya una).

curl -s -X POST https://app.oneprovider.dev/partner/v1/webhooks \
-H "Authorization: Bearer $OP_PARTNER_TOKEN" \
-H "Content-Type: application/json" \
-d '{"url":"https://shop.example.com/op-webhook","events":["order.completed","balance.low"]}'

{
"id": "<webhook id>",
"url": "https://shop.example.com/op-webhook",
"events": ["order.completed", "balance.low"],
"active": true,
"secret_last4": "a1b2",
"created_at": "2026-10-08T12:00:00Z",
"last_delivered_at": null,
"secret": "whsec_..."
}

Eventos

Los datos del evento nunca contienen secretos: ni claves, ni tokens, ni códigos. La prueba (POST /webhooks/{id}/test) envía el evento de servicio webhook.test con data {"message": "test"}; no te puedes suscribir a él.

Solicitud y firma

Enviamos un POST con un cuerpo JSON:

{
"id": "evt_...",
"type": "order.completed",
"created_at": "2026-10-08T12:00:00Z",
"data": {
"order_id": 42,
"external_order_id": "shop-1042",
"kind": "new_key",
"key_id": "<key id>",
"amount_usd": "10.00"
}
}

El cuerpo se envía como JSON compacto con las claves en orden alfabético; verifica la firma sobre los bytes tal como llegaron, no sobre un JSON reconstruido.

v1 es el hex de un HMAC-SHA256 cuya clave es el secreto del webhook (whsec_...) y cuyo mensaje es la cadena "<t>" + "." + raw_body.

Verificar la firma

1. Lee el cuerpo sin procesar de la solicitud: la firma cubre los bytes exactos, un JSON reserializado no coincidirá.
2. Recalcula el HMAC y compáralo con v1 en tiempo constante (hmac.compare_digest, timingSafeEqual).
3. Rechaza la solicitud si |now - t| supera los 5 minutos, para que no se pueda reutilizar una firma antigua.
4. Responde 2xx rápido (el tiempo de espera es de 10 segundos) y haz el trabajo pesado de forma asíncrona.

Python

import hashlib
import hmac
import time
TOLERANCE = 300 # seconds
def verify(secret: str, header: str, raw_body: bytes) -> bool:
"""header is X-OP-Signature: t=<unix>,v1=<hex>; raw_body is the unparsed request body."""
parts = dict(p.strip().partition("=")[::2] for p in header.split(","))
t, v1 = parts.get("t", ""), parts.get("v1", "")
if not t.isdigit() or abs(time.time() - int(t)) > TOLERANCE:
return False
signed = t.encode() + b"." + raw_body
expected = hmac.new(secret.encode(), signed, hashlib.sha256).hexdigest()
return hmac.compare_digest(expected, v1)

import json
import os
from fastapi import FastAPI, HTTPException, Request
app = FastAPI()
SECRET = os.environ["OP_WEBHOOK_SECRET"] # whsec_...
seen: set[str] = set() # use a database table with a unique index in production
@app.post("/op-webhook")
async def op_webhook(request: Request):
raw = await request.body() # the raw bytes, before any JSON parsing
if not verify(SECRET, request.headers.get("X-OP-Signature", ""), raw):
raise HTTPException(status_code=400, detail="bad signature")
event = json.loads(raw)
if event["id"] in seen: # retries resend the same event id
return {"ok": True}
seen.add(event["id"])
if event["type"] == "order.completed":
... # your logic
return {"ok": True} # any 2xx marks the event as delivered

Node.js

import crypto from "node:crypto"
import express from "express"
const SECRET = process.env.OP_WEBHOOK_SECRET // whsec_...
const TOLERANCE = 300 // seconds
const seen = new Set() // use a database table with a unique index in production
function verify(secret, header, raw) {
const parts = Object.fromEntries(
String(header).split(",").map((p) => p.trim().split("=")),
)
const t = Number(parts.t)
if (!Number.isInteger(t) || Math.abs(Date.now() / 1000 - t) > TOLERANCE) return false
const expected = crypto
.createHmac("sha256", secret)
.update(parts.t + ".")
.update(raw)
.digest("hex")
const a = Buffer.from(expected)
const b = Buffer.from(parts.v1 ?? "")
return a.length === b.length && crypto.timingSafeEqual(a, b)
}
const app = express()
// express.raw keeps the body as a Buffer: do not use express.json() on this route
app.post("/op-webhook", express.raw({ type: "application/json" }), (req, res) => {
if (!verify(SECRET, req.get("X-OP-Signature"), req.body)) return res.sendStatus(400)
const event = JSON.parse(req.body.toString("utf8"))
if (!seen.has(event.id)) {
seen.add(event.id) // retries resend the same event id
if (event.type === "order.completed") {
// your logic
}
}
res.sendStatus(200) // any 2xx marks the event as delivered
})
app.listen(3000)

Reintentos

Solo una respuesta 2xx cuenta como entregada. Todo lo demás (incluidos los 3xx, porque no se siguen las redirecciones, además de los tiempos de espera agotados y los errores de conexión) se reintenta con backoff exponencial: 1 minuto, 2, 4 y así sucesivamente, con un tope de 4 horas, hasta 24 horas después del evento; luego la entrega pasa a failed. Cada reintento lleva el mismo id de evento, así que deduplica por él: guarda los ids procesados en una tabla con un índice único.

Reglas de la URL

• Solo https, puerto 443 (cualquier otro puerto da 400 invalid_url) y un nombre de host; las direcciones IP literales se rechazan. La URL tiene como máximo 500 caracteres ASCII, sin usuario, contraseña ni fragmento.
• Ninguna dirección a la que resuelva el nombre puede ser privada, de loopback, de enlace local ni reservada.
• La comprobación se hace al crear y en cada entrega. Una infracción al crear da 400 invalid_url.

Prueba y registro

curl -s -X POST https://app.oneprovider.dev/partner/v1/webhooks/<webhook id>/test -H "Authorization: Bearer $OP_PARTNER_TOKEN"
curl -s "https://app.oneprovider.dev/partner/v1/webhooks/<webhook id>/deliveries?limit=20" -H "Authorization: Bearer $OP_PARTNER_TOKEN"

Objeto de entrega: id, event_id, event, status (pending, delivered, failed), attempts, next_attempt_at, last_error (http_<status>, timeout, blocked_address o el nombre del error de conexión), last_status (el estado HTTP con el que respondió tu servidor, null si no respondió), last_body (el comienzo de la respuesta, hasta 300 caracteres, en una línea), created_at. Eliminar un webhook: DELETE /webhooks/{id}. Las pruebas y los reintentos manuales (en el panel) juntos están limitados a 6 por minuto; solo se puede reintentar un evento no entregado, uno entregado da 409 already_delivered. El reintento manual está disponible solo en el panel, no con un token.