Available Operations

Status: stable Category: catalog Added: 2026-04-20 Last reviewed: 2026-04-21

Summary

Returns every (category, resource, operation, http_method, path, version) tuple the API advertises, in a flat array. This is the smallest catalog endpoint: no descriptions, no aliases, no nesting — just enough to build or check a routing table.

Unlike the other catalog endpoints, this one does not accept ?audience=. Operation paths and versions are language-invariant; there are no audience-specific labels at the operation level that would need translating.

Endpoint

Field	Value
Method	`GET`
Path	`/api/catalog/operations`
Full URL	`https://engine.tripod-health.com/api/catalog/operations`
Authentication	API key (required)
Request body	none
Response body	`application/json`
Idempotent	Yes
Rate-limited	Yes

Purpose

Minimal client codegen. When a codegen tool only needs the routing table (method + path + version), this response contains exactly that and nothing more.
Contract verification in CI. A pipeline can snapshot this list and diff it between deploys to detect when paths are added, moved, or removed.
Smoke tests. Iterate the list, call each GET path, and assert non-5xx — a cheap liveness sweep across the whole API.

Authentication

Send a valid API key in the apikey header. See authentication.md.

Request

Headers

Header	Required	Description
`apikey`	Yes	Consumer API key.
`X-Request-ID`	No	Optional correlation ID. Echoed in the `X-Request-ID` response header.

Path parameters

None.

Query parameters

None.

This endpoint intentionally does not accept ?audience=. Every other /api/catalog/* endpoint does, because they return entities that carry a translatable display_name. Operations have no such field in this response — they are just paths. A client sending ?audience= here will find it silently ignored; the response is identical regardless.

Body

None.

Response

Success — `200 OK`

Top-level array. Truncated for readability:

[
  {
    "category": "pain",
    "resource": "orebro",
    "operation": "questions",
    "http_method": "GET",
    "path": "/api/pain/orebro/questions",
    "version": "0.1.0"
  },
  {
    "category": "pain",
    "resource": "orebro",
    "operation": "score",
    "http_method": "POST",
    "path": "/api/pain/orebro/score",
    "version": "0.1.0"
  },
  {
    "category": null,
    "resource": "cdri",
    "operation": "compute",
    "http_method": "POST",
    "path": "/api/cdri/compute",
    "version": "0.1.0"
  },
  {
    "category": null,
    "resource": "health",
    "operation": "check",
    "http_method": "GET",
    "path": "/api/health/check",
    "version": "0.1.0"
  }
]

Response fields

The top-level value is a JSON array. Each element:

Field	Type	Always present	Description
`category`	`string \| null`	Yes	Category the operation belongs to. `null` for top-level resources (`cdri`, `phenotype`, `screen`, `naics`, `health`, `version`, `catalog`, `debug`).
`resource`	`string`	Yes	Resource name.
`operation`	`string`	Yes	Operation name.
`http_method`	`"GET" \| "POST"`	Yes	HTTP method for this operation.
`path`	`string`	Yes	Fully-qualified URL path, including the `/api/` prefix. Concatenate with `https://engine.tripod-health.com` to form the complete URL.
`version`	`string` (SemVer)	Yes	Operation-level version. Independent of resource, category, and catalog versions.

Status codes

Code	Meaning	When
`200`	OK	Array returned.
`401`	`Unauthenticated`	Missing or invalid API key.
`429`	`RateLimited`	Per-consumer rate limit exceeded.

Unlike the other catalog endpoints, this one cannot return 400 ValidationError — it reads no query parameters.

Examples

The language-specific invocations below assume the call() helper (or its equivalent) from quickstart.md.

1. Canonical request and response

Send:

GET /api/catalog/operations HTTP/1.1
Host: engine.tripod-health.com
apikey: $ENGINE_API_KEY
X-Request-ID: docs-catalog-operations-canonical

Receive (200 OK): a flat JSON array of (category, resource, operation, http_method, path, version) tuples. The live response today carries 40 operations. First three entries, verbatim:

[
  {
    "category": "pain",
    "resource": "orebro",
    "operation": "questions",
    "http_method": "GET",
    "path": "/api/pain/orebro/questions",
    "version": "0.1.0"
  },
  {
    "category": "pain",
    "resource": "orebro",
    "operation": "score",
    "http_method": "POST",
    "path": "/api/pain/orebro/score",
    "version": "0.1.0"
  },
  {
    "category": "pain",
    "resource": "pain_scale",
    "operation": "questions",
    "http_method": "GET",
    "path": "/api/pain/pain_scale/questions",
    "version": "0.1.0"
  }
]

2. Calling the endpoint in your language

curl

# Flat operation list
curl -sS "https://engine.tripod-health.com/api/catalog/operations" \
  -H "apikey: $ENGINE_API_KEY"

# Filter to POST operations via jq
curl -sS "https://engine.tripod-health.com/api/catalog/operations" \
  -H "apikey: $ENGINE_API_KEY" \
  | jq '[ .[] | select(.http_method == "POST") ]'

Python (`requests`) — build a routing table

# Uses the call() helper from quickstart.md.
operations = call("GET", "/api/catalog/operations")
routes = {(op["http_method"], op["path"]): op for op in operations}
for (method, path), op in sorted(routes.items()):
    print(f"{method:4} {path}   v{op['version']}")

Python (`requests`) — CI contract snapshot

# Uses the call() helper from quickstart.md.
def contract_snapshot() -> list[tuple[str, str, str]]:
    return sorted(
        (op["http_method"], op["path"], op["version"])
        for op in call("GET", "/api/catalog/operations")
    )

# Store in CI. Diff against the last green build.
snapshot = contract_snapshot()

Node.js (native `fetch`) — routing map

// Uses the call() helper from quickstart.md.
const operations = await call("GET", "/api/catalog/operations");
const byResource = {};
for (const op of operations) {
  const key = op.category ? `${op.category}/${op.resource}` : op.resource;
  (byResource[key] ??= []).push(op);
}
console.log(byResource);

TypeScript

// Uses the typed call<T>() helper from quickstart.md.
interface OperationEntry {
  category: string | null;
  resource: string;
  operation: string;
  http_method: "GET" | "POST";
  path: string;
  version: string;
}

const operations = await call<OperationEntry[]>("GET", "/api/catalog/operations");

Go

// Uses the scaffold from quickstart.md; response is an array.
req, _ := http.NewRequest("GET", baseURL+"/api/catalog/operations", nil)
req.Header.Set("apikey", os.Getenv("ENGINE_API_KEY"))
resp, _ := (&http.Client{Timeout: 30 * time.Second}).Do(req)
defer resp.Body.Close()
var ops []map[string]any
json.NewDecoder(resp.Body).Decode(&ops)
for _, op := range ops {
    fmt.Printf("%-4v %v v%v\n", op["http_method"], op["path"], op["version"])
}

Java

// Uses the call() helper from quickstart.md.
String operations = call("GET", "/api/catalog/operations", null, 3);
System.out.println(operations);

C# (.NET `HttpClient`)

// Uses the Call() helper from quickstart.md.
var operations = await Call(HttpMethod.Get, "/api/catalog/operations");
foreach (var op in operations.EnumerateArray())
{
    var verb = op.GetProperty("http_method").GetString();
    var path = op.GetProperty("path").GetString();
    var version = op.GetProperty("version").GetString();
    Console.WriteLine($"{verb,-4} {path} v{version}");
}

PowerShell

# Uses the Invoke-Engine helper from quickstart.md.
$operations = Invoke-Engine -Method Get -Path "/api/catalog/operations"
foreach ($op in $operations) {
    "{0,-4} {1} v{2}" -f $op.http_method, $op.path, $op.version
}

3. Error scenarios

This endpoint has no input to validate, so it has no endpoint-specific 400s. Failure modes are limited to 401 (auth), 429 (rate limit), and 5xx (unexpected). See authentication.md and rate-limits.md.

Intended use

Minimal codegen. All a client needs to issue a correctly-shaped HTTP call is method + path. Skip the heavier /api/catalog/resources response when you only need the routing table.
Diff-based contract checks in CI. Sort the array, serialize, compare against the last known-good snapshot. New paths appear as additions; removed paths appear as deletions; version bumps appear as modifications.
Health sweeps. Iterate GET operations, call each one, assert non-5xx. A small extension (supply stub bodies) covers POST operations too.

Mistaken use

Do not send ?audience= here and expect a different response. This endpoint does not return a translatable display_name. Other catalog endpoints do.
Do not assume array order has semantic meaning. Operations appear in catalog declaration order: category-scoped operations first (ordered by category, then resource, then operation), then top-level operations. Stable for a given deploy but not sorted; sort client-side if you need a specific order.
Do not treat this as a human browsing surface. There are no descriptions, display names, or aliases here. Use /api/catalog/get or /api/catalog/resources when you need readable metadata.
Do not hardcode paths into your client instead of using this. If the catalog's paths change between deploys, a client that reads them from here survives; one that baked them in at build time breaks.

Debugging

Capture the X-Request-ID response header.
Unexpected extra operations in the response. The catalog has moved. Check /api/version/get to confirm you are hitting the deploy you expect.
A path that used to work is no longer in the list. That operation has been removed or renamed. There is no deprecation warning in the tuple itself; the absence is the signal.
No error, but the response is the same as before a known deploy. Your client or a proxy may be serving a cached copy. This endpoint is tiny and the response changes rarely — caching is usually fine, just re-fetch when /api/version/get reports a new catalog_version.

Rate limits

See rate-limits.md.

GET /api/catalog/get — full catalog tree.
GET /api/catalog/resources — flat resource list with descriptions and display names.
GET /api/catalog/categories — category tree.
GET /api/version/get — the build + catalog version pair; poll this to detect when a /operations snapshot is stale.

Change history

Date	Change
2026-04-20	Initial publication.

Summary​

Endpoint​

Purpose​

Authentication​

Request​

Headers​

Path parameters​

Query parameters​

Body​

Response​

Success — 200 OK​

Response fields​

Status codes​

Examples​

1. Canonical request and response​

2. Calling the endpoint in your language​

curl​

Python (requests) — build a routing table​

Python (requests) — CI contract snapshot​

Node.js (native fetch) — routing map​

TypeScript​

Go​

Java​

C# (.NET HttpClient)​

PowerShell​

3. Error scenarios​

Intended use​

Mistaken use​

Debugging​

Rate limits​

Related endpoints​

Change history​

Summary

Endpoint

Purpose

Authentication

Request

Headers

Path parameters

Query parameters

Body

Response

Success — `200 OK`

Response fields

Status codes

Examples

1. Canonical request and response

2. Calling the endpoint in your language

curl

Python (`requests`) — build a routing table

Python (`requests`) — CI contract snapshot

Node.js (native `fetch`) — routing map

TypeScript

Go

Java

C# (.NET `HttpClient`)

PowerShell

3. Error scenarios

Intended use

Mistaken use

Debugging

Rate limits

Related endpoints

Change history