Integre sua operação em minutos

Integre meu sistema na rede de saúde do WhatsApp Founders (reporte de falhas WhatsApp/Meta).
Leia a spec completa em https://www.whatsappfounders.com.br/integrar.md e implemente no meu projeto.

Minhas credenciais (guarde o WHF_SECRET em variável de ambiente — nunca no código/repo):
  API        = https://api.whatsappfounders.com.br
  WHF_KEY    = whf_live_…        (cole a sua)
  WHF_SECRET = whfsec_…          (cole o seu)
  TENANT     = SEU_TENANT

Comece pelo componente "envio": no caminho de envio, um try/catch que faz POST {API}/v1/ping/{TENANT}/envio/fail (sem ?period) quando o envio dá erro — fire-and-forget, nunca derrube o app. Heartbeat periódico é opcional. Me pergunte quais componentes consigo medir e o que fazer quando houver outage do grupo.

export API="https://api.whatsappfounders.com.br"
export WHF_KEY="whf_live_…"  WHF_SECRET="whfsec_…"

# pegou erro no envio (sem ?period = modo só-falha)
curl -fsS -X POST "$API/v1/ping/SEU_TENANT/envio/fail" \
  -H "WHF-Key: $WHF_KEY" -H "WHF-Secret: $WHF_SECRET"

# (opcional) limpar na hora, no próximo envio que der certo
curl -fsS -X POST "$API/v1/ping/SEU_TENANT/envio" \
  -H "WHF-Key: $WHF_KEY" -H "WHF-Secret: $WHF_SECRET"

import os, urllib.request

API    = "https://api.whatsappfounders.com.br"
TENANT = "SEU_TENANT"
H = {"WHF-Key": os.environ["WHF_KEY"], "WHF-Secret": os.environ["WHF_SECRET"]}

def reportar(componente: str, falhou: bool) -> None:
    sufixo = "/fail" if falhou else ""        # sem ?period = modo só-falha
    url = f"{API}/v1/ping/{TENANT}/{componente}{sufixo}"
    try:
        urllib.request.urlopen(urllib.request.Request(url, method="POST", headers=H), timeout=8)
    except Exception:
        pass                                  # fire-and-forget: nunca derrube o app

# no seu envio:
try:
    enviar_pela_cloud_api(...)
except Exception:
    reportar("envio", falhou=True)

const API    = "https://api.whatsappfounders.com.br";
const TENANT = "SEU_TENANT";
const H = { "WHF-Key": process.env.WHF_KEY, "WHF-Secret": process.env.WHF_SECRET };

function reportar(componente, falhou) {            // sem ?period = modo só-falha
  const sufixo = falhou ? "/fail" : "";
  // fire-and-forget: nunca deixe o report travar/derrubar o request
  fetch(`${API}/v1/ping/${TENANT}/${componente}${sufixo}`, { method: "POST", headers: H }).catch(() => {});
}

// no seu envio:
try { await enviarPelaCloudApi(...); }
catch (e) { reportar("envio", true); }

curl -fsS -X POST "$API/v1/ping/SEU_TENANT/envio" \
  -H "WHF-Key: $WHF_KEY" -H "WHF-Secret: $WHF_SECRET" \
  -H "Content-Type: application/json" \
  -d '{"error_count": 3, "total_count": 200}'

import json, os, urllib.request

API, TENANT = "https://api.whatsappfounders.com.br", "SEU_TENANT"
H = {"WHF-Key": os.environ["WHF_KEY"], "WHF-Secret": os.environ["WHF_SECRET"],
     "Content-Type": "application/json"}

def ping(componente: str, erros: int, total: int) -> None:
    sufixo = "/fail" if total and erros / total > 0.25 else ""
    url  = f"{API}/v1/ping/{TENANT}/{componente}{sufixo}"
    body = json.dumps({"error_count": erros, "total_count": total}).encode()
    urllib.request.urlopen(urllib.request.Request(url, data=body, method="POST", headers=H), timeout=8)

ping("envio", erros=3, total=200)
ping("recebimento", erros=0, total=540)
ping("midia", erros=1, total=40)
ping("templates", erros=0, total=88)

const API = "https://api.whatsappfounders.com.br", TENANT = "SEU_TENANT";
const H = { "WHF-Key": process.env.WHF_KEY, "WHF-Secret": process.env.WHF_SECRET,
           "Content-Type": "application/json" };

async function ping(componente, erros, total) {
  const sufixo = total && erros / total > 0.25 ? "/fail" : "";
  const body = JSON.stringify({ error_count: erros, total_count: total });
  await fetch(`${API}/v1/ping/${TENANT}/${componente}${sufixo}`,
              { method: "POST", headers: H, body });
}

await ping("envio", 3, 200);
await ping("recebimento", 0, 540);
await ping("midia", 1, 40);
await ping("templates", 0, 88);

X-WHF-Event:     incident.opened          # ou incident.resolved
X-WHF-Signature: sha256=<hex>
X-WHF-Timestamp: <unix>

# assinatura = HMAC_SHA256(secret_do_webhook, "<timestamp>." + corpo_cru)
# valide a janela de tempo (anti-replay) e compare em tempo constante

import hashlib, hmac, os, time

WEBHOOK_SECRET = os.environ["WHF_WEBHOOK_SECRET"]  # devolvido ao registrar

def verificar(corpo_cru: bytes, headers: dict) -> bool:
    ts = headers.get("X-WHF-Timestamp", "")
    if not ts or abs(time.time() - int(ts)) > 300:        # janela de 5 min
        return False
    esperado = hmac.new(WEBHOOK_SECRET.encode(),
                        f"{ts}.".encode() + corpo_cru, hashlib.sha256).hexdigest()
    recebido = headers.get("X-WHF-Signature", "").removeprefix("sha256=")
    return hmac.compare_digest(esperado, recebido)

const crypto = require("crypto");
const WEBHOOK_SECRET = process.env.WHF_WEBHOOK_SECRET; // devolvido ao registrar

function verificar(corpoCru, headers) {                 // corpoCru = Buffer do body
  const ts = headers["x-whf-timestamp"];
  if (!ts || Math.abs(Date.now() / 1000 - Number(ts)) > 300) return false;
  const esperado = crypto.createHmac("sha256", WEBHOOK_SECRET)
    .update(`${ts}.`).update(corpoCru).digest("hex");
  const recebido = (headers["x-whf-signature"] || "").replace("sha256=", "");
  const a = Buffer.from(esperado), b = Buffer.from(recebido);
  return a.length === b.length && crypto.timingSafeEqual(a, b);
}

<img alt="status envio"
     src="https://img.shields.io/endpoint?url=https://api.whatsappfounders.com.br/v1/badge/envio">

![status envio](https://img.shields.io/endpoint?url=https://api.whatsappfounders.com.br/v1/badge/envio)