What it does
AI assistants often write API calls that look right but use a path, a parameter or a field that the API does not have. Paste your OpenAPI document and the code that calls the API. The tool finds each call, matches its URL to a path in the document and lists the differences. Every finding names the place in the document that backs it up (a JSON pointer such as #/paths/~1users/post) or says that there is no matching entry.
What it reads
- OpenAPI: versions 3.0 and 3.1, as JSON or YAML. References that point inside the same document (
#/components/...) are followed. References to other files or URLs are not loaded, and the tool says so. - Code: curl commands, JavaScript
fetchandaxios(includingaxios.createwith a base URL), Pythonrequestsandhttpx(including sessions and clients with a base URL), and raw HTTP text with a Host header. The method, URL, query, headers and a JSON or form body are read when they are written out in the snippet. - Servers: the base path from
serversis removed before matching, and path templates such as/users/{id}match any value.
What it checks
- Paths and methods: a path that is not in the document (with up to three "did you mean" suggestions), and a method that the path does not define.
- Parameters: query parameters that are not defined, required query, header and cookie parameters that are missing, and values with the wrong primitive type or outside an
enum(a shallow check). - Body: body fields that are not in the schema, required fields that are missing, fields with the wrong primitive type, a body that is missing or not expected, and a content type that the operation does not accept.
- Authentication: a missing credential, a header or scheme that does not match
securitySchemes(for example Basic where Bearer is declared), and credentials sent where none are declared. - Deprecation: operations and parameters marked
deprecated.
What it cannot catch
- Anything that happens at run time. A URL, header or body built from variables, template expressions, spreads or function calls is shown as not resolved and is not checked.
- Whether the real API matches its document. If the document is out of date or incomplete, correct calls can be flagged and wrong calls can pass.
- Deep schema rules. Type checks are shallow. Formats, patterns, lengths, ranges,
oneOfandanyOfbranch choice,discriminatorand cross-field rules are not validated. A value that goes through a helper or a client wrapper is not seen. - Code that is not a direct call. Generated clients, SDK methods, GraphQL and other languages are not read. Calls that the tool cannot find are not reported.
- Whether a call is allowed or safe. A call with no findings is not proof that it will work, and a finding is not proof that it is wrong.
Limits
The OpenAPI document can be up to 8,000,000 characters and the snippet up to 1,000,000. At most 200 calls and 2,000 findings are kept. The check runs in a background Web Worker so the page stays responsive, and a 2 MB document is read in well under a second. A check that takes longer than 20 seconds is stopped.
Example: six calls checked against an OpenAPI document
The built-in example compares a snippet with a small “Shop API” description. The tool finds six calls and reports 4 errors and 3 warnings:
- Matches the spec: a curl call to
GET /users?limit=10has no differences. - Wrong path (error):
/useris not in the spec. The tool suggests/users. - Made-up query parameter (warning):
page_sizeis not defined forGET /users. - Wrong body (2 errors, 1 warning):
ageis the string "thirty" but the spec expects an integer, the required fieldemailis missing, andnicknameis not defined in the schema. - Method not defined (error):
PUT /users/{id}does not exist; the spec defines GET and DELETE. - Deprecated (warning):
DELETE /users/{id}is marked as deprecated.
One part, a user ID taken from a variable, cannot be worked out from the text. It is shown as not resolved and is not counted as an error. Every finding names the place in the spec that it was compared with.
Frequently asked questions
Does it call the API or run my code?
No. It reads the snippet as text, finds the HTTP calls in it and compares them with your OpenAPI document. It never runs the code and never calls an API.
Which snippets and specs are supported?
Snippets with curl, fetch, axios, Python requests or httpx, and raw HTTP. The spec is an OpenAPI 3.0 or 3.1 document in JSON or YAML. You can check the spec first with the OpenAPI Validator.
Are the findings proof of a mistake?
No. They are hints from a text comparison. Check them against the real API before you change code.
Are the spec and code uploaded?
No. Both are read on your device and never uploaded, stored or put in the URL.
Privacy
This tool runs entirely in your browser. What you enter, and any file you open, is processed on your device and is not sent to a server. The page does not write your input to local storage, cookies or the URL, and it makes no network requests to any API. To check the document itself first, use the OpenAPI Validator.