---
title: "Coverage Cat MCP Setup"
description: "Connect Coverage Cat to your AI assistant for umbrella insurance and existing-policy support."
canonical: "https://www.coveragecat.com/developers/mcp"
last-updated: "2026-11-17"
---

# Coverage Cat MCP Setup

## Which URL to use

- ChatGPT streamable HTTP transport: `https://www.coveragecat.com/api/chatgpt/mcp`
- Other manifest-aware MCP hosts should register: `https://www.coveragecat.com/.well-known/mcp.json`
- Local Codex CLI / desktop / IDE transport URL: `https://www.coveragecat.com/api/consumer/mcp`
- Default consumer MCP server card: `https://www.coveragecat.com/.well-known/mcp/server-card.json`
- Delegated operator MCP transport: `https://www.coveragecat.com/api/agent/mcp`
- Delegated operator MCP server card: `https://www.coveragecat.com/developers/mcp/operator/server-card.json`
- If Coverage Cat MCP tools are unavailable in a runtime that supports MCP, stop and ask a short choice question instead of telling the user to register `/.well-known/mcp.json` immediately.
  Ask the question on its own line exactly as:

  Would you like to install the Coverage Cat MCP (recommended) or use the REST/CLI tools instead?

  Only share `/.well-known/mcp.json` after the user chooses MCP or asks for setup details.

## Retired homeowners services

New homeowners applications, quotes, agent search, and property insurance advice are retired.
Existing policy status, documents, and support remain available using the current authenticated context.

## Host-specific setup notes

- ChatGPT should connect directly to `/api/chatgpt/mcp`. Compare quotes and select an offer with its advertised tools, then present `checkout_url` or `payment_url` for the shopper to finish on Coverage Cat's website.
- ChatGPT document uploads and final checkout happen on the website. Keep status and policy follow-up on the same ChatGPT connection, and do not switch to the consumer or delegated APIs to bypass checkout.
- Other manifest-aware hosts should start from `/.well-known/mcp.json`.
- Local Codex clients share MCP config through `~/.codex/config.toml`; use the direct streamable HTTP consumer transport `/api/consumer/mcp`, then restart the Codex session and check `/mcp` before assuming Coverage Cat tools are unavailable.
- The default consumer MCP exposes public umbrella shopping and research tools. Use the delegated operator MCP only when you already need operator-authenticated umbrella tools and are ready for OAuth or an existing bearer token.

## Discovery links

- Consumer discovery JSON: `https://www.coveragecat.com/api/consumer`
- Consumer OpenAPI YAML: `https://www.coveragecat.com/api/consumer/openapi.yaml`
- Delegated operator discovery JSON: `https://www.coveragecat.com/api/agent`
- Delegated operator OpenAPI YAML: `https://www.coveragecat.com/api/agent/openapi.yaml`

## What the default consumer MCP exposes

Consumer-operated default subset:

- `umbrella_consumer_prefill`

- `consumer_intake_issues`
- `consumer_intake_patch`
- `umbrella_consumer_select`
- `umbrella_consumer_bind`
- `umbrella_consumer_attach`
- `umbrella_consumer_payment`
- `umbrella_consumer_policy`
- `umbrella_consumer_service`


- `homeowners_consumer_policy`
- `homeowners_consumer_service`

Consumer-operated umbrella guidance:

- Stay on that subset through quote review, declarations upload, `payment_needed`, secure payment UI when available, `payment_url` fallback, authoritative policy reads, and shopper-approved policy-support previews or requests.
- Do not switch to delegated umbrella tools just to reach checkout.
- Use those shopper surfaces only for insurance purchase and policy support; Coverage Cat records connector origin and permitted purpose on those handoffs.

Existing homeowners policy support:

- Existing homeowners policy status, documents, and support remain available; new applications and quotes are retired.

- Read-only calculator tools
- Consumer-prefill umbrella MCP tools for direct chat continuation
- Embedded docs search and docs resource reader tools
- `ui://` resources for Coverage Cat tool apps

## Umbrella planning tools

These public tools need no account or identifying information. Results include normalized inputs, assumptions, a methodology version, and source links. They calculate scenarios from the supplied numbers; they do not create insurance applications.

- `umbrella_limit_planner`: compare assets, an optional income allowance, and one applicable underlying limit against $0, $1M, $2M, $3M, $5M, and $10M umbrella scenarios. Human calculator: `/tools/umbrella-limits`.
- `umbrella_underlying_limit_check`: compare current auto split, auto combined single limit, or home liability limits with requirements from an actual umbrella quote. Omitted or null current limits remain unknown. Human calculator: `/tools/umbrella-underlying-limits`.
- `umbrella_bundle_comparison`: compare all annual auto, home, and umbrella premiums, underlying-limit upgrade costs, and one-time switching costs over a chosen period. Human calculator: `/tools/umbrella-bundle-comparison`.

Use `tools/list` for the input and output schemas. REST equivalents are under `/api/agent/calculators/` at the same path suffixes as the human calculators; their complete contract is in `/api/agent/openapi.yaml`. When the shopper wants quotes, continue with `umbrella_consumer_prefill`.

## What the delegated operator MCP adds

- Delegated umbrella MCP tools for draft, quotes, select, bind, status, and attachment upload when operator auth is present
- The same read-only tools and embedded docs search
- OAuth or an existing operator bearer token on the outer MCP request

## Transport

Coverage Cat uses streamable HTTP at the MCP endpoints above. Send JSON-RPC requests with `POST`. If your client asks for `text/event-stream`, Coverage Cat streams the MCP response as SSE.

Coverage Cat supports MCP `2026-07-28` and legacy `2025-11-25`:

- Modern requests are stateless; call tools directly or use optional `server/discover`. Include `params._meta["io.modelcontextprotocol/protocolVersion"]` and `params._meta["io.modelcontextprotocol/clientCapabilities"]` on every request.
- Send matching `MCP-Protocol-Version` and `Mcp-Method` headers. `tools/call` additionally requires `Mcp-Name` matching `params.name`; `resources/read` requires it to match `params.uri`.
- Modern results include `resultType: "complete"` and server identity metadata. Discovery and resource results include `ttlMs` and `cacheScope`; authenticated and operator responses are private.
- Tool input errors return recoverable `isError: true` results. Invalid transport requests return HTTP 400; unknown or removed methods return HTTP 404. These statuses also apply when the client accepts SSE.
- Legacy hosts retain `initialize` and the `2025-11-25` response shape. JSON-RPC batches are unsupported; the separate REST tools batch endpoint remains available.
- Embedded calculators use MCP Apps `2026-01-26` initialization and call tools through the host. Versioned `ui://coveragecat/tools/v2/` resources carry standard UI metadata and ChatGPT compatibility aliases. The previous calculator resource URIs still resolve.
- Non-browser clients may omit `Origin`. Browser MCP clients must use an allowed origin; deployments can configure `:mcp_allowed_origins`.

Example modern request:

```http
POST /api/consumer/mcp
Content-Type: application/json
Accept: application/json, text/event-stream
MCP-Protocol-Version: 2026-07-28
Mcp-Method: tools/call
Mcp-Name: umbrella_limit_planner
```

```json
{"jsonrpc":"2.0","id":"plan-1","method":"tools/call","params":{"_meta":{"io.modelcontextprotocol/protocolVersion":"2026-07-28","io.modelcontextprotocol/clientCapabilities":{}},"name":"umbrella_limit_planner","arguments":{"net_worth":1500000,"underlying_limit":300000}}}
```

Expected transport symptoms:

- `GET` on the transport endpoints returns `405 Method Not Allowed`; use the well-known manifest or server card for discovery metadata instead.
- If a local client mistakenly configures `/.well-known/mcp.json` as the direct streamable HTTP transport URL, initialize will hit the manifest instead of the transport and fail. Use `/api/consumer/mcp` for direct local transport config.

## Authentication

- The default consumer MCP read-only tools are public when the corresponding public HTTP tool endpoints are public.
- The default consumer MCP consumer-prefill tools are public. Send the freshest `intake_access_token` with `uid` on every follow-up. Stateless MCP `2026-07-28` requires explicit access; legacy hosts can also preserve hidden MCP shopper sessions. Keep the token private.
- The default consumer MCP umbrella follow-up can remain on the same no-auth subset through `payment_needed`, secure payment UI when available, `payment_url` fallback, authoritative policy reads, and shopper-approved policy-support previews or requests.
- The delegated operator MCP requires an operator bearer key or an OAuth-capable host for delegated umbrella tools.
- Local Codex delegated OAuth uses the host's callback configuration. If your operator OAuth host rejects the local loopback callback, keep the default shopper path on the consumer MCP and use the delegated operator MCP only from a host whose OAuth callback policy is already compatible.

## Related Coverage Cat resources

- `/api/agent/skill.md`
- `/api/agent/homeowners/skill.md`
- `/developers`
- `/agent-plugin/plugin.json`

## Multi-language starter samples

Coverage Cat's shopper-safe consumer discovery document is the fastest starting point for a personal shopping agent. From there, call the consumer-prefill flow instead of sending the shopper straight to `/umbrella`.

```sh
curl https://www.coveragecat.com/api/consumer
curl -X POST https://www.coveragecat.com/api/consumer/umbrella/prefill \
  -H "Content-Type: application/json" \
  -H "Coverage-Cat-API-Version: v1" \
  -H "Idempotency-Key: demo-consumer-prefill-1" \
  -d '{"credit_consent_pending":true,"intake":{"full_name":"Taylor Example","email":"taylor@example.test","address":{"street":"123 Main St","city":"San Francisco","state":"CA","zip":"94107"}}}'
```

```javascript
const discovery = await fetch("https://www.coveragecat.com/api/consumer").then((response) => response.json());
console.log(discovery.preferred_openapi_url);
```

```python
import requests

discovery = requests.get("https://www.coveragecat.com/api/consumer", timeout=30).json()
print(discovery["preferred_openapi_url"])
```
