Yes, and on the discovery question it’s actually in better shape than GraphQL or a webhook-based API: a SOAP service ships a WSDL document that already describes every operation, its inputs, and its outputs, the same way an OpenAPI spec does for REST. The catch is everything downstream of that document. SOAP speaks XML, not JSON, its authentication model predates OAuth by a decade, and plenty of the services still worth converting were written before anyone thought about an AI client calling them.

Why SOAP doesn’t fit the REST playbook unchanged

An MCP tool takes JSON in and returns JSON out, matched against a JSON Schema. A SOAP call is an XML envelope — a <soap:Envelope> wrapping a header and a body, sent over HTTP with its own content type. Before any of that can become a tool call, something has to translate a JSON-shaped argument into a well-formed XML request, send it, parse the XML response back out, and map it onto the result shape a model expects. None of that is new in kind — gRPC needed the same kind of bridge for its binary wire format — but XML brings its own wrinkles: namespaces, nested complex types, and two different encoding styles (document/literal and the older RPC/encoded) that a converter has to recognize before it can generate a correct schema.

What WSDL gives you that GraphQL and webhooks don’t

WSDL (Web Services Description Language) is SOAP’s contract document: it lists every operation, the XML Schema for its input and output messages, and the binding that says how to actually reach the service over the wire. That’s a real schema to generate from — closer to an OpenAPI document than to GraphQL introspection, and far more than a webhook gives you, since nothing describes a webhook payload up front. A generator that can parse WSDL knows the full operation list and the exact shape of every message without guessing, which is exactly why standalone SOAP-to-MCP tools exist at all.

What already exists for this conversion

A handful of projects take a WSDL file or URL and produce an MCP server from it. We haven’t run any of these through our own scanner, so treat this as a starting point to evaluate against your own service, not a recommendation.

  • Runtime bridges that parse WSDL on connect. legacy2mcp and soap-mcp-server both take a WSDL and generate one MCP tool per operation at startup, named after the operation. Another, mcp2ws, takes the same approach against a WSDL file passed on the command line. legacy2mcp’s own docs describe excluding operations that look like writes by name unless you explicitly allow them — a default worth keeping, not a limitation to work around.
  • A gateway that fronts SOAP with REST and MCP together. SOAP API Gateway converts a WSDL service into a REST-style interface and runs a separate MCP server process alongside it, with support for WS-Security UsernameToken credentials passed through environment configuration.
  • A no-code option for mixed estates. Hosted tools like AnythingMCP describe building a SOAP connector from a WSDL URL through a dashboard, alongside REST and GraphQL connectors, for teams that don’t want to run a generator by hand for every protocol they still have in production.

Authentication is where SOAP diverges hardest from everything else in this series

REST, GraphQL, and gRPC services mostly authenticate with a bearer token or mutual TLS — mechanisms an MCP bridge can hold onto cleanly, as covered in MCP OAuth scopes explained. Plenty of SOAP services, especially older enterprise ones, instead expect WS-Security: a signed or plaintext username/password token embedded in the SOAP header itself, sometimes alongside a SAML assertion. That credential has to be constructed and attached to every outbound envelope by the bridge, not handed to the model and not exposed as a tool input argument. If the service you’re converting still runs over WS-Security, budget time for this part specifically — it’s the one piece in a SOAP conversion that doesn’t have a close analog in the REST, GraphQL, or gRPC posts in this series.

Curate the generated tool list the same way

A WSDL with sixty operations becomes a sixty-tool MCP server the moment a generator runs unmodified — the same problem covered in how many tools an MCP server should expose. WSDL doesn’t mark an operation as a read or a write any more reliably than a gRPC method name does, so confirm each generated tool is correctly annotated before trusting it; see MCP tool annotations. And because plenty of SOAP services were built for a specific internal caller with no expectation that every operation would ever be exposed at once, check for anything closer to excessive agency than to a tool a model actually needs — an admin-only operation sitting in the same WSDL as the public ones is a common pattern in legacy services, and a generator has no way to know the difference.

Where gate fits: gate’s MCP Builder generates tool definitions from an OpenAPI or Swagger spec today, the REST path covered in turning an API into an MCP server — it doesn’t parse WSDL or speak SOAP directly. Whichever of the tools above you use to bridge a SOAP service, once the resulting MCP server exists you can put it behind gate: it’s scanned for prompt injection before it goes live, each generated tool sits behind its own allow / ask / block rule, and every call lands in a plain-language log. See /mcp-gateway for the full picture.

The bottom line

A SOAP API can become an MCP server, and WSDL actually makes discovery easier than GraphQL introspection or a bare webhook ever could. What doesn’t get easier: XML has to become JSON somewhere in the chain, WS-Security credentials need a home that isn’t the tool’s input schema, and a generated tool list from a decades-old service needs the same curation — read/write labeling, pruning, scope review — as any other auto-converted API before an agent gets near it.