https://openapi-proxy.com

The mock in sixty seconds

Paste an OpenAPI 3.0 or 3.1 document into the box on the front page, or send it straight from a terminal:

curl -s https://openapi-proxy.com/specs -T openapi.json
https://amber-heron.openapi-proxy.com

There are two other ways in, and they are the same door.

From a URL. If the document is already hosted - a raw GitHub link, /openapi.json on a staging box, a published portal - paste the address instead and we fetch it once, now. What we keep are the bytes we fetched, not the address: the mock goes on working whether or not that URL stays up, and it never changes under you because something upstream was edited. Addresses on private networks are refused; we will fetch from the public internet on your behalf and nowhere else.

From an example. The front page carries three documents you can run in one click - a petstore, a checkout API with money and enums in it, and a minimal one-operation document in YAML. They are ordinary specs, so the mock they produce is an ordinary mock: send requests to it, break it on purpose, then paste your own.

Whichever way it arrives, you land on a page with its own address, and that address is shareable. Anyone you send it to gets the same live mock and the same console for firing requests at it, with no account and no sign-in, for as long as the mock lives.

That URL is live now. Every operation in the document answers immediately, generated from your schemas:

curl https://amber-heron.openapi-proxy.com/pets/42
{ "id": 42, "name": "string", "tag": "string" }
  • Declared example and examples values are honoured first; where there are none, values are generated from the schema - required fields present, types correct, enums picked from the declared set.
  • Content negotiation follows the spec: an operation that declares application/json and text/csv answers in whichever you ask for.
  • Response selection follows the spec too: the lowest declared 2xx by default, or ask for another with Prefer: code=404.
  • A request that does not conform to the contract is answered with RFC 7807 application/problem+json naming the schema pointer at fault - so the mock is also your client's first validation pass.

An anonymous mock lives for 24 hours. Sign up (free) and it persists, becomes editable, and gains a request log.

Once it is on an account

The proxy page carries every version of the document you have uploaded, and each one has two buttons.

Download hands back the bytes that went up - byte for byte, same key order, same comments if it was YAML. That is a promise rather than a nicety: the digest shown beside each version is taken over exactly those bytes, so a document that came back reformatted would quietly invalidate every digest you had written down.

Edit opens the same add-a-version box with that version already in it, which is what you want most of the time - a new version is nearly always the current one with a change. Saving adds a version; it never overwrites the one you started from, and nothing goes live until you publish it. In-flight requests finish against the old version.

What it is for

A frontend unblocked before the backend has a repository. An SDK exercised against the contract rather than against a guess. A partner demo booked against an API that is still a document. And the quiet one: the first time your spec is loaded by a strict validator, you find out what is wrong with the spec.