Documentation

Webhooks

Webhooks let you receive real-time notifications when events happen in the Strictly platform — such as when a payment is approved, a subscription renews, or an invoice is paid.

Instead of polling the API for status updates, configure a webhook endpoint and the Strictly API will POST event payloads to your server automatically.

How it works

Register your endpoint

Provide a publicly accessible HTTPS URL to your account manager or via the dashboard. This URL will receive POST requests with a JSON payload whenever a relevant event occurs.

Receive the event

When an event fires, the Strictly API sends a POST request to your endpoint with a Content-Type: application/json body.

Your endpoint must respond with HTTP 200 within 5 seconds. If it does not, the delivery is considered failed and may be retried.


Example webhook payload
{
  "event": "payment.approved",
  "timestamp": "2024-01-15T10:30:00.000Z",
  "data": {
    "id": "txn_abc123",
    "status": "approved",
    "amount": 1000,
    "currency": "USD",
    "authCode": "ABC123"
  }
}

Acknowledge immediately, process asynchronously

Return 200 as fast as possible — before any business logic runs. Process the event in the background (queue, worker, etc.) to avoid timeouts.


Express.js — acknowledge immediately
app.post("/webhooks/strictly", express.json(), (req, res) => {
  // Acknowledge before processing
  res.sendStatus(200);

  // Process in background
  processWebhookEvent(req.body).catch(console.error);
});

Event types

Event	Trigger
`payment.approved`	A card or ACH charge was approved
`payment.declined`	A charge was declined by the gateway
`payment.refunded`	A refund was processed
`payment.voided`	A transaction was voided
`subscription.created`	A new subscription was created
`subscription.renewed`	A subscription billing cycle renewed
`subscription.cancelled`	A subscription was cancelled
`subscription.failed`	A subscription renewal charge failed
`invoice.created`	An invoice was generated
`invoice.paid`	An invoice was marked as paid
`invoice.overdue`	An invoice passed its due date
`customer.created`	A new customer vault was created

Payload structure

All webhook payloads share the same envelope:


Code
{
  "event": "event.type",
  "timestamp": "ISO 8601 datetime",
  "data": {
    // Event-specific object
  }
}

The data field contains the full resource object associated with the event (e.g. a transaction record for payment events, a subscription record for subscription events).

Retries and reliability

If your endpoint returns a non-2xx response or times out, the Strictly platform will retry delivery with exponential backoff:

Attempt	Delay
1st retry	5 minutes
2nd retry	30 minutes
3rd retry	2 hours
4th retry	12 hours

After 4 failed retries, the delivery is abandoned. You can replay missed events by querying the relevant resource through the API.

Idempotency

Your webhook handler must be idempotent — the same event may be delivered more than once. Store the event id (or data.id) and skip processing if you've already handled it.


Idempotent handler example
const processedEvents = new Set(); // In production: use a database

async function processWebhookEvent(payload) {
  const eventId = payload.data?.id;

  if (processedEvents.has(eventId)) {
    console.log(`Skipping duplicate event: ${eventId}`);
    return;
  }

  processedEvents.add(eventId);

  // Handle the event
  switch (payload.event) {
    case "payment.approved":
      await fulfillOrder(payload.data);
      break;
    case "subscription.failed":
      await notifyCustomer(payload.data);
      break;
    // ...
  }
}

Inbound webhooks

The Strictly API also accepts inbound webhooks from external integrations via the /public/webhooks/ endpoints. These allow third-party services to send payment-related events into the Strictly platform. See the API Reference for available inbound webhook routes and their expected payloads.

Last modified on February 27, 2026

Error Handling