REST API

Webhook Endpoints API

Create, list, and manage webhook endpoint configurations programmatically. Requires the release_webhooks feature flag.

Overview#

Webhook endpoints define where Manza sends outbound event notifications. For payload formats, signing, retries, and event semantics, see the Webhooks guide.

Required scopes#

Endpoint	Scope
List / Get webhook endpoints	`webhook_endpoints:read`
Create / Update / Delete webhook endpoints	`webhook_endpoints:write`
Enable / Disable / Test / Regenerate secret	`webhook_endpoints:write`

Webhook endpoint object#

Field	Type	Description
`id`	string	Unique identifier (UUIDv7)
`url`	string	HTTPS destination URL
`description`	string	Optional internal label
`events`	array	Event types this endpoint subscribes to
`status`	string	active or disabled
`disabled_at`	string	ISO 8601 timestamp when disabled, or null
`last_succeeded_at`	string	ISO 8601 timestamp of the last successful delivery, or null
`created_at`	string	ISO 8601 timestamp
`updated_at`	string	ISO 8601 timestamp

signing_secret is shown once

The signing_secret is returned only when creating an endpoint or regenerating the secret. Store it immediately — it is never returned by list, get, update, enable, disable, or test responses.

List webhook endpoints#

GET /api/webhook_endpoints

Supports cursor pagination (cursor, limit 1–100, default 25).

request.sh

curl "https://ma.manza.dev/api/webhook_endpoints" \
  -H "Authorization: Bearer sk_live_..."

manza

manza webhook-endpoints list

app.js

import { Manza } from "@getmanza/sdk";
const manza = new Manza({ apiKey: process.env.MANZA_API_KEY });

await manza.webhookEndpoints.list();

app.rb

require "manza"
manza = Manza.new(api_key: ENV["MANZA_API_KEY"])

manza.webhook_endpoints.list

app.py

from manza import Manza
client = Manza()  # reads MANZA_API_KEY

client.webhook_endpoints.list()

main.go

import manza "github.com/getmanza/manza-go"

client, _ := manza.New(manza.WithAPIKey(os.Getenv("MANZA_API_KEY")))

page, err := client.WebhookEndpoints.List(ctx, manza.ListParams{})

main.rs

let client = manza::Client::builder()
    .api_key(std::env::var("MANZA_API_KEY")?)
    .build()?;

let page = client.webhook_endpoints().list(Default::default())?;

app.exs

{:ok, client} = Manza.new(api_key: System.fetch_env!("MANZA_API_KEY"))

{:ok, page} = Manza.WebhookEndpoints.list(client)

app.cr

require "manza"

client = Manza::Client.new # reads MANZA_API_KEY

page = client.webhook_endpoints.list

app.php

use Manza\Client;

$client = new Client(apiKey: getenv('MANZA_API_KEY'));

$page = $client->webhookEndpoints->list();

response.json

{
  "data": [
    {
      "id": "019dde72-02ed-7a23-aaca-98c40c48e6b6",
      "url": "https://example.com/webhooks/manza",
      "description": "Production",
      "events": ["payment_link.paid", "transfer.executed"],
      "status": "active",
      "disabled_at": null,
      "last_succeeded_at": "2026-04-30T11:14:00Z",
      "created_at": "2026-04-30T10:30:00Z",
      "updated_at": "2026-04-30T10:30:00Z"
    }
  ],
  "has_more": false,
  "next_cursor": null
}

Required: url (must be HTTPS; private, loopback, and link-local IPs are rejected) and events (must contain supported subscribable events). A signing secret is generated automatically and returned once.

request.sh

curl -X POST "https://ma.manza.dev/api/webhook_endpoints" \
  -H "Authorization: Bearer sk_live_..." \
  -H "Content-Type: application/json" \
  -d '{
  "url": "https://example.com/webhooks/manza",
  "description": "Production",
  "events": ["payment_link.paid", "transfer.executed"]
}'

manza

manza webhook-endpoints create --url https://example.com/webhooks/manza --event payment_link.paid --event transfer.executed

app.js

import { Manza } from "@getmanza/sdk";
const manza = new Manza({ apiKey: process.env.MANZA_API_KEY });

await manza.webhookEndpoints.create({
  url: "https://example.com/webhooks/manza",
  events: ["payment_link.paid", "transfer.executed"],
});

app.rb

require "manza"
manza = Manza.new(api_key: ENV["MANZA_API_KEY"])

manza.webhook_endpoints.create(
  url: "https://example.com/webhooks/manza",
  events: ["payment_link.paid", "transfer.executed"],
)

app.py

from manza import Manza
client = Manza()  # reads MANZA_API_KEY

client.webhook_endpoints.create(
    url="https://example.com/webhooks/manza",
    events=["payment_link.paid", "transfer.executed"],
)

main.go

import manza "github.com/getmanza/manza-go"

client, _ := manza.New(manza.WithAPIKey(os.Getenv("MANZA_API_KEY")))

endpoint, err := client.WebhookEndpoints.Create(ctx, manza.Attributes{
    "url":    "https://example.com/webhooks/manza",
    "events": []string{"payment_link.paid", "transfer.executed"},
})

main.rs

let client = manza::Client::builder()
    .api_key(std::env::var("MANZA_API_KEY")?)
    .build()?;

let endpoint = client.webhook_endpoints().create(&serde_json::json!({
    "url": "https://example.com/webhooks/manza",
    "events": ["payment_link.paid", "transfer.executed"],
}))?;

app.exs

{:ok, client} = Manza.new(api_key: System.fetch_env!("MANZA_API_KEY"))

{:ok, endpoint} =
  Manza.WebhookEndpoints.create(client, %{
    "url" => "https://example.com/webhooks/manza",
    "events" => ["payment_link.paid", "transfer.executed"]
  })

app.cr

require "manza"

client = Manza::Client.new # reads MANZA_API_KEY

endpoint = client.webhook_endpoints.create(
  url: "https://example.com/webhooks/manza",
  events: ["payment_link.paid", "transfer.executed"]
)

app.php

use Manza\Client;

$client = new Client(apiKey: getenv('MANZA_API_KEY'));

$endpoint = $client->webhookEndpoints->create([
    'url' => 'https://example.com/webhooks/manza',
    'events' => ['payment_link.paid', 'transfer.executed'],
]);

created.json

{
  "id": "019dde72-02ed-7a23-aaca-98c40c48e6b6",
  "url": "https://example.com/webhooks/manza",
  "description": "Production",
  "events": ["payment_link.paid", "transfer.executed"],
  "status": "active",
  "disabled_at": null,
  "last_succeeded_at": null,
  "created_at": "2026-04-30T10:30:00Z",
  "updated_at": "2026-04-30T10:30:00Z",
  "signing_secret": "whsec_..."
}

Copy the signing secret now

The signing_secret (a random whsec_ value) is shown only once in this response. Use it to verify webhook signatures — see the Webhooks guide.

Get webhook endpoint#

GET /api/webhook_endpoints/:id

Returns the webhook endpoint object without signing_secret.

request.sh

curl "https://ma.manza.dev/api/webhook_endpoints/019dde72-02ed-7a23-aaca-98c40c48e6b6" \
  -H "Authorization: Bearer sk_live_..."

manza

manza webhook-endpoints get 019dde72-02ed-7a23-aaca-98c40c48e6b6

app.js

import { Manza } from "@getmanza/sdk";
const manza = new Manza({ apiKey: process.env.MANZA_API_KEY });

await manza.webhookEndpoints.get("019dde72-02ed-7a23-aaca-98c40c48e6b6");

app.rb

require "manza"
manza = Manza.new(api_key: ENV["MANZA_API_KEY"])

manza.webhook_endpoints.get("019dde72-02ed-7a23-aaca-98c40c48e6b6")

app.py

from manza import Manza
client = Manza()  # reads MANZA_API_KEY

client.webhook_endpoints.get("019dde72-02ed-7a23-aaca-98c40c48e6b6")

main.go

import manza "github.com/getmanza/manza-go"

client, _ := manza.New(manza.WithAPIKey(os.Getenv("MANZA_API_KEY")))

endpoint, err := client.WebhookEndpoints.Get(ctx, "019dde72-02ed-7a23-aaca-98c40c48e6b6")

main.rs

let client = manza::Client::builder()
    .api_key(std::env::var("MANZA_API_KEY")?)
    .build()?;

let endpoint = client.webhook_endpoints().get("019dde72-02ed-7a23-aaca-98c40c48e6b6")?;

app.exs

{:ok, client} = Manza.new(api_key: System.fetch_env!("MANZA_API_KEY"))

{:ok, endpoint} = Manza.WebhookEndpoints.get(client, "019dde72-02ed-7a23-aaca-98c40c48e6b6")

app.cr

require "manza"

client = Manza::Client.new # reads MANZA_API_KEY

endpoint = client.webhook_endpoints.get("019dde72-02ed-7a23-aaca-98c40c48e6b6")

app.php

use Manza\Client;

$client = new Client(apiKey: getenv('MANZA_API_KEY'));

$endpoint = $client->webhookEndpoints->get('019dde72-02ed-7a23-aaca-98c40c48e6b6');

Update webhook endpoint#

PATCH /api/webhook_endpoints/:id

Update the destination url, description, or subscribed events. Returns the updated object without signing_secret.

request.sh

curl -X PATCH "https://ma.manza.dev/api/webhook_endpoints/019dde72-02ed-7a23-aaca-98c40c48e6b6" \
  -H "Authorization: Bearer sk_live_..." \
  -H "Content-Type: application/json" \
  -d '{
  "url": "https://example.com/webhooks/manza-v2",
  "description": "Production v2",
  "events": ["payment_link.paid"]
}'

manza

manza webhook-endpoints update 019dde72-02ed-7a23-aaca-98c40c48e6b6 --url https://example.com/webhooks/manza-v2 --event payment_link.paid

app.js

import { Manza } from "@getmanza/sdk";
const manza = new Manza({ apiKey: process.env.MANZA_API_KEY });

await manza.webhookEndpoints.update("019dde72-02ed-7a23-aaca-98c40c48e6b6", {
  url: "https://example.com/webhooks/manza-v2",
  events: ["payment_link.paid"],
});

app.rb

require "manza"
manza = Manza.new(api_key: ENV["MANZA_API_KEY"])

manza.webhook_endpoints.update("019dde72-02ed-7a23-aaca-98c40c48e6b6",
  url: "https://example.com/webhooks/manza-v2",
  events: ["payment_link.paid"],
)

app.py

from manza import Manza
client = Manza()  # reads MANZA_API_KEY

client.webhook_endpoints.update("019dde72-02ed-7a23-aaca-98c40c48e6b6",
    url="https://example.com/webhooks/manza-v2",
    events=["payment_link.paid"],
)

main.go

import manza "github.com/getmanza/manza-go"

client, _ := manza.New(manza.WithAPIKey(os.Getenv("MANZA_API_KEY")))

endpoint, err := client.WebhookEndpoints.Update(ctx, "019dde72-02ed-7a23-aaca-98c40c48e6b6", manza.Attributes{
    "url":    "https://example.com/webhooks/manza-v2",
    "events": []string{"payment_link.paid"},
})

main.rs

let client = manza::Client::builder()
    .api_key(std::env::var("MANZA_API_KEY")?)
    .build()?;

let endpoint = client.webhook_endpoints().update("019dde72-02ed-7a23-aaca-98c40c48e6b6", &serde_json::json!({
    "url": "https://example.com/webhooks/manza-v2",
    "events": ["payment_link.paid"],
}))?;

app.exs

{:ok, client} = Manza.new(api_key: System.fetch_env!("MANZA_API_KEY"))

{:ok, endpoint} =
  Manza.WebhookEndpoints.update(client, "019dde72-02ed-7a23-aaca-98c40c48e6b6", %{
    "url" => "https://example.com/webhooks/manza-v2",
    "events" => ["payment_link.paid"]
  })

app.cr

require "manza"

client = Manza::Client.new # reads MANZA_API_KEY

endpoint = client.webhook_endpoints.update("019dde72-02ed-7a23-aaca-98c40c48e6b6",
  url: "https://example.com/webhooks/manza-v2",
  events: ["payment_link.paid"]
)

app.php

use Manza\Client;

$client = new Client(apiKey: getenv('MANZA_API_KEY'));

$endpoint = $client->webhookEndpoints->update('019dde72-02ed-7a23-aaca-98c40c48e6b6', [
    'url' => 'https://example.com/webhooks/manza-v2',
    'events' => ['payment_link.paid'],
]);

Disable webhook endpoint#

POST /api/webhook_endpoints/:id/disable

Disables delivery to the endpoint (returns the object with status: "disabled"). Existing delivery logs remain available in the dashboard.

request.sh

curl -X POST "https://ma.manza.dev/api/webhook_endpoints/019dde72-02ed-7a23-aaca-98c40c48e6b6/disable" \
  -H "Authorization: Bearer sk_live_..."

manza

manza webhook-endpoints disable 019dde72-02ed-7a23-aaca-98c40c48e6b6

app.js

import { Manza } from "@getmanza/sdk";
const manza = new Manza({ apiKey: process.env.MANZA_API_KEY });

await manza.webhookEndpoints.disable("019dde72-02ed-7a23-aaca-98c40c48e6b6");

app.rb

require "manza"
manza = Manza.new(api_key: ENV["MANZA_API_KEY"])

manza.webhook_endpoints.disable("019dde72-02ed-7a23-aaca-98c40c48e6b6")

app.py

from manza import Manza
client = Manza()  # reads MANZA_API_KEY

client.webhook_endpoints.disable("019dde72-02ed-7a23-aaca-98c40c48e6b6")

main.go

import manza "github.com/getmanza/manza-go"

client, _ := manza.New(manza.WithAPIKey(os.Getenv("MANZA_API_KEY")))

endpoint, err := client.WebhookEndpoints.Disable(ctx, "019dde72-02ed-7a23-aaca-98c40c48e6b6")

main.rs

let client = manza::Client::builder()
    .api_key(std::env::var("MANZA_API_KEY")?)
    .build()?;

let endpoint = client.webhook_endpoints().disable("019dde72-02ed-7a23-aaca-98c40c48e6b6")?;

app.exs

{:ok, client} = Manza.new(api_key: System.fetch_env!("MANZA_API_KEY"))

{:ok, endpoint} = Manza.WebhookEndpoints.disable(client, "019dde72-02ed-7a23-aaca-98c40c48e6b6")

app.cr

require "manza"

client = Manza::Client.new # reads MANZA_API_KEY

endpoint = client.webhook_endpoints.disable("019dde72-02ed-7a23-aaca-98c40c48e6b6")

app.php

use Manza\Client;

$client = new Client(apiKey: getenv('MANZA_API_KEY'));

$endpoint = $client->webhookEndpoints->disable('019dde72-02ed-7a23-aaca-98c40c48e6b6');

Enable webhook endpoint#

POST /api/webhook_endpoints/:id/enable

Re-enables delivery (returns the object with status: "active") and clears any in-progress failure window.

request.sh

curl -X POST "https://ma.manza.dev/api/webhook_endpoints/019dde72-02ed-7a23-aaca-98c40c48e6b6/enable" \
  -H "Authorization: Bearer sk_live_..."

manza

manza webhook-endpoints enable 019dde72-02ed-7a23-aaca-98c40c48e6b6

app.js

import { Manza } from "@getmanza/sdk";
const manza = new Manza({ apiKey: process.env.MANZA_API_KEY });

await manza.webhookEndpoints.enable("019dde72-02ed-7a23-aaca-98c40c48e6b6");

app.rb

require "manza"
manza = Manza.new(api_key: ENV["MANZA_API_KEY"])

manza.webhook_endpoints.enable("019dde72-02ed-7a23-aaca-98c40c48e6b6")

app.py

from manza import Manza
client = Manza()  # reads MANZA_API_KEY

client.webhook_endpoints.enable("019dde72-02ed-7a23-aaca-98c40c48e6b6")

main.go

import manza "github.com/getmanza/manza-go"

client, _ := manza.New(manza.WithAPIKey(os.Getenv("MANZA_API_KEY")))

endpoint, err := client.WebhookEndpoints.Enable(ctx, "019dde72-02ed-7a23-aaca-98c40c48e6b6")

main.rs

let client = manza::Client::builder()
    .api_key(std::env::var("MANZA_API_KEY")?)
    .build()?;

let endpoint = client.webhook_endpoints().enable("019dde72-02ed-7a23-aaca-98c40c48e6b6")?;

app.exs

{:ok, client} = Manza.new(api_key: System.fetch_env!("MANZA_API_KEY"))

{:ok, endpoint} = Manza.WebhookEndpoints.enable(client, "019dde72-02ed-7a23-aaca-98c40c48e6b6")

app.cr

require "manza"

client = Manza::Client.new # reads MANZA_API_KEY

endpoint = client.webhook_endpoints.enable("019dde72-02ed-7a23-aaca-98c40c48e6b6")

app.php

use Manza\Client;

$client = new Client(apiKey: getenv('MANZA_API_KEY'));

$endpoint = $client->webhookEndpoints->enable('019dde72-02ed-7a23-aaca-98c40c48e6b6');

Send test event#

POST /api/webhook_endpoints/:id/test

Queues a test.ping delivery to the endpoint. The endpoint must be active. Responds 202 Accepted.

request.sh

curl -X POST "https://ma.manza.dev/api/webhook_endpoints/019dde72-02ed-7a23-aaca-98c40c48e6b6/test" \
  -H "Authorization: Bearer sk_live_..."

manza

manza webhook-endpoints test 019dde72-02ed-7a23-aaca-98c40c48e6b6

app.js

import { Manza } from "@getmanza/sdk";
const manza = new Manza({ apiKey: process.env.MANZA_API_KEY });

await manza.webhookEndpoints.test("019dde72-02ed-7a23-aaca-98c40c48e6b6");

app.rb

require "manza"
manza = Manza.new(api_key: ENV["MANZA_API_KEY"])

manza.webhook_endpoints.test_endpoint("019dde72-02ed-7a23-aaca-98c40c48e6b6")

app.py

from manza import Manza
client = Manza()  # reads MANZA_API_KEY

client.webhook_endpoints.test_endpoint("019dde72-02ed-7a23-aaca-98c40c48e6b6")

main.go

import manza "github.com/getmanza/manza-go"

client, _ := manza.New(manza.WithAPIKey(os.Getenv("MANZA_API_KEY")))

result, err := client.WebhookEndpoints.Test(ctx, "019dde72-02ed-7a23-aaca-98c40c48e6b6")

main.rs

let client = manza::Client::builder()
    .api_key(std::env::var("MANZA_API_KEY")?)
    .build()?;

let result = client.webhook_endpoints().test("019dde72-02ed-7a23-aaca-98c40c48e6b6")?;

app.exs

{:ok, client} = Manza.new(api_key: System.fetch_env!("MANZA_API_KEY"))

{:ok, result} = Manza.WebhookEndpoints.test(client, "019dde72-02ed-7a23-aaca-98c40c48e6b6")

app.cr

require "manza"

client = Manza::Client.new # reads MANZA_API_KEY

result = client.webhook_endpoints.test("019dde72-02ed-7a23-aaca-98c40c48e6b6")

app.php

use Manza\Client;

$client = new Client(apiKey: getenv('MANZA_API_KEY'));

$result = $client->webhookEndpoints->test('019dde72-02ed-7a23-aaca-98c40c48e6b6');

test.json

{
  "delivery_id": "019dde72-0538-7795-a0b2-48c7097e9827",
  "status": "queued"
}

Regenerate signing secret#

POST /api/webhook_endpoints/:id/regenerate_secret

Rotates the endpoint signing secret and returns the new value (the object includes signing_secret). Requests sent after rotation are signed with the new secret.

Endpoints that approve transfers

While an endpoint is enrolled for transfer authorization, regenerating its secret returns 422 and changing its url is refused. Its secret rotates only in the app, behind a two-factor step: Settings → Developer → Transfer approval → Rotate secret.

request.sh

curl -X POST "https://ma.manza.dev/api/webhook_endpoints/019dde72-02ed-7a23-aaca-98c40c48e6b6/regenerate_secret" \
  -H "Authorization: Bearer sk_live_..."

manza

manza webhook-endpoints regenerate-secret 019dde72-02ed-7a23-aaca-98c40c48e6b6

app.js

import { Manza } from "@getmanza/sdk";
const manza = new Manza({ apiKey: process.env.MANZA_API_KEY });

await manza.webhookEndpoints.regenerateSecret("019dde72-02ed-7a23-aaca-98c40c48e6b6");

app.rb

require "manza"
manza = Manza.new(api_key: ENV["MANZA_API_KEY"])

manza.webhook_endpoints.regenerate_secret("019dde72-02ed-7a23-aaca-98c40c48e6b6")

app.py

from manza import Manza
client = Manza()  # reads MANZA_API_KEY

client.webhook_endpoints.regenerate_secret("019dde72-02ed-7a23-aaca-98c40c48e6b6")

main.go

import manza "github.com/getmanza/manza-go"

client, _ := manza.New(manza.WithAPIKey(os.Getenv("MANZA_API_KEY")))

endpoint, err := client.WebhookEndpoints.RegenerateSecret(ctx, "019dde72-02ed-7a23-aaca-98c40c48e6b6")

main.rs

let client = manza::Client::builder()
    .api_key(std::env::var("MANZA_API_KEY")?)
    .build()?;

let endpoint = client.webhook_endpoints().regenerate_secret("019dde72-02ed-7a23-aaca-98c40c48e6b6")?;

app.exs

{:ok, client} = Manza.new(api_key: System.fetch_env!("MANZA_API_KEY"))

{:ok, endpoint} = Manza.WebhookEndpoints.regenerate_secret(client, "019dde72-02ed-7a23-aaca-98c40c48e6b6")

app.cr

require "manza"

client = Manza::Client.new # reads MANZA_API_KEY

endpoint = client.webhook_endpoints.regenerate_secret("019dde72-02ed-7a23-aaca-98c40c48e6b6")

app.php

use Manza\Client;

$client = new Client(apiKey: getenv('MANZA_API_KEY'));

$endpoint = $client->webhookEndpoints->regenerateSecret('019dde72-02ed-7a23-aaca-98c40c48e6b6');

Delete webhook endpoint#

DELETE /api/webhook_endpoints/:id

Deletes the endpoint: it stops receiving events and no longer appears in the list. Its delivery history is retained so Manza support can trace past deliveries. Responds 204 No Content.

request.sh

curl -X DELETE "https://ma.manza.dev/api/webhook_endpoints/019dde72-02ed-7a23-aaca-98c40c48e6b6" \
  -H "Authorization: Bearer sk_live_..."

manza

manza webhook-endpoints delete 019dde72-02ed-7a23-aaca-98c40c48e6b6

app.js

import { Manza } from "@getmanza/sdk";
const manza = new Manza({ apiKey: process.env.MANZA_API_KEY });

await manza.webhookEndpoints.delete("019dde72-02ed-7a23-aaca-98c40c48e6b6");

app.rb

require "manza"
manza = Manza.new(api_key: ENV["MANZA_API_KEY"])

manza.webhook_endpoints.delete("019dde72-02ed-7a23-aaca-98c40c48e6b6")

app.py

from manza import Manza
client = Manza()  # reads MANZA_API_KEY

client.webhook_endpoints.delete("019dde72-02ed-7a23-aaca-98c40c48e6b6")

main.go

import manza "github.com/getmanza/manza-go"

client, _ := manza.New(manza.WithAPIKey(os.Getenv("MANZA_API_KEY")))

_, err := client.WebhookEndpoints.Delete(ctx, "019dde72-02ed-7a23-aaca-98c40c48e6b6")

main.rs

let client = manza::Client::builder()
    .api_key(std::env::var("MANZA_API_KEY")?)
    .build()?;

client.webhook_endpoints().delete("019dde72-02ed-7a23-aaca-98c40c48e6b6")?;

app.exs

{:ok, client} = Manza.new(api_key: System.fetch_env!("MANZA_API_KEY"))

{:ok, _} = Manza.WebhookEndpoints.delete(client, "019dde72-02ed-7a23-aaca-98c40c48e6b6")

app.cr

require "manza"

client = Manza::Client.new # reads MANZA_API_KEY

client.webhook_endpoints.delete("019dde72-02ed-7a23-aaca-98c40c48e6b6")

app.php

use Manza\Client;

$client = new Client(apiKey: getenv('MANZA_API_KEY'));

$client->webhookEndpoints->delete('019dde72-02ed-7a23-aaca-98c40c48e6b6');

Supported events#

Event	Trigger
`checkout_session.completed`	Fires when a checkout session receives a confirmed payment
`checkout_session.settled`	Fires when the provider settles a checkout session payment
`payment_link.paid`	Fires when a payment link receives a payment
`payment_link.payment_settled`	Fires when the provider settles a payment link payment
`transfer.executed`	Fires when an outgoing transfer is executed

The test.ping event can be sent with the test endpoint, but it is not a subscribable event.

Error responses#

Scenario	Status	Type	Param
Missing or invalid API key	401	`authentication_error`	—
Missing required scope	403	`insufficient_scope`	—
Webhooks not enabled	403	`forbidden_error`	—
Endpoint not found	404	`not_found_error`	—
Non-HTTPS URL	422	`validation_error`	`url`
Private IP URL	422	`validation_error`	`url`
Unknown event name	422	`validation_error`	`events`
Test disabled endpoint	422	`state_error`	—