Webhooks

Get Event Alerts and Automate Actions Across Your Tools

Moments after something happens in Enlivy (an invoice is paid, a transaction lands, a user changes), a webhook fires to your system. React to events instead of polling for changes or waiting on reports.

Create a free account

Free account, no card needed. Sending events needs any paid pack, from €2.99/month, excluding VAT.

WHAT IT IS

The Change Happens. Your Systems Act.

Stay ahead by keeping your systems in sync with event updates from Enlivy.

Webhooks let your applications react moments after something happens inside Enlivy.

Instead of waiting for reports or building costly polling logic, you receive event notifications in your system when records change.

Event Notifications

Get notified moments after an invoice, transaction, user, or other key record is created or updated, with retries when your endpoint is down.
Direct Automation

Connect Enlivy directly to your apps and workflows. Trigger custom actions, sync with external tools, or keep your reporting current without polling.

Adding an event destination: a webhook that sends a signed HTTP POST to your endpoint, or a Slack channel

WHAT IT IS

Stay Ahead with Current Data

Enlivy Webhooks help keep your systems up to date, giving you complete control over your data and workflows.

By receiving notifications whenever invoices, transactions, users, or other key events occur, you no longer have to rely on manual checks or delayed reporting.

Save Time Automatically

Event notifications mean less manual work and faster response times.
Reduce Errors

Your data stays accurate and synchronized across all systems.
Simplify Your Integrations

Connect your apps and workflows quickly with minimal setup.

EVENT DELIVERY

Subscribe to Helpdesk moments

Event Delivery lets you select Helpdesk triggers such as a new, assigned or unanswered conversation and send them to a webhook destination. Choose the events and destination for each subscription.

WHY WEBHOOKS

Fast, Reliable, and Yours to Shape

Webhooks turn Enlivy into the source of truth your whole stack listens to.

Signed Event Notifications

Moments after an invoice, transaction, or user changes, a signed payload lands on your endpoint. No polling, no waiting on reports.
You know what changed without checking by hand.
Fully Customizable

Subscribe to only the events that matter and choose the related data each one carries. Get exactly what your workflow needs, nothing more.
Every payload is shaped by you.
Smarter Automation

Trigger workflows, notifications, and integrations automatically instead of moving data by hand.
Your systems work for you, not the other way around.
Centralized Data Flow

Keep every tool, platform, and application synchronized from one stream of events.
Your team focuses on decisions, not data management.
Reliable and Always On

Deliveries are consistent and always on, and every send is logged so you can inspect exactly what happened.
A delivery is tried up to five times over about ten minutes, and the account owner gets an hourly digest of anything that still failed.
Scalable Integration

Each active paid pack includes up to 25 endpoints.
Automation stays simple at every scale.

API Reference

Webhooks & Event Delivery from the API

Get notified the moment something happens in your account. An event destination is an endpoint, an HTTPS webhook or a Slack channel, that subscribes to the events you care about (an invoice paid, a contract updated, a bank transaction created) and receives a signed payload each time one fires.

Every send is recorded as a delivery, so you can inspect exactly what was sent and how your endpoint responded. This reference covers the full loop: create and adjust destinations, subscribe them to events, fire a test, delete them, and read the delivery logs and their data.

List your configured destinations. Retrieve a single one with its subscribed events and recent deliveries by expanding the includes.

GET/organizations/<organization_id>/event-destinations+1

# list all destinations
curl 'https://api.enlivy.com/organizations/<organization_id>/event-destinations' \
  -H "Authorization: Bearer $ENLIVY_API_TOKEN" \
  -H 'Accept: application/json'

# one destination, with its subscriptions and deliveries inline
curl -G 'https://api.enlivy.com/organizations/<organization_id>/event-destinations/<event_destination_id>' \
  --data-urlencode 'include=event_subscriptions,event_deliveries' \
  -H "Authorization: Bearer $ENLIVY_API_TOKEN" \
  -H 'Accept: application/json'

const baseUrl = "https://api.enlivy.com";
const token = process.env.ENLIVY_API_TOKEN;
const organizationId = "<organization_id>";
const eventDestinationId = "<event_destination_id>";

const headers = {
  Authorization: `Bearer ${token}`,
  Accept: "application/json",
};

// list all destinations
const result1 = await fetch(`${baseUrl}/organizations/${organizationId}/event-destinations`, {
  method: "GET",
  headers,
}).then((response) => response.json());

// one destination, with its subscriptions and deliveries inline
const query = new URLSearchParams({
  include: "event_subscriptions,event_deliveries",
});
const result2 = await fetch(`${baseUrl}/organizations/${organizationId}/event-destinations/${eventDestinationId}?${query}`, {
  method: "GET",
  headers,
}).then((response) => response.json());

Register a webhook (or Slack) endpoint and subscribe it to events. Each subscribed event can specify which related data to embed and an optional message template. The response includes a signing_secret, use it to verify the signature on incoming webhook payloads.

POST/organizations/<organization_id>/event-destinations

curl -X POST 'https://api.enlivy.com/organizations/<organization_id>/event-destinations' \
  -H "Authorization: Bearer $ENLIVY_API_TOKEN" \
  -H 'Accept: application/json' \
  -H 'Content-Type: application/json' \
  -d '{
  "type": "webhook",
  "name": "My integration",
  "destination_url": "https://example.com/enlivy/webhooks",
  "is_active": true,
  "events": [
    {
      "event": "invoice.paid",
      "includes": [
        "line_items",
        "taxes"
      ],
      "config": {
        "message": "Invoice {{ invoice.number }} was paid"
      }
    },
    {
      "event": "contract.updated"
    }
  ]
}'

# Response includes: id, type, destination_url, signing_secret, is_active, name, config.

const baseUrl = "https://api.enlivy.com";
const token = process.env.ENLIVY_API_TOKEN;
const organizationId = "<organization_id>";

const result = await fetch(`${baseUrl}/organizations/${organizationId}/event-destinations`, {
  method: "POST",
  headers: {
    Authorization: `Bearer ${token}`,
    Accept: "application/json",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    // webhook | slack
    type: "webhook",
    name: "My integration",
    // required when type = webhook
    destination_url: "https://example.com/enlivy/webhooks",
    is_active: true,
    // For Slack instead, drop destination_url and send:
    //   type: "slack",
    //   organization_api_credential_id: "slack_credential_id",
    //   config: { channel: "#billing" },
    // subscribe to one or more trigger events (pattern: subject.action)
    events: [
      {
        // e.g. invoice.created | invoice.paid | contract.updated
        event: "invoice.paid",
        includes: ["line_items", "taxes"],
        config: { message: "Invoice {{ invoice.number }} was paid" },
      },
      { event: "contract.updated" },
    ],
  }),
}).then((response) => response.json());

// Response includes: id, type, destination_url, signing_secret, is_active, name, config.

Update a destination: change its URL, pause or resume it, or re-set the events it is subscribed to. Provide the full events set you want the destination subscribed to.

PUT/organizations/<organization_id>/event-destinations/<event_destination_id>

curl -X PUT 'https://api.enlivy.com/organizations/<organization_id>/event-destinations/<event_destination_id>' \
  -H "Authorization: Bearer $ENLIVY_API_TOKEN" \
  -H 'Accept: application/json' \
  -H 'Content-Type: application/json' \
  -d '{
  "is_active": false,
  "destination_url": "https://example.com/enlivy/webhooks/v2",
  "events": [
    {
      "event": "invoice.created"
    },
    {
      "event": "invoice.paid"
    }
  ]
}'

const baseUrl = "https://api.enlivy.com";
const token = process.env.ENLIVY_API_TOKEN;
const organizationId = "<organization_id>";
const eventDestinationId = "<event_destination_id>";

const result = await fetch(`${baseUrl}/organizations/${organizationId}/event-destinations/${eventDestinationId}`, {
  method: "PUT",
  headers: {
    Authorization: `Bearer ${token}`,
    Accept: "application/json",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    // pause delivery without deleting
    is_active: false,
    destination_url: "https://example.com/enlivy/webhooks/v2",
    events: [{ event: "invoice.created" }, { event: "invoice.paid" }],
  }),
}).then((response) => response.json());

Fire a synthetic event at a destination to verify the wiring end to end. It produces a real delivery record you can inspect in the logs.

POST/organizations/<organization_id>/event-destinations/<event_destination_id>/test

curl -X POST 'https://api.enlivy.com/organizations/<organization_id>/event-destinations/<event_destination_id>/test' \
  -H "Authorization: Bearer $ENLIVY_API_TOKEN" \
  -H 'Accept: application/json' \
  -H 'Content-Type: application/json' \
  -d '{
  "event": "invoice.paid"
}'

const baseUrl = "https://api.enlivy.com";
const token = process.env.ENLIVY_API_TOKEN;
const organizationId = "<organization_id>";
const eventDestinationId = "<event_destination_id>";

const result = await fetch(`${baseUrl}/organizations/${organizationId}/event-destinations/${eventDestinationId}/test`, {
  method: "POST",
  headers: {
    Authorization: `Bearer ${token}`,
    Accept: "application/json",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    // optional, omit to send a generic test event
    event: "invoice.paid",
  }),
}).then((response) => response.json());

Read the log of every event sent. Filter by destination, by one or more events, by delivery status, and by date, the fastest way to spot failures and retries.

GET/organizations/<organization_id>/event-destinations/deliveries

# event + status accept arrays, pass each value with a [] suffix
# status: pending | success | failed | dropped | anomaly
curl -G 'https://api.enlivy.com/organizations/<organization_id>/event-destinations/deliveries' \
  --data-urlencode 'organization_event_destination_id=<destination_id>' \
  --data-urlencode 'event[]=invoice.paid' \
  --data-urlencode 'event[]=invoice.created' \
  --data-urlencode 'status[]=failed' \
  --data-urlencode 'created_at_from=2026-07-01' \
  --data-urlencode 'created_at_to=2026-07-31' \
  -H "Authorization: Bearer $ENLIVY_API_TOKEN" \
  -H 'Accept: application/json'

const baseUrl = "https://api.enlivy.com";
const token = process.env.ENLIVY_API_TOKEN;
const organizationId = "<organization_id>";

// event + status accept arrays, pass each value with a [] suffix
// status: pending | success | failed | dropped | anomaly
const query = new URLSearchParams([
  ["organization_event_destination_id", "<destination_id>"],
  ["event[]", "invoice.paid"],
  ["event[]", "invoice.created"],
  ["status[]", "failed"],
  ["created_at_from", "2026-07-01"],
  ["created_at_to", "2026-07-31"],
]);
const result = await fetch(`${baseUrl}/organizations/${organizationId}/event-destinations/deliveries?${query}`, {
  method: "GET",
  headers: {
    Authorization: `Bearer ${token}`,
    Accept: "application/json",
  },
}).then((response) => response.json());

Retrieve a single delivery with its full data: the exact payload Enlivy sent, the HTTP status and body your endpoint returned, and whether it was a retry. Use this to debug a failed delivery.

GET/organizations/<organization_id>/event-destinations/deliveries/<event_delivery_id>

curl 'https://api.enlivy.com/organizations/<organization_id>/event-destinations/deliveries/<event_delivery_id>' \
  -H "Authorization: Bearer $ENLIVY_API_TOKEN" \
  -H 'Accept: application/json'

# Returns: event, status, request_payload (what we sent),
# response_status + response_type + response (what your endpoint replied), is_retry.

const baseUrl = "https://api.enlivy.com";
const token = process.env.ENLIVY_API_TOKEN;
const organizationId = "<organization_id>";
const eventDeliveryId = "<event_delivery_id>";

const result = await fetch(`${baseUrl}/organizations/${organizationId}/event-destinations/deliveries/${eventDeliveryId}`, {
  method: "GET",
  headers: {
    Authorization: `Bearer ${token}`,
    Accept: "application/json",
  },
}).then((response) => response.json());

// Returns: event, status, request_payload (what we sent),
// response_status + response_type + response (what your endpoint replied), is_retry.

Delete a destination to stop all delivery to it. To pause temporarily instead, set is_active false with a PUT.

DELETE/organizations/<organization_id>/event-destinations/<event_destination_id>

curl -X DELETE 'https://api.enlivy.com/organizations/<organization_id>/event-destinations/<event_destination_id>' \
  -H "Authorization: Bearer $ENLIVY_API_TOKEN" \
  -H 'Accept: application/json'

const baseUrl = "https://api.enlivy.com";
const token = process.env.ENLIVY_API_TOKEN;
const organizationId = "<organization_id>";
const eventDestinationId = "<event_destination_id>";

const result = await fetch(`${baseUrl}/organizations/${organizationId}/event-destinations/${eventDestinationId}`, {
  method: "DELETE",
  headers: {
    Authorization: `Bearer ${token}`,
    Accept: "application/json",
  },
}).then((response) => response.json());