Test webhook

Sends ONE signed test event to the endpoint right now and answers the outcome inline, so the console can show whether the subscriber is reachable without waiting for real traffic.

POST /v1/webhook/{id}/test

Webhook → · All API references → · Get started →

Address	`https://api.hanzo.ai/v1/webhook/{id}/test`
Method	`POST`
Operation	`post_webhook_by_id_test`
Auth	`Authorization: Bearer $HANZO_API_KEY`

Sends ONE signed test event to the endpoint right now and answers the outcome inline, so the console can show whether the subscriber is reachable without waiting for real traffic. It takes the same attempt path the bus dispatcher takes — one attempt, 10s timeout, no retry ladder — and records the result in the endpoint's delivery log. It works on a DISABLED endpoint too: validating one you have paused is the whole point.

Request

1 field.

Field	In	Type	Required	Description
`id`	path	string	yes

Response

Status	Body	Meaning
`200`	webhook.testResult	ok
`default`	problem-details	refused

200 body — 4 fields.

Field	In	Type	Always	Description
`delivered`	body	boolean	—	Delivered is whether the subscriber accepted the test POST.
`durationMs`	body	integer (int64)	—	DurationMs is how long the single attempt took, in MILLISECONDS.
`error`	body	string	—	Error says what stopped it.
`httpStatus`	body	integer (int64)	—	HTTPStatus is what the subscriber answered, or 0 if it never answered.

Failure carries the platform error shape — see Errors.

Examples

CLI

SDK

HTTP

MCP

hanzo webhook test <id>

.ts

.py

.go

.rs

.java

import { Configuration, WebhookApi } from 'hanzoai';

const api = new WebhookApi(new Configuration({ accessToken: process.env.HANZO_API_KEY }));
const { data } = await api.postWebhookByIdTest({ id: 'id' });

from hanzoai.cloud import ApiClient, Configuration
from hanzoai.cloud.api import WebhookApi

client = ApiClient(Configuration(access_token=os.environ["HANZO_API_KEY"]))
result = WebhookApi(client).post_webhook_by_id_test(id='id')

cfg := hanzoai.NewConfiguration()
cfg.AddDefaultHeader("Authorization", "Bearer "+os.Getenv("HANZO_API_KEY"))
client := hanzoai.NewAPIClient(cfg)

resp, _, err := client.WebhookAPI.PostWebhookByIdTest(context.Background()).Execute()
if err != nil {
	return err
}

use hanzo_client::apis::{configuration::Configuration, webhook_api};

let mut cfg = Configuration::new();
cfg.bearer_access_token = std::env::var("HANZO_API_KEY").ok();

let result = webhook_api::post_webhook_by_id_test(&cfg, Default::default()).await?;

import ai.hanzo.cloud.ApiClient;
import ai.hanzo.cloud.api.WebhookApi;

ApiClient client = new ApiClient();
client.setBearerToken(System.getenv("HANZO_API_KEY"));

var result = new WebhookApi(client).postWebhookByIdTest();

curl -X POST https://api.hanzo.ai/v1/webhook/<id>/test \
  -H "Authorization: Bearer $HANZO_API_KEY"

MCP reaches webhook through the webhook tool, which names its 7 operations with its own verbs — this one among them, under a name only MCP declares. describe explains any of them:

curl -X POST https://api.hanzo.ai/v1/mcp \
  -H "Content-Type: application/json" \
  -d '{
       "jsonrpc": "2.0",
       "id": 1,
       "method": "tools/call",
       "params": {
         "name": "describe",
         "arguments": {
           "op": "list_webhooks"
         }
       }
     }'

Webhook API · All Hanzo APIs · Interactive reference

Was this page useful?

PreviousCreate secret NextCreate webhook