API and MCP
Amendary’s REST API and MCP server let your tools read workspace data. A key can also be allowed to run checks: it asks Amendary to check a GitHub change against your engineering docs, and the findings wait for a person in the Queue.
Where is the complete API reference?
The REST API reference lists every endpoint, query parameter, response field, status value, error, pagination rule, and copyable request example. For generated clients, use the OpenAPI document at https://api.amendary.com/api/v1/openapi.json.
What can the API do?
Every key reads one workspace’s corrections, freshness, usage and mapped-page metadata. A key with the checks:run scope can also request a check of a GitHub PR or commit range against mapped engineering docs. A check spends a capped amount of model tokens and drafts findings for review; it never publishes an edit. So a key is read-only unless you allow it to run checks.
Two surfaces share one key and return the same fields: a REST API for a CI step or a script, and an MCP server for an agent.
How do I create an API key?
In the dashboard, go to Settings → API keys. Only the workspace owner can manage keys. Give the key a name, tick Allow this key to run checks if it needs checks:run, and select Create key. The key is shown once, so copy it then and store it somewhere safe. It starts with amk_.
Amendary keeps only a hash of the key, never the raw value, so a lost key cannot be recovered. To rotate, create a new key and revoke the old one.
How do I revoke a key?
On the same Settings → API keys page, select Revoke next to the key. Revoke is immediate: the next request with that key is refused. A revoked key stays listed so you can see it was in use and when it was last used.
What is the base URL and how do I authenticate?
The base URL is https://api.amendary.com/api/v1. Send your key as a bearer token on every request:
Authorization: Bearer amk_your_key_hereThe key selects the workspace, so there is no workspace header to set. The OpenAPI schema is at /api/v1/openapi.json and lists only the v1 routes.
What data can I read over REST?
Four read endpoints, all under the base URL:
GET /api/v1/corrections: pending and recent corrections with their evidence (the source, the changed paths, the stale quote, the planned edit). Paginated, newest first, with an optional status filter.GET /api/v1/checks/status: per-repo freshness. When each repo was last checked, the sha it was compared against, the last run’s outcome, and how many corrections are still pending.GET /api/v1/usage: the workspace’s token-usage summary, the same numbers Settings shows.GET /api/v1/docs: the mapped pages for a repo with a freshness record and each page’s own URL in Notion, GitHub, Zendesk or Intercom. Optional repo and title filters.
Two more endpoints run and poll checks: POST /api/v1/checks (needs checks:run) and GET /api/v1/checks/{request_id}. See the reference.
/docs returns page metadata and links, not page contents. Correction records include the stale quote and the planned edit; see Security.
What is the MCP server?
A single JSON-RPC endpoint at POST /mcp that exposes the same workspace data and change checks as MCP tools: list_corrections, get_check_status, get_usage, get_docs, check_change, and get_change_check. An agent can ask Amendary to list pending corrections or a repo’s doc freshness directly, with no dashboard round-trip.
It uses the same amk_ key as the REST API, sent as a bearer token, and the same read scope. The check_change tool additionally requires checks:run;get_change_check polls its result. The tools return the same data as REST.
Trigger payload with every field:
{
"jsonrpc": "2.0",
"id": 1,
"method": "tools/call",
"params": {
"name": "check_change",
"arguments": {
"repo": "acme/api",
"pr_number": 19,
"base": null,
"head": null,
"note": "Check the mapped engineering docs for this proposed change.",
"retry": false,
"idempotency_key": "ci-pr-19"
}
}
}Accepted response:
{
"jsonrpc": "2.0",
"id": 1,
"result": {
"content": [
{
"type": "text",
"text": "{\"id\":\"00000000-0000-4000-8000-000000000001\",\"repo_id\":\"00000000-0000-4000-8000-000000000002\",\"status\":\"queued\",\"base_sha\":\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\",\"head_sha\":\"bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\",\"result\":null,\"error\":null,\"waiting_for\":null,\"token_usage\":0,\"created_at\":\"2026-10-02T09:15:00Z\",\"started_at\":null,\"finished_at\":null}"
}
],
"structuredContent": {
"id": "00000000-0000-4000-8000-000000000001",
"repo_id": "00000000-0000-4000-8000-000000000002",
"status": "queued",
"base_sha": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
"head_sha": "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb",
"result": null,
"error": null,
"waiting_for": null,
"token_usage": 0,
"created_at": "2026-10-02T09:15:00Z",
"started_at": null,
"finished_at": null
}
}
}Poll with get_change_check and {"request_id":"00000000-0000-4000-8000-000000000001"}. The completed resource has the same fields shown in the REST reference. Tool failures return isError: true and HTTP-equivalent status/detail/headers in structuredContent.
Configure an MCP client with https://api.amendary.com/mcp and an Authorization: Bearer amk_... header. It uses a JSON-RPC POST tool flow and protocol version 2025-06-18. A client first sends initialize, thennotifications/initialized, and can calltools/list or tools/call.
{
"mcpServers": {
"amendary": {
"type": "http",
"url": "https://api.amendary.com/mcp",
"headers": { "Authorization": "Bearer amk_your_key_here" }
}
}
}Configuration keys vary by client. Keep the API key in that client’s secret or environment-variable facility rather than committing it to a repository. This is the currently supported remote MCP subset; broader client compatibility, discovery, and OAuth are roadmap work rather than implied support for every MCP client.
Is there a rate limit?
Yes. Both the REST API and the MCP server are rate limited per key, per minute. A busy poller that goes over gets a 429; slow down and retry. API reads are not written to your Activity log, so a poller cannot flood it.
What is a good way to use it?
Common setups:
- A CI step that reads pending corrections and warns on a pull request.
- A dashboard or Slack post that shows per-repo doc freshness.
- A cost check that reads the usage summary on a schedule.
- An agent that asks Amendary, over MCP, whether a repo’s docs are behind.
For what each type of page is and how corrections are drafted, see Document types and Queue & reviews.
Try Amendary on your own help center
Connect Notion, GitHub, Zendesk or Intercom and pick the articles to watch. Your first check shows what Amendary would fix, with the change as proof.
Free for 14 days with no card, and every edit waits for your review. Or free forever with your own Anthropic API key. Code is never touched.