Not directly, no — and the reason is more basic than anything that tripped up GraphQL or gRPC on their way into MCP. Those conversions had to deal with a different schema shape, but the call itself stayed the same: the client asks, the server answers. A webhook flips that. The third party decides when something happened and pushes it to you, on its own schedule, whether or not a model is sitting in a conversation waiting to hear about it. MCP tool calls don’t have a slot for that at all.

Why a webhook doesn’t fit the request/response shape

Every MCP tool call rides on JSON-RPC 2.0: the client sends a request, the server sends back a response to that specific request, and that’s the whole transaction. There’s no message type for “here’s something that happened that nobody asked about.” A webhook, by contrast, is the API-provider’s own server making an outbound HTTP call to you, whenever its event fires — a payment cleared, a deployment finished, a form was submitted. Even if an AI client happens to have an MCP session open at that exact moment, there is no mechanism for your server to reach into that session and hand the model an unsolicited result. The model has to ask. The question is what it should ask for, and when.

The three patterns that actually bridge the gap

None of them make the webhook itself speak MCP. All of them put a small piece of infrastructure between the webhook and the tool call — something that catches events as they land and holds them until a model comes looking.

  • A receiver that writes to a store, plus a pull tool. Stand up an ordinary HTTP endpoint to receive the webhook (most providers require this anyway), have it write each event to a table or queue, and expose a tool like list_new_events(since_cursor) that reads from that store. This is the most reliable pattern because it doesn’t depend on a session being open when the event arrives — the event just waits. It’s also the same cursor-based approach covered in paginating large MCP tool results, reused here for a different reason: not because one result is too big, but because new events keep arriving after the model already looked.
  • A resource with a subscription. Model the webhook feed as an MCP resource and declare the subscribe capability described in MCP resource subscriptions. Your receiver fires notifications/resources/updated the moment an event lands, and a client that already subscribed knows to re-read. This gets you something closer to real push, but only for a session that was already open and already subscribed — it does nothing for the events that happened while nobody was connected, so you still need the same durable store as the first pattern underneath it.
  • A long-running task, if the webhook is really a callback. Sometimes what looks like a webhook is actually the async completion of something the model itself kicked off — “render this video and let me know when it’s done.” If that’s the real shape, MCP Tasks is the closer-fitting primitive: the model starts a task, and a check-status call (or the task’s own completion signal) replaces the ad-hoc webhook entirely. Worth checking before you build a whole queueing layer for something that was never a general event stream to begin with.

The part a generator can’t do for you

Turning a REST API into an MCP server from an OpenAPI spec works because the spec already describes a call-and-get-a-result operation. A webhook isn’t that — it’s a promise the provider makes to call you, and no OpenAPI document or schema file can hand a generator the durable store, the cursor logic, or the decision about which of the three patterns above fits your case. That store is infrastructure you build once, by hand, the same way the GraphQL and gRPC conversions needed a hand-built bridge for the parts their schemas didn’t describe either. Set expectations accordingly: a converted API gets you most of the way for its synchronous operations, and the webhook side is always a separate, smaller project next to it.

Keep the pull tool job-shaped, not endpoint-shaped

It’s tempting to expose get_webhook_events as a raw dump of whatever the provider sent and call it done. Better to shape it around what the model actually needs to do with the events — filtered by type, summarized, or scoped to what changed since the last check — the same design question covered in designing MCP tools around agent jobs, not API endpoints. And if the provider sends a dozen different event types, resist making a dozen different tools for them; one well-designed pull tool with a type filter beats the tool-count problem described in how many tools an MCP server should expose.

Verify the webhook before you trust what’s in it

Webhook payloads arrive over the open internet to a public endpoint, so the standard practice most providers support — a signature header computed with a shared secret, checked before you accept the body — isn’t optional. That check protects your receiver, and it’s a separate layer from whatever OAuth or API key the MCP server itself requires from the AI client connecting to it; see MCP OAuth scopes explained if you’re unclear on what that second layer is actually granting. Skipping webhook signature verification means anyone who finds the receiver’s URL can inject fake events straight into whatever the model reads next.

Where gate fits: gate’s MCP Builder generates tool definitions from an OpenAPI or Swagger spec, the same synchronous, request/response path covered in turning an API into an MCP server — it doesn’t ingest webhook definitions or stand up a receiver for you. Whatever you build to bridge the webhook side, once the resulting server exists you can put the whole thing behind gate: it’s scanned for prompt injection before it goes live, the pull tool sits behind its own allow / ask / block rule like any other, and every call lands in a plain-language log. See /mcp-gateway for the full picture.

The bottom line

A webhook-based API can feed an MCP server, but never by exposing the webhook itself as a tool — there’s no request for it to respond to. The real work is a small piece of infrastructure you own: a receiver that catches and stores events, and a tool (or a subscribed resource) that lets the model pull what it needs on its own schedule instead of the provider’s. Pick the pattern based on one question — does the model need “what’s new since I last checked,” or does it need genuine push into a session that’s already open — and build the smaller of the two you actually need.