Yes, People Still Need to Mock SOAP APIs

SOAP's reputation among developers who came up after 2012 is roughly "the thing REST replaced." That's true for new public APIs. It's not true for the actual integration landscape a lot of teams still work in: banking, insurance, a large share of healthcare-adjacent integrations, government systems, and a long tail of enterprise software with an integration layer that was built once, works, and has had no reason to be rewritten since. If your team integrates with any of those, you didn't choose SOAP — you inherited it, and it isn't going anywhere on your timeline.
Why REST-shaped mocking tools handle SOAP badly
A typical mock tool routes on URL path and HTTP method, which is exactly backwards for SOAP. A SOAP service commonly exposes one endpoint — often a single POST URL — and the operation being called lives inside the XML body, in a SOAPAction header, or as an element name inside the envelope. A mocking tool that only understands "match this path, return this JSON" has no hook to distinguish GetAccountBalance from TransferFunds when both arrive as a POST to the same URL, because the thing that actually determines the operation isn't in the URL at all — it's inside the body.
What matching actually needs to look at
Testing a SOAP integration properly means matching on an element inside the XML envelope — the operation name, an account ID nested a few levels deep, a namespace-qualified field — the same way REST mocking matches on a JSON body path, just with XML's more verbose shape and its namespace prefixes, which commonly differ between clients calling the same service and shouldn't be part of the match. And the response has to actually be XML: a valid SOAP envelope with the right Content-Type (text/xml or application/soap+xml, depending on SOAP version), not JSON with the right data wearing an XML-flavored hat.
What this looks like in practice
MockBase's SOAP & XML support matches on an element inside the envelope by name, ignoring namespace prefix differences between clients, and returns a raw XML/SOAP envelope with templating still applied — so a response can echo a value back out of the request the same way a JSON mock would, without pretending the payload is JSON when the real service would send SOAP. There's no WSDL parsing — the envelope shape still gets written by hand rather than generated from a service definition — but for the everyday case of "test this specific operation's success and fault responses," it means SOAP doesn't have to be the reason a team falls back to hitting the real staging service, just because their mocking tool quietly assumed everything modern runs over a REST path.
Xerat02
Building MockBase.
More from the blog

When Your Mock Lies to You: The Contract Drift Problem
Mocking a dependency is a productivity win right up until the mock quietly stops matching reality — at which point it's worse than not having one, because it gives you false confidence.

GraphQL Doesn't Kill the Need to Mock — It Just Moves It
A GraphQL mock that returns one fixed body for every request to /graphql tells you almost nothing — the client's query, not the URL, determines what a real server would actually send back.