Missions API

Run, manage and build missions from your own code over HTTP: tokens, every endpoint, errors, jobs, worked examples.

For developers integrating their own systems with missions. The OpenAPI file loads into Postman, Swagger UI or a client generator.

Updated Oct 19, 2026

Run, manage and build your missions from your own systems — a script, a CI job, an operations portal, a scheduler — over HTTP.

You want to You call
Ask a mission a question and get its answer POST /missions/{id}/chat, then GET …/chat/{conversationId}?wait=60
See what is waiting for approval, and approve or reject it GET /missions/{id}/decisions?status=pending, POST …/decisions/{decisionId}/decide
Feed events from your system into a mission POST /missions/{id}/watchers/{watcherId}/events
Read and change a mission's records GET/POST/PATCH/DELETE /missions/{id}/tables/{table}/rows…
See every mission, its status and health; pause or activate one GET /missions, GET /missions/{id}/health, PATCH /missions/{id}
Change settings, connections, people, schedules, agents /missions/{id}/settings, /connections, /roles, /schedules, /agents
Install a mission from a bundle, upgrade it, export it POST /missions, POST /missions/{id}/upgrade, GET /missions/{id}/export
Change how a mission works: watchers, playbooks, rules, pages /missions/{id}/watchers, /playbooks, /rules, /pages, …

Every path below is under https://<your-missions-host>/missions/api/v1. The complete machine-readable description — every field of every request and response — is served by your own installation at GET /missions/api/v1/openapi.json (OpenAPI 3.1). Load it into Postman, Swagger UI or a client generator.

Everything the API does is the same code the Missions screens run: the same approval limits, the same mission lock, the same audit trail. A change made through the API appears in the mission's history under the token's user.


1. Tokens

Send a token on every call:

Authorization: Bearer <token>

(X-Iris-Api-Key: <token> also works.) There are two kinds.

Personal token iris_pat_… Service token iris_svc_…
Acts as You A StudioX user you create for the integration
Made by Anyone, for themselves A business administrator
Made in Missions → Settings → API Access Missions → Settings → Service tokens
Chat, building agents, MCP tools Work while your Studio sign-in is recent Always work — nobody needs to be signed in
Business The one you were in when you made it The service user's business
Use it for Your own scripts, trying things out Systems that run on their own

A token can be limited to what it may do (scopes) and given an expiry. A token with no scopes may do everything its user may do.

Scope Allows
runtime Chat, approvals, watchers runs and events, reading mission data, files, health and usage
manage Status, settings, connections, people, schedules, agents; raising a decision for a person; reading how a mission is built
build Create, upgrade, clone, export missions; create and change watchers, playbooks, rules, procedures, pages, gates, ontologies, checkpoints
data:write Add, change and delete mission rows

A service token, or any token limited by scopes, works on /missions/api/v1 only. A service token sees its own business's missions and no others.

Tokens are made and revoked only in the Missions screens, never through the API, so a token that leaks cannot make more. A revoked token stops working within a minute. Only a hash of each token is stored; it is shown once, when it is made.

Setting up a service token

  1. In Studio, create a user for the integration — for example missions-api@<your-company> — in your business, with the role the integration needs (a business administrator role if it will change settings, people or mission data).
  2. Sign in to Studio as that user and generate its API key: Studio → Settings → Profile → API Key → Generate. Copy it and sign out. (A business administrator can always generate one; other roles only where the business allows API access.)
  3. Sign in as a business administrator, open Missions → Settings → Service tokens, paste the service user's API key, choose what the token may do and, optionally, when it expires.
  4. Tick Run this business's background work as this user if you want watchers, webhooks, playbooks and approvals from email to run as the service user instead of as whoever last opened each mission. One token per business can hold this.
  5. Copy the iris_svc_… token. It is shown once.

If the service user's API key is generated again in Studio, the old key stops working and so does the service token: make a new service token with the new key.

Check a token with:

export MISSIONS="https://<your-missions-host>/missions/api/v1"
export TOKEN="iris_svc_…"
curl -s -H "Authorization: Bearer $TOKEN" "$MISSIONS/me"
{ "email": "missions-api@example.com", "business": "…", "tokenKind": "service",
  "scopes": ["runtime", "manage"], "role": "business-admin",
  "studioxCredential": "ok", "missionCount": 12 }

studioxCredential says whether calls that reach the agents, StudioX or MCP tools will work now: ok, missing or expired. For a service token it is always ok while the service user's key is current.


2. How the API behaves

JSON in, JSON out. File uploads are multipart/form-data; exports are application/zip.

Errors are always { "error": "<what went wrong>", "code": "<code>" }, sometimes with more detail (missingSettings, scope, reason, details).

Status code Means
400 invalid_request The request is wrong; error says how
401 — No token, or it is unknown, revoked or expired
403 scope_missing The token is not allowed this; scope names what it needs
403 forbidden Your role does not allow this (e.g. business administrators only)
403 locked The mission is locked against changes of this kind
404 not_found It does not exist, or you cannot see it
409 conflict Someone changed it since you read it (see below), or it is in a state that refuses this
409 studiox_session_stale A personal token whose Studio sign-in has lapsed; sign in once, or use a service token
429 rate_limited Over 600 requests a minute for this token; wait Retry-After seconds
502 upstream_error A connected system (an MCP server) refused or failed

Lists take page (from 1) and pageSize, and answer with the page and a total.

Status of a mission is draft, active or paused.

Who may change a mission. Running a mission — chat, approvals, events, its records — needs only that you can see it. Changing how it is set up or built (anything needing manage or build) also needs edit rights on it: you created it, it is shared with you for editing, or you are a business administrator. A service user is usually made a business administrator for this reason.

Long operations run as jobs. Creating, upgrading or rebuilding a mission answers 202 at once:

{ "jobId": "5e0c…", "status": "queued", "kind": "create-mission", "poll": "/missions/api/v1/jobs/5e0c…" }

Read GET /jobs/{jobId} until status is succeeded or failed. steps shows progress; result is the outcome; error says why it failed.

Changing what someone else may be changing. Read the object, keep its updatedAt, and send it back as expectedUpdatedAt with your change. If someone changed it in between you get 409 conflict instead of overwriting their work.

Audit. Every change, every chat and every MCP tool run through the API is recorded in the mission's audit log with the token's user and kind.


3. Running a mission

Ask a question

MID="<mission id>"
CID=$(curl -s -X POST -H "Authorization: Bearer $TOKEN" -H "Content-Type: application/json" \
  -d '{"message":"Which cases breached their SLA this week?"}' \
  "$MISSIONS/missions/$MID/chat" | jq -r .conversationId)

curl -s -H "Authorization: Bearer $TOKEN" "$MISSIONS/missions/$MID/chat/$CID?wait=60" | jq -r .reply

?wait=60 holds the request until the answer is ready (up to 60 s); without it the call answers at once with status: "running" and you call again. Send conversationId with the next message to continue the same conversation. GET …/chat/{conversationId}/trace shows how the answer was reached: which agents and tools were used and for how long. When a conversation has been handed to a person, the reply says status: "with-a-person".

Approvals

# what is waiting
curl -s -H "Authorization: Bearer $TOKEN" "$MISSIONS/missions/$MID/decisions?status=pending&pageSize=50"

# one decision, and who may approve it
curl -s -H "Authorization: Bearer $TOKEN" "$MISSIONS/missions/$MID/decisions/$DID"

# approve it
curl -s -X POST -H "Authorization: Bearer $TOKEN" -H "Content-Type: application/json" \
  -d '{"action":"approve","notes":"Checked against the contract"}' \
  "$MISSIONS/missions/$MID/decisions/$DID/decide"

The approval limits set on the mission's roles apply exactly as in the approvals queue: above your limit you get 403 with the limit; a decision that needs a second approver records yours and answers awaiting. A decision with options takes {"optionId": "…"} instead of action. Your system can also raise a decision for a person to make: POST /missions/{id}/decisions with event, what and why (scope manage); the mission's reviewers are emailed as usual.

Feed events in

A watcher set to be triggered by a webhook takes your rows:

curl -s -X POST -H "Authorization: Bearer $TOKEN" -H "Content-Type: application/json" \
  -d '[{"alarm_id":"A-1042","site":"ESP-17","severity":"major","raised_at":"2026-10-16T13:05:00Z"}]' \
  "$MISSIONS/missions/$MID/watchers/$WID/events"

The body is an array of rows, an object holding them under the watcher's rows key, or a single row. Up to 500 rows a call; sending the same row twice stores it once. POST …/watchers/{watcherId}/run runs any watcher now; GET …/watchers/{watcherId}/logs shows what its runs did.

A system that cannot hold a token can still push to the watcher's own webhook URL; a business administrator finds those URLs at GET /missions/{id}/endpoints.

Mission records

curl -s -H "Authorization: Bearer $TOKEN" "$MISSIONS/missions/$MID/tables"
curl -s -H "Authorization: Bearer $TOKEN" \
  "$MISSIONS/missions/$MID/tables/cases/rows?filter[status]=open&sort=opened_at&dir=desc&pageSize=100"
curl -s -X PATCH -H "Authorization: Bearer $TOKEN" -H "Content-Type: application/json" \
  -d '{"set":{"status":"closed"}}' "$MISSIONS/missions/$MID/tables/cases/rows/CASE-118"

Reading and writing records is for business administrators, as on the Database page. Writing needs the data:write scope and follows the same rules as the mission's own agents: only the mission's columns, never a credential column, every change recorded in the mission's history. A mission marked sensitive, or one whose design forbids exporting its data, does not open its records to the API.

How records are connected

Once the mission's tables are linked to its ontology (the Ontologies page, or PUT /missions/{id}/ontology/mappings), ask how your records are connected. With a question, the AI plans the walk and code runs it; with a plan, nothing but code runs:

curl -s -X POST -H "Authorization: Bearer $TOKEN" -H "Content-Type: application/json" \
  -d '{"question":"Which customers are affected if router PE-SEA-01 goes down?"}' \
  "$MISSIONS/missions/$MID/ontology/traverse"
curl -s -X POST -H "Authorization: Bearer $TOKEN" -H "Content-Type: application/json" \
  -d '{"plan":{"start":{"table":"routers","key":"PE-SEA-01"},
       "path":[{"via":"dependsOn","direction":"in","maxHops":3},{"via":"serves","direction":"out"}],
       "target":"Customer"}}' \
  "$MISSIONS/missions/$MID/ontology/traverse"

Each result carries its path (pe1.sea1 (PE-SEA-01) ⟵ depends on ⟵ … ⟶ serves ⟶ Northwind Traders (CUST-01)), and plan in the answer is the plan that ran, to keep and replay. "out" follows the record's own link column; "in" finds the records whose link names it. A walk reads only. Uploading an ontology under a name the mission already has makes its next version: list them at …/ontologies/{ontologyId}/versions, compare two at …/diff?from=1&to=3, restore one with …/restore, download its file at …/source.


4. Seeing and changing missions

curl -s -H "Authorization: Bearer $TOKEN" "$MISSIONS/missions?include=readiness"
curl -s -H "Authorization: Bearer $TOKEN" "$MISSIONS/missions/$MID/health"

# pause, then activate
curl -s -X PATCH -H "Authorization: Bearer $TOKEN" -H "Content-Type: application/json" \
  -d '{"status":"paused"}' "$MISSIONS/missions/$MID"
curl -s -X PATCH -H "Authorization: Bearer $TOKEN" -H "Content-Type: application/json" \
  -d '{"status":"active"}' "$MISSIONS/missions/$MID"

Activation is refused while a required setting is empty; the answer lists them in missingSettings. Set them with PUT /missions/{id}/settings:

curl -s -X PUT -H "Authorization: Bearer $TOKEN" -H "Content-Type: application/json" \
  -d '{"values":{"inbox":"noc-cases@example.com"},"secrets":{"servicenow":{"password":"…"}}}' \
  "$MISSIONS/missions/$MID/settings"

Secrets can be written but are never returned. When the mission's review policy sends settings changes to review, the answer is the change request rather than the change.


5. Building and updating missions

Install a mission from a bundle

# what the bundle needs from you
curl -s -X POST -H "Authorization: Bearer $TOKEN" -F file=@network-desk.sxm "$MISSIONS/bundles/inspect"

# install it, connect it, set it up, and switch it on — one job
curl -s -X POST -H "Authorization: Bearer $TOKEN" -F file=@network-desk.sxm \
  -F 'options={"name":"Network Desk",
               "integrationBindings":{"servicenow":"https://mcp.example.com/servicenow/mcp"},
               "settings":{"inbox":"noc-cases@example.com"},
               "enableWatchers":true,"activate":true}' \
  "$MISSIONS/missions"
# → 202 { "jobId": "…", "poll": "/missions/api/v1/jobs/…" }

curl -s -H "Authorization: Bearer $TOKEN" "$MISSIONS/jobs/$JOB"

The job runs what the install screens run: import, settings, connections, building the agents, switching on watchers, activation. result.mission is the new mission. If activation was refused for an empty setting, the job still succeeds with the mission created, the activate step failed and the list in result.missingSettings. A mission can also be created from a blueprint ({"blueprint": {…}}) or from the prebuilt gallery (GET /prebuilts, then {"prebuiltId": "…"}).

Change a mission's design and upgrade it

curl -s -H "Authorization: Bearer $TOKEN" "$MISSIONS/missions/$MID/blueprint" > blueprint.json
# edit blueprint.json
curl -s -X POST -H "Authorization: Bearer $TOKEN" -H "Content-Type: application/json" \
  -d "{\"blueprint\": $(jq .blueprint blueprint.json), \"dryRun\": true}" "$MISSIONS/missions/$MID/upgrade"
curl -s -X POST -H "Authorization: Bearer $TOKEN" -H "Content-Type: application/json" \
  -d "{\"blueprint\": $(jq .blueprint blueprint.json)}" "$MISSIONS/missions/$MID/upgrade"

dryRun shows what would change without changing anything. An upgrade only adds: new tables, columns, settings, watchers, agents and knowledge; pages are rebuilt. Data, decisions and setting values are never touched, and anything the new design no longer has is reported in findings and left in place. New watchers arrive switched off — switch them on with PATCH /missions/{id}/watchers/{watcherId} {"isEnabled": true}.

GET /missions/{id}/export?includeData=true downloads the mission as a bundle to install elsewhere; POST /missions/{id}/clone copies it here.


6. Reference

Generated from the server's own catalog by node scripts/v1-reference-md.mjs — 160 operations. Request and response bodies: GET /missions/api/v1/openapi.json.

Platform

Method Path What it does Scope Needs
GET /version Version and build of this Missions server any
GET /openapi.json This API as OpenAPI 3.1 any
GET /me Who the token acts as, and what it may do any

Jobs

Method Path What it does Scope Needs
GET /jobs Jobs you started, newest first any
GET /jobs/{jobId} One job: status, steps, result or error any

Chat

Method Path What it does Scope Needs
POST /missions/{id}/chat Ask the mission a question runtime StudioX credential
GET /missions/{id}/chat/{conversationId} Read a conversation's reply runtime
GET /missions/{id}/chat/{conversationId}/trace How the mission reached its reply runtime
POST /missions/{id}/agents/{agentId}/chat Ask one agent directly runtime StudioX credential

Conversations

Method Path What it does Scope Needs
GET /missions/{id}/conversations The mission's conversations runtime
DELETE /missions/{id}/conversations/{conversationId} Delete one of your conversations runtime

Decisions

Method Path What it does Scope Needs
GET /missions/{id}/decisions Decisions waiting for a person, and decided ones runtime
POST /missions/{id}/decisions Ask a person to decide something manage
GET /missions/{id}/decisions/summary How many decisions wait for you, and the latest runtime
GET /missions/{id}/decisions/{decisionId} One decision, and who may approve it runtime
POST /missions/{id}/decisions/{decisionId}/decide Approve, reject or choose an option runtime

Watchers

Method Path What it does Scope Needs
GET /missions/{id}/observations Watchers with their last run, and recent agent runs runtime
GET /missions/{id}/watchers The mission's watchers runtime
POST /missions/{id}/watchers Add a watcher build
GET /missions/{id}/watchers/{watcherId} One watcher, its recent runs, and what a run reads runtime
PATCH /missions/{id}/watchers/{watcherId} Change a watcher, or turn it on or off any
DELETE /missions/{id}/watchers/{watcherId} Remove a watcher build
POST /missions/{id}/watchers/{watcherId}/run Run a watcher now runtime
POST /missions/{id}/watchers/{watcherId}/reset Let a watcher look at everything again runtime or data:write
GET /missions/{id}/watchers/{watcherId}/logs A watcher's log runtime
POST /missions/{id}/watchers/{watcherId}/events Push rows into a webhook watcher runtime
GET /missions/{id}/activity Recent watcher runs and findings runtime

Mission data

Method Path What it does Scope Needs
GET /missions/{id}/tables The mission's tables and columns runtime
GET /missions/{id}/tables/{table}/rows Rows of a mission table runtime
POST /missions/{id}/tables/{table}/rows Add a row data:write
GET /missions/{id}/tables/{table}/rows/{key} One row by its key runtime
PATCH /missions/{id}/tables/{table}/rows/{key} Change a row data:write
DELETE /missions/{id}/tables/{table}/rows/{key} Delete a row data:write

Files

Method Path What it does Scope Needs
POST /missions/{id}/files Upload a file for a mission form runtime file upload
GET /missions/{id}/files/{fileId} Download a file attached in a mission form runtime application/octet-stream

Procedures

Method Path What it does Scope Needs
GET /missions/{id}/procedure-runs Runs of the mission's procedures runtime
GET /missions/{id}/procedures The mission's procedures, with what its agents can do build or manage
POST /missions/{id}/procedures Enable a library procedure here, or write one on this mission build
GET /missions/{id}/procedures/{procedureId} One procedure, with its checks and any template update build or manage StudioX credential
PATCH /missions/{id}/procedures/{procedureId} Save the mission's copy: steps, wiring, on/off, follow updates build
DELETE /missions/{id}/procedures/{procedureId} Remove a procedure from the mission build
POST /missions/{id}/procedures/{procedureId}/validate Check a procedure (and optionally a draft of it) build StudioX credential

Health and usage

Method Path What it does Scope Needs
GET /missions/{id}/health Is the mission working right now runtime
GET /missions/{id}/cost What the mission has cost runtime
GET /missions/{id}/usage The mission's token use, by part and by person runtime
GET /missions/{id}/audit The mission's audit log runtime

Missions

Method Path What it does Scope Needs
GET /missions The missions of your business, and your own any
GET /missions/{id} One mission: its agents, readiness, install progress, lock and clock any
PATCH /missions/{id} Rename, describe, activate or pause a mission manage
DELETE /missions/{id} Delete a mission and what it made manage StudioX credential
GET /missions/{id}/readiness What blocks activation manage or build
GET /missions/{id}/provisioning Progress of the mission's background install manage or build

Settings

Method Path What it does Scope Needs
GET /missions/{id}/settings The mission's settings: definitions, values, integrations, readiness manage or build business admin
PUT /missions/{id}/settings Save settings and credentials, and optionally activate manage
GET /missions/{id}/config The reasoning core's overrides for this mission manage or build
PUT /missions/{id}/config Set or reset reasoning core overrides manage
GET /missions/{id}/autonomy When each decision type may act without an approval manage or build
PUT /missions/{id}/autonomy Save one decision type's scenarios manage business admin
GET /missions/{id}/review-policy Which changes need a change request manage or build
PATCH /missions/{id}/review-policy Turn change requests on or off per surface manage business admin

Connections

Method Path What it does Scope Needs
GET /missions/{id}/connections The servers the mission's connections point at, each checked live manage or build StudioX credential
POST /missions/{id}/connections Check a server before pointing a connection at it manage StudioX credential
PUT /missions/{id}/connections Point a connection at a server manage StudioX credential
PATCH /missions/{id}/connections Mark a connection "not connected yet" manage
GET /missions/{id}/datasources The mission's data sources, credentials masked manage or build
PUT /missions/{id}/datasources/{kind} Create or change one data source manage
DELETE /missions/{id}/datasources/{kind} Remove one data source manage
POST /missions/{id}/datasources/{kind}/rotate-token New ingest token for the event stream (shown once) manage
POST /missions/{id}/datasources/{kind}/test Test a data source the way a watcher calls it manage

People

Method Path What it does Scope Needs
GET /missions/{id}/roles The mission's roles, what each may do, and who holds them manage or build
POST /missions/{id}/roles Give a person a role on the mission manage business admin
GET /missions/{id}/reviewers The people on the mission's roster manage or build
POST /missions/{id}/reviewers Add or update a person on the roster manage business admin
DELETE /missions/{id}/reviewers/{reviewerId} Take a person off the roster manage business admin
GET /missions/{id}/sharing Who can open the mission manage or build
POST /missions/{id}/sharing Change visibility, share or unshare manage

Schedules

Method Path What it does Scope Needs
GET /missions/{id}/schedules The mission's report schedules manage or build
POST /missions/{id}/schedules Create a report schedule manage
PATCH /missions/{id}/schedules/{scheduleId} Pause, resume or edit a schedule manage
DELETE /missions/{id}/schedules/{scheduleId} Delete a schedule manage
POST /missions/{id}/schedules/{scheduleId}/send Send a schedule once, now, to yourself manage StudioX credential

Agents

Method Path What it does Scope Needs
GET /missions/{id}/agents The mission's agents any
POST /missions/{id}/agents Add an agent manage
GET /missions/{id}/agents/{agentId} One agent any
PATCH /missions/{id}/agents/{agentId} Edit an agent manage
DELETE /missions/{id}/agents/{agentId} Remove an agent build StudioX credential
GET /missions/{id}/agents/{agentId}/settings The agent's model, limits, MCP tool timeout and specialization manage or build StudioX credential
PATCH /missions/{id}/agents/{agentId}/settings Change the agent's model, limits, MCP tool timeout or specialization manage StudioX credential
GET /missions/{id}/agents/{agentId}/tables What the agent may do with the mission's tables manage or build
PATCH /missions/{id}/agents/{agentId}/tables Let the agent read or change the mission's tables, or neither manage StudioX credential
GET /missions/{id}/agents/{agentId}/knowledge The documents on the agent's bot manage or build StudioX credential
POST /missions/{id}/agents/{agentId}/knowledge Add a plain-text document to the agent's bot manage StudioX credential
PATCH /missions/{id}/agents/{agentId}/knowledge/{sourceId} Switch a document on or off, or replace its text manage StudioX credential
DELETE /missions/{id}/agents/{agentId}/knowledge/{sourceId} Remove a document from the agent's bot manage StudioX credential
GET /missions/{id}/agents/{agentId}/mcp MCP servers you may use, each marked on or off for this agent manage or build StudioX credential
POST /missions/{id}/agents/{agentId}/mcp Switch an MCP server on or off for this agent manage StudioX credential

Keys

Method Path What it does Scope Needs
POST /missions/{id}/agents/{agentId}/webhook-secret New secret for the agent's webhook (shown once) manage
POST /missions/{id}/api-key New API key for the mission (shown once) manage
GET /missions/{id}/endpoints The URLs other systems push to manage or build business admin

Build

Method Path What it does Scope Needs
GET /prebuilts The Prebuilt Missions gallery any
GET /integrations Standard MCP integrations a blueprint can name, with their credential keys build or manage
POST /missions Create a mission from a bundle, a prebuilt or a blueprint build StudioX credential, job (202), file upload
POST /missions/{id}/upgrade Update a mission to a newer bundle or an edited blueprint build StudioX credential, job (202), file upload
POST /missions/{id}/finalize Build or repair the mission's bots and wiring build StudioX credential, job (202)
POST /missions/{id}/clone Copy a mission into a new one build StudioX credential
GET /missions/{id}/blueprint The mission's installed blueprint build

Bundles

Method Path What it does Scope Needs
POST /bundles/inspect Read a bundle and list what it asks before install build file upload
GET /missions/{id}/export Download the mission as a .sxm build StudioX credential, application/zip

Playbooks

Method Path What it does Scope Needs
GET /missions/{id}/playbooks The mission's playbooks, with how many watchers use each build or manage
POST /missions/{id}/playbooks Create a playbook build
GET /missions/{id}/playbooks/{playbookId} One playbook build or manage
PATCH /missions/{id}/playbooks/{playbookId} Change a playbook's name, description or content build
DELETE /missions/{id}/playbooks/{playbookId} Delete a playbook build

Rules

Method Path What it does Scope Needs
GET /missions/{id}/rules The mission's routing rules (which agent a message goes to) build or manage
POST /missions/{id}/rules Add a routing rule build
PATCH /missions/{id}/rules/{ruleId} Change a routing rule, or turn it on or off build
DELETE /missions/{id}/rules/{ruleId} Delete a routing rule build
GET /missions/{id}/formula-rules Every formula rule across the mission's watchers build or manage
PUT /missions/{id}/formula-rules Change one formula rule's expression build business admin
POST /missions/{id}/formula-rules/test Try a formula against the current rows without saving it build

Pages

Method Path What it does Scope Needs
GET /missions/{id}/pages The mission's pages build or manage
POST /missions/{id}/pages Add a page build
GET /missions/{id}/pages/{pageId} One page and its spec build or manage
PUT /missions/{id}/pages/{pageId} Replace a page's spec build
DELETE /missions/{id}/pages/{pageId} Delete a page build

Gates

Method Path What it does Scope Needs
GET /missions/{id}/gates The mission's gates build or manage
POST /missions/{id}/gates Add a gate build
GET /missions/{id}/gates/{gateId} One gate and every target it has judged build or manage
PATCH /missions/{id}/gates/{gateId} Change a gate build
DELETE /missions/{id}/gates/{gateId} Delete a gate build
POST /missions/{id}/gates/{gateId}/trigger Run a gate against a target runtime
POST /missions/{id}/gates/{gateId}/override Override a gate for a target manage or build

Ontologies

Method Path What it does Scope Needs
GET /missions/{id}/ontologies The mission's ontologies build or manage
POST /missions/{id}/ontologies Upload an ontology build file upload
GET /missions/{id}/ontologies/{ontologyId} One ontology with 20 sample triples build or manage
DELETE /missions/{id}/ontologies/{ontologyId} Delete an ontology and its triples build
POST /missions/{id}/ontologies/{ontologyId}/query Ask an ontology one question runtime
GET /missions/{id}/ontologies/{ontologyId}/versions Every kept version of an ontology build or manage
GET /missions/{id}/ontologies/{ontologyId}/diff What changed between two versions build or manage
POST /missions/{id}/ontologies/{ontologyId}/restore Restore an earlier version build
GET /missions/{id}/ontologies/{ontologyId}/source Download the file as uploaded build or manage text/plain
GET /missions/{id}/ontology/mappings The mission's tables linked to its model build or manage
PUT /missions/{id}/ontology/mappings Link the mission's tables to its model build
POST /missions/{id}/ontology/traverse How things are connected runtime

Checkpoints

Method Path What it does Scope Needs
GET /missions/{id}/checkpoints The mission's checkpoints, newest first build or manage
POST /missions/{id}/checkpoints Take a checkpoint now build
GET /missions/{id}/checkpoints/compare What changed between two checkpoints, or since one build or manage
POST /missions/{id}/checkpoints/{seq}/restore Restore the configuration to a checkpoint build business admin

MCP servers

Method Path What it does Scope Needs
GET /mcp/servers MCP servers connected to your business runtime StudioX credential
GET /mcp/servers/{id}/tools Tools of one MCP server runtime StudioX credential
POST /mcp/servers/{id}/tools/{tool} Run one tool on an MCP server runtime StudioX credential

Case Desk

Method Path What it does Scope Needs
GET /missions/{id}/case-desk/tools The desk's tools and their arguments runtime
POST /missions/{id}/case-desk/tools/{tool} Run one of the desk's tools as you runtime
GET /missions/{id}/case-desk/cases Cases you may see, newest first runtime
POST /missions/{id}/case-desk/cases File a case runtime
GET /missions/{id}/case-desk/cases/{caseNo} One case as you may see it runtime
POST /missions/{id}/case-desk/cases/{caseNo}/messages Add a note, send a reply, or post the requester's message runtime
POST /missions/{id}/case-desk/cases/{caseNo}/status Move a case to another status runtime
POST /missions/{id}/case-desk/cases/{caseNo}/documents Attach a file or a link to a case runtime

Test Impact Scout

Method Path What it does Scope Needs
POST /missions/{id}/test-impact-scout/plan The tests to run for a batch of PRs runtime

Version history

Oct 19, 2026

Ontologies: every upload format, versions you can compare and restore, the file kept, tables linked to the model, and POST /missions/{id}/ontology/traverse for how records connect.

Oct 16, 2026 · Maintained

The Missions API at /missions/api/v1: run missions (chat, approvals, watchers, records), see and change them (status, settings, connections, people, schedules, agents), and build them (install, upgrade, export, watchers, playbooks, rules, pages). Personal and service tokens, scopes, jobs, and the full endpoint reference; the OpenAPI 3.1 file loads into Postman, Swagger UI or a client generator.

Downloads

FormatFileSizeSHA-256
OpenAPI 3.1 (JSON)missions-api-openapi.json641 KBf9b276c79c2469c2df28cdc212e7ef7d88f26f3482cff7cea80eb584f2a7b405
Guide (PDF)remote-api-guide.pdf1.1 MB10f30a91f110059f5500d983ab8a8ff5d3749da237e23283ab541cb0639f634a

SHA256SUMS

Check the file is ours

Compare the file's SHA-256 with the one listed for it before you run it.

# macOS / Linux
shasum -a 256 <file>

# Windows (PowerShell)
Get-FileHash <file> -Algorithm SHA256

Related

  • Missions CLI — Run, manage and build missions from a terminal or a script: ask a mission, approve what's waiting, run watchers, change records and settings, install and upgrade missions.
  • A2A CLI — Talk to a mission — or any A2A (Agent2Agent) agent — from a terminal: read its card, send messages, stream answers.