canonical: https://jentic.com/apis/anyhook.net/anyhook

# AnyHook API

The AnyHook API relays inbound webhooks from providers such as Stripe, GitHub, and Shopify, giving each relay app an inbound URL that receives and verifies events. Its management surface creates and configures apps, connects a provider with a single key, queries a searchable event delivery log, and re-delivers events, either one at a time or by bulk-replaying an app's failed deliveries. It also lists undelivered events, rotates destination signing secrets, and manages API keys.

## For AI agents

Create webhook relay apps, connect providers like Stripe and GitHub, query the event delivery log, and replay failed or missed webhook deliveries.

## Scope

Does not send outbound email, SMS, or push notifications, and does not host your application. Use for relaying inbound provider webhooks and tracking their delivery only.

## Capabilities

- Create webhook relay apps and configure their destinations
- Connect Stripe or GitHub with a single provider key
- Query the event delivery log across apps
- Replay a single event or bulk-replay an app's failed deliveries
- List the undelivered events for an app
- Rotate a destination signing secret and manage API keys

## Use cases

### AI agent wiring up webhook relays

An integration agent needs to start receiving a provider's webhooks without a developer configuring endpoints by hand. Through Jentic the agent searches for connecting a provider webhook, loads the connect operation with the key already injected, and registers the webhook so events begin flowing to a relay app. For providers beyond Stripe and GitHub, it creates an app first to obtain an inbound URL.

Example prompt: Call POST `/api/v1/connect` with a Stripe key, then GET `/api/v1/events` to confirm the first event arrived

### Recovering missed webhooks

When a downstream service was down, an agent needs to find the deliveries that failed and send them again. AnyHook lists the undelivered events for an app and can re-deliver a single event or bulk-replay all failed ones, so the agent can recover a backlog without the provider resending. This closes the gap left by a temporary outage.

Example prompt: Call GET `/api/v1/apps/{slug}/events/undelivered`, then POST `/api/v1/apps/{slug}/replay-failed` to resend them

### Inspecting webhook delivery

A support agent investigating a missing event queries the delivery log to see whether the webhook was received and how its delivery attempts went. AnyHook exposes a searchable event log and per-event replay, so the agent can confirm receipt, inspect the delivery history, and re-send a specific event if needed. This answers 'did the webhook arrive?' directly from the API.

Example prompt: Call GET `/api/v1/events` filtered to one app, then POST `/api/v1/events/{id}/replay` for the event that failed

## Key endpoints

| Method | Path | Description |
| --- | --- | --- |
| POST | `/api/v1/apps` | Create a new webhook relay app |
| GET | `/api/v1/apps` | List all relay apps |
| POST | `/api/v1/connect` | Connect Stripe or GitHub with a single key |
| GET | `/api/v1/events` | Query the event delivery log |
| POST | `/api/v1/events/{id}/replay` | Re-deliver a specific event |
| POST | `/api/v1/apps/{slug}/replay-failed` | Bulk-replay an app's failed events |

## Key resources

- **Apps** — Create, list, update, and delete relay apps and connect providers like Stripe and GitHub
- **Events** — Query the delivery log, list undelivered events, and replay single or failed deliveries
- **Keys and secrets** — Manage API keys and rotate destination signing secrets

## AI readiness

This API is usable in Jentic One now. Its AI-readiness score against Jentic's framework shows where it stands today and where improvements would make it even easier for agents to use.

- **Score:** 66 / 100
- **Maturity:** AI-Aware
- **Dimensions:**
  - Foundational Compliance: 93 / 100
  - Developer Experience & Jentic Compatibility: 63 / 100
  - AI-Readiness & Agent Experience: 45 / 100
  - Agent Usability: 94 / 100
  - Security: 60 / 100
  - AI Discoverability: 87 / 100
- **View full report:** https://jentic.com/apis/anyhook.net/anyhook/scorecard
- **How the score is calculated:** https://docs.jentic.com/reference/api-readiness-framework/overview/
- **More about the dimensions:** https://docs.jentic.com/reference/api-readiness-framework/specification/#dimensional-model-overview

### Score it yourself

Every API in the directory is allowlisted, so you can re-score it with no key required.

- **Score your own API:** https://jentic.com/scorecard.md
- **Scoring CLI agent skill:** https://github.com/jentic/jentic-api-scorecard/blob/main/skills/jentic-api-scorecard/SKILL.md

```sh
npx @jentic/api-scorecard-cli score <openapi-url>
```

## Why Jentic

- **Setup:** Wiring AnyHook by hand means creating relay apps, authenticating the management calls with your ahk_live bearer key, and leaving the ingress endpoint open because it verifies HMAC signatures itself. Through Jentic you install once, import AnyHook from the API Directory, store the key once, and your agent calls it.
- **Permission scoping:** AnyHook puts the app slug in the management URL path (`/api/v1/apps/{slug}/...`), so a rule can pin your agent to one app and the operations you pick, such as reading its event log and replaying failures. You choose the operations it may call, so destructive ones like deleting an app or creating API keys stay out unless you add them.
- **Credential handling:** Your AnyHook bearer key is stored once, encrypted, by your own Jentic One instance and injected at execution time. It never enters the agent's prompt, logs, or context.
- **Discovery method:** Agents search Jentic by intent such as 'replay a failed webhook' or 'query the delivery log', and Jentic returns the matching AnyHook operation with its input schema so the agent calls the right endpoint without reading the reference docs.

## Related APIs

- **Hookdeck API** — A webhook gateway with queuing, filtering, and retries as an alternative relay layer
- **Relayhook API** — Another webhook relay service for receiving and forwarding provider events
- **Ably Control API** — Manages realtime messaging channels for pushing events on to end clients after relay

## FAQ

### What authentication does the AnyHook API use?

The management API authenticates with a bearer key sent as Authorization: Bearer in the ahk_live format, per its OpenAPI spec. The ingress endpoint that receives provider webhooks needs no credential, because AnyHook verifies the HMAC signature on each inbound event instead. Through Jentic the bearer key is injected at call time for the management operations.

### Can I replay a webhook that failed to deliver?

Yes. Call POST `/api/v1/events/{id}/replay` to re-deliver a single event, or POST `/api/v1/apps/{slug}/replay-failed` to bulk-replay every failed delivery for an app. You can first call GET `/api/v1/apps/{slug}/events/undelivered` to see what still needs sending.

### What are the rate limits for the AnyHook API?

The OpenAPI spec does not state numeric rate limits. Throughput is governed by your plan and by how many relay apps and events your account processes. Check the AnyHook documentation for the current limits on your key before scripting large bulk replays.

### Is there an AnyHook API MCP server?

You don't need an MCP server to give your agent the AnyHook API. Jentic connects it directly from the API Directory: import the API, store your bearer key once, and your agent calls operations such as GET `/api/v1/events` on demand without loading another server's tool definitions into its context.

### Can I limit what my agent is allowed to do with the AnyHook API?

Yes. Write a rule that allows only the event-log read and the replay operations, so the agent can inspect deliveries and resend failed events but cannot delete an app or create new API keys, and every call it makes is logged. Destructive management operations stay out of the allowed set until you add them.

### How do I query the webhook delivery log through Jentic?

Search Jentic for 'query webhook delivery log', load the GET `/api/v1/events` operation, and run it after your bearer key is stored. To run it on your own infrastructure, install Jentic One from its GitHub repo.