Probar tus webhooks

import os
from compense_gateway import CompenseClient

client = CompenseClient(api_key=os.environ["COMPENSE_API_KEY"], environment="sandbox")

tx = client.webhooks.endpoints.send_test(
    "3f1a2b3c-0000-4a1b-9c2d-000000000001",
    event_type="credits.decision",           # omítelo para un test.ping
)
print(tx.data["delivery_id"], tx.data["event_id"], tx.data["status"])

# Sigue el resultado de la entrega:
entrega = client.webhooks.deliveries.get(tx.data["delivery_id"])
print(entrega["status"], entrega.get("response"))

import { CompenseClient } from "@compense/sdk";

const client = new CompenseClient({ apiKey: process.env.COMPENSE_API_KEY!, environment: "sandbox" });

const tx = await client.webhooks.endpoints.sendTest("3f1a2b3c-0000-4a1b-9c2d-000000000001", {
  eventType: "credits.decision", // omítelo para un test.ping
});
console.log(tx.data.delivery_id, tx.data.event_id, tx.data.status);

const entrega = await client.webhooks.deliveries.get(String(tx.data.delivery_id));
console.log(entrega.status, entrega.response);

<?php
require __DIR__ . '/vendor/autoload.php';

use Compense\Sdk\CompenseClient;

$client = new CompenseClient(apiKey: getenv('COMPENSE_API_KEY'), environment: 'sandbox');

$tx = $client->webhooks->endpoints->sendTest(
    '3f1a2b3c-0000-4a1b-9c2d-000000000001',
    eventType: 'credits.decision',           // omítelo para un test.ping
);
echo $tx->data['delivery_id'], ' ', $tx->data['event_id'], ' ', $tx->data['status'], PHP_EOL;

$entrega = $client->webhooks->deliveries->get($tx->data['delivery_id']);
echo $entrega['status'], PHP_EOL;

using System.Text.Json.Nodes;
using Compense.Sdk;
using Compense.Sdk.Models;

using var client = new CompenseClient(
    Environment.GetEnvironmentVariable("COMPENSE_API_KEY")!, CompenseEnvironment.Sandbox);

Transaction tx = await client.Webhooks.Endpoints.SendTestAsync(
    "3f1a2b3c-0000-4a1b-9c2d-000000000001", "credits.decision"); // sin el 2.º argumento: test.ping
Console.WriteLine($"{tx.Data["delivery_id"]} {tx.Data["event_id"]} {tx.Data["status"]}");

JsonObject entrega = await client.Webhooks.Deliveries.GetAsync(tx.Data["delivery_id"]!.GetValue<string>());
Console.WriteLine(entrega["status"]);

package main

import (
	"context"
	"fmt"
	"log"
	"os"

	compense "github.com/Appiasoft/compense-saas-sdk-go"
)

func main() {
	ctx := context.Background()
	client, err := compense.NewClient(os.Getenv("COMPENSE_API_KEY"),
		compense.WithEnvironment(compense.Sandbox))
	if err != nil {
		log.Fatal(err)
	}

	tx, err := client.Webhooks.Endpoints.SendTest(ctx, "3f1a2b3c-0000-4a1b-9c2d-000000000001",
		&compense.SendTestParams{EventType: "credits.decision"}) // nil: test.ping
	if err != nil {
		log.Fatal(err)
	}
	fmt.Println(tx.Data["delivery_id"], tx.Data["event_id"], tx.Data["status"])

	entrega, err := client.Webhooks.Deliveries.Get(ctx, fmt.Sprint(tx.Data["delivery_id"]))
	if err != nil {
		log.Fatal(err)
	}
	fmt.Println(entrega["status"])
}

# Payload de ejemplo de un evento del catálogo
curl -X POST https://sandbox.dev.compense.co/gw/v1/gateway/webhooks/endpoints/$ENDPOINT_ID/test/ \
  -H "X-API-Key: $COMPENSE_API_KEY" \
  -H "Idempotency-Key: prueba-credits-decision-001" \
  -H "Content-Type: application/json" \
  -d '{"event_type": "credits.decision"}'

# test.ping genérico: sin cuerpo
curl -X POST https://sandbox.dev.compense.co/gw/v1/gateway/webhooks/endpoints/$ENDPOINT_ID/test/ \
  -H "X-API-Key: $COMPENSE_API_KEY" \
  -H "Idempotency-Key: prueba-ping-001"

import json
import time

from compense_gateway.webhooks import expected_signature, verify_webhook

SECRETO = "whsec_prueba_local"
cuerpo = json.dumps(
    {"event": "credits.decision", "version": "1", "tenant_id": "horizonte",
     "occurred_at": "2026-10-27T15:20:00Z", "resource": {"decision": "approved"}},
    separators=(",", ":"),                   # JSON compacto, como lo envía Compense
).encode("utf-8")
ahora = int(time.time())
cabeceras = {
    "X-Webhook-Signature": "sha256=" + expected_signature(SECRETO, cuerpo),
    "X-Webhook-Event": "credits.decision",
    "X-Webhook-Id": "evt-prueba-0001",
    "X-Webhook-Timestamp": str(ahora),
}

event = verify_webhook(cuerpo, cabeceras, secret=SECRETO, now=ahora)
assert event.resource["decision"] == "approved"
# Con Flask: app.test_client().post("/compense/webhooks", data=cuerpo, headers=cabeceras)

import { expectedSignature, verifyWebhook } from "@compense/sdk/webhooks";

const SECRETO = "whsec_prueba_local";
const cuerpo = JSON.stringify({
  event: "credits.decision", version: "1", tenant_id: "horizonte",
  occurred_at: "2026-10-27T15:20:00Z", resource: { decision: "approved" },
});
const ahora = Math.floor(Date.now() / 1000);
const cabeceras = {
  "X-Webhook-Signature": `sha256=${expectedSignature(SECRETO, cuerpo)}`,
  "X-Webhook-Event": "credits.decision",
  "X-Webhook-Id": "evt-prueba-0001",
  "X-Webhook-Timestamp": String(ahora),
};

const event = verifyWebhook(cuerpo, cabeceras, SECRETO, { now: ahora });
console.assert(event.resource.decision === "approved");

<?php
use Compense\Sdk\Webhook\Webhook;

$secreto = 'whsec_prueba_local';
$cuerpo = json_encode([
    'event' => 'credits.decision', 'version' => '1', 'tenant_id' => 'horizonte',
    'occurred_at' => '2026-10-27T15:20:00Z', 'resource' => ['decision' => 'approved'],
]);
$ahora = time();
$cabeceras = [
    'X-Webhook-Signature' => 'sha256=' . Webhook::expectedSignature($secreto, $cuerpo),
    'X-Webhook-Event' => 'credits.decision',
    'X-Webhook-Id' => 'evt-prueba-0001',
    'X-Webhook-Timestamp' => (string) $ahora,
];

$event = Webhook::verify($cuerpo, $cabeceras, $secreto, now: (float) $ahora);
assert($event->resource()['decision'] === 'approved');

using System.Text;
using Compense.Sdk.Webhooks;

const string Secreto = "whsec_prueba_local";
byte[] cuerpo = Encoding.UTF8.GetBytes(
    "{\"event\":\"credits.decision\",\"version\":\"1\",\"tenant_id\":\"horizonte\"," +
    "\"occurred_at\":\"2026-10-27T15:20:00Z\",\"resource\":{\"decision\":\"approved\"}}");
long ahora = DateTimeOffset.UtcNow.ToUnixTimeSeconds();
var cabeceras = new Dictionary<string, string>
{
    ["X-Webhook-Signature"] = "sha256=" + CompenseWebhooks.ExpectedSignature(Secreto, cuerpo),
    ["X-Webhook-Event"] = "credits.decision",
    ["X-Webhook-Id"] = "evt-prueba-0001",
    ["X-Webhook-Timestamp"] = ahora.ToString(),
};

WebhookEvent evt = CompenseWebhooks.Verify(cuerpo, cabeceras, Secreto,
    now: DateTimeOffset.FromUnixTimeSeconds(ahora));
Console.WriteLine(evt.Resource["decision"]); // approved

package receptor

import (
	"net/http"
	"strconv"
	"testing"
	"time"

	"github.com/Appiasoft/compense-saas-sdk-go/webhook"
)

func TestVerificaEntregaFirmada(t *testing.T) {
	const secreto = "whsec_prueba_local"
	cuerpo := []byte(`{"event":"credits.decision","version":"1","tenant_id":"horizonte",` +
		`"occurred_at":"2026-10-27T15:20:00Z","resource":{"decision":"approved"}}`)
	ahora := time.Now()

	h := http.Header{}
	h.Set("X-Webhook-Signature", "sha256="+webhook.ExpectedSignature(secreto, cuerpo))
	h.Set("X-Webhook-Event", "credits.decision")
	h.Set("X-Webhook-Id", "evt-prueba-0001")
	h.Set("X-Webhook-Timestamp", strconv.FormatInt(ahora.Unix(), 10))

	ev, err := webhook.Verify(cuerpo, h, []string{secreto},
		webhook.WithNow(func() time.Time { return ahora }))
	if err != nil || ev.Resource()["decision"] != "approved" {
		t.Fatalf("verificación: %v", err)
	}
}

# Contra tu receptor corriendo en local (el mismo secreto configurado en él):
SECRET="whsec_prueba_local"
BODY='{"event":"credits.decision","version":"1","tenant_id":"horizonte","resource":{"decision":"approved"}}'
SIG=$(printf '%s' "$BODY" | openssl dgst -sha256 -hmac "$SECRET" | sed 's/^.* //')
curl -i -X POST http://localhost:8000/compense/webhooks \
  -H "Content-Type: application/json" \
  -H "X-Webhook-Signature: sha256=$SIG" \
  -H "X-Webhook-Event: credits.decision" \
  -H "X-Webhook-Id: evt-prueba-0001" \
  -H "X-Webhook-Timestamp: $(date +%s)" \
  --data-binary "$BODY"