Skip to main content
Glama

webhooks.cc

Capture webhooks and email, forward them to localhost, and put the site on your machine at a public link. A hosted service with an open source CLI (whk), SDKs for TypeScript, Python and Go, and an MCP server for AI coding agents.

CI whk Homebrew GitHub Action License @webhooks-cc/sdk SDK downloads PyPI pytest-webhooks-cc Go Reference @webhooks-cc/mcp MCP downloads MCP Registry Glama

whk tunnel forwarding three webhooks to localhost:3000, then whk share putting localhost:3000 at a public sharehooks.cc link with a QR code and three visitors

No account needed to try it: open webhooks.cc for a capture URL, send it a request, and watch it arrive.

A Stripe test webhook captured on webhooks.cc: the request list, the event's parsed JSON body, and tabs for headers, raw body and signature

If webhooks.cc saves you time, a star on this repository helps other developers find it.

Quick start

Pick where you work.

In the terminal. Install whk, sign in once, and forward a capture URL to your app, or share the app itself:

curl -fsSL https://webhooks.cc/install.sh | sh   # or: brew install kroqdotdev/tap/whk
whk auth login
whk tunnel 3000   # a webhook URL whose requests reach localhost:3000
whk share 3000    # https://<name>.sharehooks.cc, served from localhost:3000

In your coding agent. Add the remote MCP server; you approve the connection once in your browser, with no key to paste:

claude mcp add -s user --transport http webhooks-cc https://webhooks.cc/mcp

In your tests. Wait for the webhook or email your code sends, then assert on it:

npm install @webhooks-cc/sdk      # TypeScript
pip install pytest-webhooks-cc    # pytest fixtures, on the Python SDK
go get webhooks.cc/go             # Go

In the browser. Visit webhooks.cc, copy your URL, and send it a request:

curl -X POST https://go.webhooks.cc/w/<slug> -d '{"test": true}'

Related MCP server: mcp-webhook-tools

Features

  • Capture requests: store incoming webhooks with headers, body, query parameters and metadata

  • Capture email: every endpoint receives mail at {slug}@mailhooks.cc, with parsed fields, attachments and authentication results

  • Inspect in real time: see requests the moment they arrive

  • Configure responses: return custom status codes, headers and bodies, chosen by rules, to test error paths

  • Verify signatures: check provider signatures (Stripe, GitHub, Shopify and more) on captured requests

  • Forward: tunnel webhooks to localhost during development (with --live, the sender gets your local app's answer), or forward them to other URLs, chat and file drops

  • Share localhost: put the site on your machine at a public link on sharehooks.cc with whk share

  • CLI for people and agents: manage endpoints, tunnel, stream and wait for requests from your terminal, with JSON output and stable exit codes for scripts and coding agents

  • SDKs for TypeScript, Python and Go: wait for and assert on webhooks in tests and CI, and share a local port from code

  • pytest plugin: pip install pytest-webhooks-cc gives every test a capture URL and an email address as fixtures

  • GitHub Action: setup-whk installs the CLI in a workflow

  • MCP server: connect AI coding agents (Claude Code, Cursor, VS Code, Codex) to your webhooks

Use cases

Testing payment integrations: point Stripe's test webhooks at your endpoint. Inspect the payload structure before writing handlers.

Debugging CI/CD hooks: see exactly what GitHub sends when a push, PR, or deployment occurs.

Developing locally: forward production-like webhooks to localhost without exposing your machine to the internet.

Showing work in progress: send a teammate or client a link to the app running on your laptop.

Mocking failure scenarios: configure your endpoint to return 500 errors and test your retry logic.

Install

CLI

curl -fsSL https://webhooks.cc/install.sh | sh
# or
brew install kroqdotdev/tap/whk
# without root: any directory you can write to (created when missing)
curl -fsSL https://webhooks.cc/install.sh | WHK_INSTALL_DIR="$HOME/.local/bin" sh

With WHK_INSTALL_DIR, put that directory on your PATH (the installer prints the line to add) before running whk.

SDK

npm install @webhooks-cc/sdk

MCP server

# Claude Code, remote (sign in once in the browser)
claude mcp add -s user --transport http webhooks-cc https://webhooks.cc/mcp

# Claude Code, local, with an API key
claude mcp add -s user webhooks-cc -e WHK_API_KEY=whcc_... -- npx -y @webhooks-cc/mcp

# Cursor, VS Code, Devin Desktop (formerly Windsurf), Claude Desktop
npx @webhooks-cc/mcp setup cursor --api-key whcc_...

See webhooks.cc/installation for all install methods, one-click buttons, and setup guides.

CLI

whk tunnel 8080                       # Forward webhooks to localhost:8080
whk share 3000                        # Share localhost:3000 at https://<name>.sharehooks.cc
whk listen <slug>                     # Stream incoming requests, one line each
whk wait <slug> --json                # Block until the next request arrives, print it, exit
whk create my-endpoint                # Create a new endpoint
whk list                              # List your endpoints
whk replay <request-id> --to :3000    # Replay a captured request
whk api endpoints/<slug>/destinations # Call any API route with your credentials

Every command takes --json (the API's own answers, NDJSON for streams, failures as {"error": {...}} on stderr) and exits with a stable status that says what went wrong; see whk --help. Nothing waits for input without a terminal: destructive commands need --yes there.

SDK

import { WebhooksCC, matchMethod, matchHeader, matchAll } from "@webhooks-cc/sdk";

const client = new WebhooksCC({ apiKey: "whcc_..." });

const endpoint = await client.endpoints.create({ name: "my-webhook" });
console.log(endpoint.url);

// Wait for a matching request with human-readable timeout
const req = await client.requests.waitFor(endpoint.slug, {
  timeout: "30s",
  match: matchAll(matchMethod("POST"), matchHeader("stripe-signature")),
});

// Replay captured requests to your local server
await client.requests.replay(req.id, "http://localhost:3000/webhooks");

MCP server

The @webhooks-cc/mcp package exposes 94 tools (91 on the remote server) that let AI agents manage endpoints, inspect webhooks, send test payloads, replay requests, and share a local site at a public link through natural language.

You: "Create a webhook endpoint for testing Stripe"
Agent: Created endpoint "stripe-test" at https://go.webhooks.cc/w/abc123

You: "Send a test checkout.session.completed event"
Agent: Sent POST to stripe-test

You: "Replay that to my local server"
Agent: Replayed to http://localhost:3000/webhooks: 200 OK

See packages/mcp/README.md for full setup and tool reference.

Pricing

The free plan has 50 requests a day and 7 days of history, which is enough for development and testing. Pro ($8/month) and Business ($29/month) raise the limits, and teams share endpoints under a per-seat subscription. See pricing and plans and limits.

Why the code is public

webhooks.cc holds other people's webhooks and email, so the code that handles them should be open to inspection. You can read exactly how a request is captured, stored, forwarded and deleted, and check that the service does what it says. The repository is also where security scanning, dependency updates and bug reports happen in the open.

webhooks.cc is built and run by one developer. The hosted service at webhooks.cc is the product; the repository is not a community project.

Issues and contributions

  • Bugs and feature requests are welcome as issues.

  • Questions about your account, billing or data go to webhooks.cc/support, never to a public issue.

  • Security vulnerabilities are reported privately, see SECURITY.md.

  • Pull requests are accepted only from people who have signed the Contributor License Agreement. Open an issue first: most changes are made in-house, and a pull request may be closed or reimplemented. See CONTRIBUTING.md.

License

This project uses a split license:

  • AGPL-3.0: the web app, receiver, email-capture SMTP host, tunnel edge, attachment parser and database schema (apps/web/, apps/receiver-rs/, apps/mx-rs/, apps/edge-rs/, apps/parser-rs/, supabase/). See LICENSE.

  • MIT: the CLI and its tunnel protocol crate, the TypeScript, Python and Go SDKs, the pytest plugin, the MCP server, the Zapier and Make apps, and the Claude Code plugin (apps/cli-rs/, crates/tunnel/, packages/sdk/, packages/sdk-python/, packages/pytest-webhooks-cc/, packages/sdk-go/, packages/mcp/, packages/zapier-app/, packages/make-app/, plugins/). See the LICENSE file in each directory.

The CLI, SDKs and MCP server are MIT so you can use them freely in your own projects, open or closed.

Available Tools

11 tools
about_sandboxAbout sandboxA
Read-onlyIdempotent
Inspect

Explain what this agent can do without a webhooks.cc account, the sandbox limits, and how to connect an account. No network call.

Inputs: no named parameters.

connect_accountConnect accountAInspect

Connect this agent to a human's webhooks.cc account, for the full tool set (mock responses, signatures, email, teams) and to keep the sandbox endpoints. Returns a link and a 6-digit code: show both to the human, who signs in or signs up with that email and enters the code. Then call wait_for_connection. Calling again gives a new code.

Inputs: email (required).

create_endpointCreate endpointAInspect

Create a temporary webhook capture endpoint in the agent sandbox (no account needed): up to 3 endpoints at a time, 25 captured requests each and 100 in all, deleted 24 hours after the sandbox was created. The first call registers the sandbox, which takes a few seconds of proof of work. Mock responses, notifications and signature verification need an account: see connect_account.

Inputs: name, site, ephemeral, expiresIn, +6 more.

delete_endpointDelete endpointA
DestructiveIdempotent
Inspect

Delete one of this agent's sandbox endpoints and its captured requests. Frees a slot; the sandbox's request budget is not refunded.

Inputs: slug (required).

generate_payload_schemaGenerate payload schemaA
Read-onlyIdempotent
Inspect

Generate TypeScript interfaces, Zod schemas, Pydantic models, or JSON Schema from the bodies of requests captured by a sandbox endpoint. Several requests of one event teach which fields are optional or nullable.

Inputs: endpointSlug (required), name, path, event, +4 more.

get_endpointGet endpointA
Read-onlyIdempotent
Inspect

Get one of this agent's sandbox endpoints by slug, with its sandbox limits and usage.

Inputs: slug (required).

get_requestGet requestB
Read-onlyIdempotent
Inspect

Get full details for a request captured by a sandbox endpoint.

Inputs: requestId (required).

list_endpointsList endpointsA
Read-onlyIdempotent
Inspect

List this agent's sandbox endpoints. Empty until create_endpoint starts the sandbox.

Inputs: team.

list_requestsList requestsB
Read-onlyIdempotent
Inspect

List recent requests captured by a sandbox endpoint, newest first.

Inputs: endpointSlug (required), kind, limit, since.

wait_for_connectionWait for connectionA
Idempotent
Inspect

Wait for the human to enter the code from connect_account. On success the full webhooks.cc tools for their account replace these sandbox tools. Returns after timeoutSeconds (default 45) if they have not finished yet; call it again to keep waiting.

Inputs: timeoutSeconds.

wait_for_requestWait for requestC
Read-onlyIdempotent
Inspect

Wait for a request to arrive at a sandbox endpoint.

Inputs: endpointSlug (required), timeout, pollInterval.

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    TDQS

    A3.7/5.0

    Scored across 11 tools

    Disambiguation4/5

    Request tools (list/get/wait) and endpoint tools (create/list/get/delete) are clearly separated by resource and action. The only mild overlap is between about_sandbox, connect_account, and wait_for_connection, which all touch the account story, but their descriptions make the distinction clear (informational vs. initiate vs. poll).

    Naming Consistency4/5

    Nearly all tools follow a consistent snake_case verb_noun pattern (list_requests, get_endpoint, delete_endpoint, generate_payload_schema, connect_account). The lone deviation is about_sandbox, which is a noun phrase rather than a verb_noun, but it remains readable and unambiguous.

    Tool Count5/5

    Eleven tools is well within the ideal 3-15 range and each tool maps to a distinct operation in the sandbox webhook workflow. No tool feels redundant or padded.

    Completeness4/5

    Endpoint lifecycle (create/list/get/delete) and request inspection (list/get/wait) are fully covered, plus schema generation and an account-upgrade path. Minor gaps exist—no way to clear/delete individual captured requests or update an endpoint—but these are workable around given the sandbox's auto-expiry.

    Maintenance

    ActivityActive
    ResponsivenessLimited data

    Related MCP Connectors

    Related MCP Servers