API reference and discovery

Every endpoint AppEngine serves is documented in one place, generated at boot from the running route table. There is no second copy to drift: the page, the markdown, the search index and the OpenAPI document are all views of the same object.

• Browsable: /documentation — the page, with a request runner
• For agents: /llms.txt — the map, then search to one endpoint
• Machine contract: /documentation-json — OpenAPI 3, for code generation

The page

/documentation lists 3,036 endpoints across 161 sections. It loads an index first — method, path and summary only — then fetches one section when you open it. Search filters across path, summary, tag and method.

Two things on it are worth knowing about before you start calling anything.

Credentials, remembered. The panel in the sidebar holds your orgid and the two tokens, in that browser's local storage. Set them once and every request the page sends carries them. Each has a checkbox: untick to keep the value but stop sending it, which is the quickest way to see how an endpoint answers without a credential. Tokens are decoded so the panel shows who they belong to and when they expire.

Sign in without leaving. Login as user and Login as customer call /user/signin and /customer/signin and keep the token that comes back. They fill different slots — staff go in Authorization, customers in x-client-authorization — so signing in as one leaves the other alone. That is how you end up holding both, which is what the dual-token routes expect. See Conventions for what each header means.

Try it sends the real request from your browser and shows the status, elapsed time and body, plus the equivalent curl, JavaScript and Python. Those snippets are generated from the call that actually went out, so they include the headers the panel attached that you never typed — which is exactly the part you need when moving the call into your own code.

For agents and crawlers

The page renders client-side, so fetching it without JavaScript gives you a shell with no endpoints in it. Everything below is the same reference as plain text, generated from the same document.

Every link above is live — follow one to see the real thing rather than a description of it.

/api-docs, /docs and /swagger all redirect to /documentation.

Every section

The API directory lists all 161 with a direct link to each one's specification. Both map files carry the same list with URLs: /llms.txt as a short index, /documentation.md with every endpoint underneath. A few, to show the shape:

• Repository — generic data access over every datatype
• Users · Authentication — sign-in, sign-up, tokens
• Storefront — catalogue, carts, orders
• Business Made · Payroll — pay runs and payslips

The slug is the section name lowercased with non-alphanumerics replaced by hyphens, so Users · Authentication is users-authentication.

Finding one endpoint

Reading a 197 KB index to find two routes is what an agent does when nothing better is offered, and it is the thing most likely to be truncated halfway and then guessed at. Three requests get you to one endpoint, each smaller than the last.

1. Start at the map.

curl https://appengine.appmint.io/llms.txt

2. Search for what you need.

curl 'https://appengine.appmint.io/documentation/search?q=refund'

{
  "query": "refund",
  "count": 5,
  "results": [
    {
      "method": "POST",
      "path": "/finance/payments/refund",
      "summary": "Refund a payment",
      "tag": "Finance",
      "detail": "https://appengine.appmint.io/documentation/endpoint?method=POST&path=%2Ffinance%2Fpayments%2Frefund",
      "section": "https://appengine.appmint.io/documentation/tag/finance.md"
    }
  ]
}

Results are scored rather than filtered, so an exact path match ranks above a word that merely appears in a summary. Every hit carries the URL of its own detail page — nothing has to construct one.

3. Read the endpoint. Follow detail, and you get roughly 4 KB of markdown: the description, the call signature, which credentials it needs, a parameters table, the response shapes and an example.

curl 'https://appengine.appmint.io/documentation/endpoint?method=POST&path=%2Ffinance%2Fpayments%2Frefund'

Fifteen kilobytes, then a search, then four kilobytes — against 6.8 MB for the whole document.

Reading breadth-first works too: /documentation.md for the full list, /documentation/tag/<section>.md for everything in one area.

Generating a client

/documentation-json is a complete OpenAPI 3 document, which openapi-generator turns into a client for Java, C#, Python, Go, PHP, Ruby or Kotlin.

npx @openapitools/openapi-generator-cli generate \
  -i https://appengine.appmint.io/documentation-json \
  -g java -o ./appengine-java

Prefer this to writing a client by hand. A hand-written one covers the few dozen endpoints someone needed that week and starts drifting immediately; a generated one is regenerated when the API changes.

Calling something with an MCP client instead

If your agent speaks the Model Context Protocol, it does not need any of the above — it discovers services and their signatures over the protocol itself. See MCP server.

What the documentation is built from

Controllers carry no Swagger decorators. NestJS produces the skeleton — paths, methods, path parameters — and a merge pass fills it in from a documentation registry in the server source: descriptions, schemas, examples, and a per-endpoint error catalogue. Platform-wide failures (401, 403, 429, 500) are documented once and referenced, rather than repeated on all 3,036 operations.

This replaced Swagger UI, which could not render an API this size: it inlines the whole document into its bootstrap script, which came to 33 MB here, and the browser stalled before drawing anything.