Docs

Build on api.insure

One API for claims and coverage. Your agent runs the open work over HTTP or MCP, and every reserved act returns a typed state until a licensed professional performs it.

Quickstart

Every call below runs keyless in the sandbox, on synthetic files. Four calls take you from discovery to a claim waiting on a licensed adjuster.

Discover every door.The capability card names the HTTP routes, the MCP server and the pricing document.
keyless read
```
$ curl https://api.insure/.well-known/agents.json
```
Read the claims collection.Filter by peril or stage. A filter that matches nothing answers a typed EMPTY.
keyless read
```
$ curl 'https://api.insure/claims?peril=wind_hail'
```

File a claim and watch it stop.The open work runs, then the claim waits on a licensed adjuster for the reserved act.

answers 202, then PENDING_ADJUSTER

$ curl -X POST https://api.insure/claims \    -H 'content-type: application/json' \    -d '{"policy":"HO3-4482-TX","loss":{"date":"2026-07-14","peril":"wind_hail","state":"TX"}}'

Hand it to your agent.The same nouns and verbs as MCP tools, over streamable HTTP.
MCP config
```
{  "mcpServers": {    "api.insure": { "url": "https://api.insure/mcp" }  }}
```

Where to next

ReferenceEvery route, one contractClaims, coverage, documents and events, with request and response JSON. MCPTools for your agentThe streamable HTTP server and its tools. They stop exactly where the API stops. Humans in the loopWhere the state says licensedHow a reserved act reaches a licensed professional, and what comes back. PricingPriced per actA flat fee for each reserved act, fixed when you post it. No decision, no charge.

Concepts

Open work and reserved acts

intakeacknowledgeassemblecoverage readestimate reviewquote mathdocument prep

investigateadjustsettlesellsolicitnegotiatebind

open: your agent, at API speedreserved: a licensed adjuster or producer, under their own license

The state reserves a few acts to licensed people: adjusting and settling a claim, and selling, negotiating and binding coverage. Everything else is open work. The line is drawn per state and line of authority, and the API's types stop your agent at it. Negotiating a settlement is speech, so it is gated when it is said, not only when it is signed.

Typed states

Every response is an envelope with a type. A record that waits on a reserved act carries a pending status that names who it waits on, so it never stalls silently.

type	HTTP	Means
`OK`	`200` read, `202` write	The call did what it asked.
`EMPTY`	`200`	A truthful empty collection, never a bare list posing as data.
`BLOCKED`	`401`, `403`	A permission boundary, with a worded reason.
`OFFER`	`402`	The call would pass your spend ceiling. The body carries the offer.

status	Waits on	Clears on
`PENDING_ADJUSTER`	A licensed adjuster, for an adjuster-reserved act	`decision.issued`, a send-back, or a declination that reroutes the file
`PENDING_PRODUCER`	A licensed producer, for a producer-reserved act	`policy.bound`, or a bind that does not complete

Claim stages

noticeacknowledgeinvestigateevaluatedecidepay

a statutory clock runs to this stage

A claim moves through six stages, derived from its committed events. The statute's own verbs (acknowledge, decide, pay) are stage verbs, so the clock and the lifecycle are one machine. A claim reaches PENDING_ADJUSTER once the file is ready for the decision, and leaves it when a licensed adjuster attests.

The parties

The API types the parties distinctly instead of blurring them into one client.

Carrier

The principal. Delegated authority flows from its claims-handling agreement.

Policyholder

Owed good-faith handling and the statutory clocks, on the record.

Claimant

Adverse in third-party claims, and typed that way.