# ChatWithHuman.ai

> AI-to-human chat platform that routes AI agent sessions to verified human experts, billed per minute. When your agent hits a wall, ChatWithHuman.ai routes the session to a verified human expert — billed per minute, resolved in seconds.

- What: human-in-the-loop escalation API. An AI agent opens a session; a verified human expert joins, chats, and hands control back.
- Handoff: one call — `POST https://chatwithhuman.chrismai.ai/api/sessions` with `agent_id`, `context` and optional `tier` (see OpenAPI).
- Auth: `Authorization: Bearer <API key>` on the agent session routes; keys (prefix `cwh_live_`, shown once) are created in the dashboard (/dashboard/keys) or via `POST /api/keys` while signed in.
- Pricing: Standard $10 / min (developers and small teams; API tier `standard`) · Priority $25 / min (funded startups and crypto projects; API tier `priority`) · Enterprise from $250,000 / year (public companies and large institutions; annual contract — contact sales below). No platform fee, no subscriptions, no seat fees.
- Webhooks and spending caps: planned, not live. Use the SSE stream `GET /api/sessions/{id}/events`.
- Billing starts when a human connects, not when the session is created.
- MCP server: planned, not available yet.
- Contact sales (no API key needed): `POST https://chatwithhuman.chrismai.ai/api/leads` with `email` + `name` or `company` (+ optional `use_case`, `volume`, `timeline`, `plan`) stores a lead; `POST https://chatwithhuman.chrismai.ai/api/sales-chat` with `{"message": "…", "plan": "enterprise"}` talks to the AI sales assistant (pass back `conversation_id`; JSON or SSE). Rate-limited per IP. Human handoff: text or call Chris Mai, 415-375-5872.

## Docs

- [For agents](https://chatwithhuman.chrismai.ai/agents.md): when to escalate, the session loop, copy-paste calls
- [Developer docs](https://chatwithhuman.chrismai.ai/docs.md): quickstart, API reference, event stream, API keys
- [Pricing](https://chatwithhuman.chrismai.ai/pricing.md): tiers, platform fee, FAQ
- [Home](https://chatwithhuman.chrismai.ai/index.md): product overview, how it works, features

## API

- [OpenAPI 3.1 spec](https://chatwithhuman.chrismai.ai/openapi.json): every implemented /api route with request/response schemas
- [AI plugin manifest](https://chatwithhuman.chrismai.ai/.well-known/ai-plugin.json)
- [MCP descriptor (planned)](https://chatwithhuman.chrismai.ai/.well-known/mcp.json)
- [Status JSON](https://chatwithhuman.chrismai.ai/api/status): live service health
- [Sales chat config](https://chatwithhuman.chrismai.ai/api/sales-chat): mode, lead fields, handoff contact, limits

## Optional

- [Full text](https://chatwithhuman.chrismai.ai/llms-full.txt): all pages above inlined
- [System status](https://chatwithhuman.chrismai.ai/status.md)
- [Sitemap](https://chatwithhuman.chrismai.ai/sitemap.xml)

---

# ChatWithHuman.ai — The human layer for your AI agents

> When your agent hits a wall, ChatWithHuman.ai routes the session to a verified human expert — billed per minute, resolved in seconds.

## Hand off to a human in one API call

One REST call to escalate any session. Works with any agent framework.

```http
POST https://chatwithhuman.ai/api/sessions
Authorization: Bearer <API_KEY>
Content-Type: application/json

{
  "agent_id": "agent_abc123",
  "context": "User is asking about a refund for order #8821",
  "tier": "standard"
}

// Response 201
{ "session_id": "ses_x9k2m", "status": "queued", "eta_seconds": 12, "billing_started": false, "tier": "standard", "rate_cents_per_minute": 1000, "metadata": {} }
```

```bash
curl -X POST https://chatwithhuman.chrismai.ai/api/sessions \
  -H "Authorization: Bearer $CHATWITHHUMAN_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
  "agent_id": "agent_abc123",
  "context": "User is asking about a refund for order #8821",
  "tier": "standard"
}'
```

## At a glance

| Metric | Value |
| --- | --- |
| Standard rate | $10/min |
| To hand off | 1 call |
| Uptime target | 99.9% |

## Billing examples (computed from published rates)

- Standard · 2m 00s connected → 2 min × $10 = $20.00
- Standard · 0m 45s connected → 1-min minimum = $10.00
- Priority · 3m 00s connected → 3 min × $25 = $75.00
- Priority · 1m 30s connected → whole minutes: 1 × $25 = $25.00
- Platform fee → $0.00
- Enterprise → from $250,000 / year, by contract

## How it works

1. **AI hits a wall** — Your agent detects a scenario it can't resolve — ambiguous intent, sensitive context, or a task requiring human judgment.
2. **Routes to ChatWithHuman.ai** — A single API call escalates the session. ChatWithHuman.ai matches it to an available human expert based on topic, language, and urgency.
3. **Human responds in seconds** — The expert joins the live session, resolves the issue, and hands control back to your agent. Billed per minute at your tier's rate.

## Built for production

- **Real-time chat interface** — Human operators get a live dashboard with session queue, typing indicators, full message history, and context from your agent. Zero latency handoff.
- **Per-minute billing** — Metered per minute while a human is connected: $10/min Standard, $25/min Priority. No platform fee. Usage dashboard with per-agent breakdowns and per-session invoices.
- **Scheduling & availability** — Set expert availability windows, timezone-aware scheduling, and live/busy status. Overflow routing built in.
- **Webhooks (planned)** — Planned: POST events to your endpoint on session start, message, and close. Today, stream the same events over SSE.
- **Session history** — Full transcript storage with search, export, and replay.

## Transparent pricing

No subscriptions. No seat fees. Pay only for what you use.

| Item | Value | Unit | Note |
| --- | --- | --- | --- |
| Standard | $10 | / min | Pay-as-you-go · developers, small teams |
| Priority | $25 | / min | Guaranteed fast human response |
| Enterprise | from $250,000 | / year | Dedicated expert, SLA, contract |
| Platform fee | None | — | No subscriptions or seat fees |

## Ready to add a human layer?

Get your API key and make your first escalation in under 5 minutes.

```yaml
# Session escalated successfully
session_id: "ses_x9k2m"
status: "connected"
tier: "standard"
rate_cents_per_minute: 1000
billingStartedAt: "2026-10-14T21:18:04Z"
```

## Machine-readable

- [/llms.txt](https://chatwithhuman.chrismai.ai/llms.txt): llmstxt.org index: summary + links
- [/llms-full.txt](https://chatwithhuman.chrismai.ai/llms-full.txt): All docs, pricing and FAQ inlined in one file
- [/openapi.json](https://chatwithhuman.chrismai.ai/openapi.json): OpenAPI 3.1 spec of the implemented /api routes
- [/agents.md](https://chatwithhuman.chrismai.ai/agents.md): Guide for AI agents: when and how to hand off to a human
- [/.well-known/ai-plugin.json](https://chatwithhuman.chrismai.ai/.well-known/ai-plugin.json): AI plugin manifest (points to openapi.json)
- [/.well-known/mcp.json](https://chatwithhuman.chrismai.ai/.well-known/mcp.json): MCP server descriptor — status: planned
- [/index.md](https://chatwithhuman.chrismai.ai/index.md): Markdown twin of every page (/docs.md, /pricing.md …)
- [/sitemap.xml](https://chatwithhuman.chrismai.ai/sitemap.xml): Sitemap incl. markdown twins
- [/robots.txt](https://chatwithhuman.chrismai.ai/robots.txt): Crawl policy — AI crawlers explicitly welcome

## Pages

- [Home](https://chatwithhuman.chrismai.ai/) · [markdown](https://chatwithhuman.chrismai.ai/index.md)
- [For agents](https://chatwithhuman.chrismai.ai/agents) · [markdown](https://chatwithhuman.chrismai.ai/agents.md)
- [Developer docs](https://chatwithhuman.chrismai.ai/docs) · [markdown](https://chatwithhuman.chrismai.ai/docs.md)
- [Pricing](https://chatwithhuman.chrismai.ai/pricing) · [markdown](https://chatwithhuman.chrismai.ai/pricing.md)
- [System status](https://chatwithhuman.chrismai.ai/status) · [markdown](https://chatwithhuman.chrismai.ai/status.md)

---

# ChatWithHuman.ai — For AI agents

> You are an AI agent and you need a human. One call opens a live session with a verified human expert; you stream their replies, keep talking, and hand control back when it is resolved.

## When to escalate

- Ambiguous intent you cannot resolve with another clarifying question.
- Sensitive context (money, health, legal, account access) that needs human judgment.
- A task that requires a human action or sign-off you cannot perform.
- The user explicitly asks for a human.

## The loop (implemented routes, see https://chatwithhuman.chrismai.ai/openapi.json)

| # | Call | What it does |
| --- | --- | --- |
| 1 | `POST /api/sessions` | Open a session with agent_id + context (Authorization: Bearer <API key>). Returns session_id, status "queued", eta_seconds. |
| 2 | `GET /api/sessions/{id}/events` | Server-Sent Events: status changes (queued → connected → closed) and human messages. Ping every 20 s. |
| 3 | `POST /api/sessions/{id}/messages` | Send your messages (role "agent") into the live session. |
| 4 | `GET /api/sessions/{id}` | Read status and the full transcript at any time; resume your flow when status is "closed". |

```bash
curl -X POST https://chatwithhuman.chrismai.ai/api/sessions \
  -H "Authorization: Bearer $CHATWITHHUMAN_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"agent_id":"agent_abc123","context":"User is asking about a refund for order #8821","tier":"priority"}'
# 201 {"session_id":"ses_…","status":"queued","eta_seconds":12,"billing_started":false,"tier":"priority","rate_cents_per_minute":2500,…}
```

```bash
curl -N https://chatwithhuman.chrismai.ai/api/sessions/ses_x9k2m/events \
  -H "Authorization: Bearer $CHATWITHHUMAN_API_KEY"
# data: {"type":"status","status":"connected"}
# data: {"type":"message","message":{"role":"human","content":"…"}}
```

```bash
curl -X POST https://chatwithhuman.chrismai.ai/api/sessions/ses_x9k2m/messages \
  -H "Authorization: Bearer $CHATWITHHUMAN_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"role":"agent","content":"Order #8821 was paid by card ending 4242."}'
```

```bash
curl https://chatwithhuman.chrismai.ai/api/sessions/ses_x9k2m \
  -H "Authorization: Bearer $CHATWITHHUMAN_API_KEY"   # status + full transcript
```

## Writing good context

- Put everything the human needs in `context`: the user goal, what you already tried, relevant ids.
- Use `tier: "priority"` ($25/min, guaranteed fast human response) when a user is waiting on it; otherwise the default `standard` ($10/min).
- Attach your own correlation ids in `metadata`; they are echoed back.

## Billing

Billing starts when a human connects (status "connected"), not when you create the session: whole minutes at the session tier rate (Standard $10/min, Priority $25/min), no platform fee.

| Plan | Rate | For | Billing | API `tier` | CTA |
| --- | --- | --- | --- | --- | --- |
| Standard | $10 / min | Developers and small teams | Pay-as-you-go · whole minutes while a human is connected, 1-minute minimum | `standard` | Get API key |
| Priority | $25 / min | Funded startups and crypto projects | Pay-as-you-go · choose per session with tier: "priority" | `priority` | Get API key |
| Enterprise | from $250,000 / year | Public companies and large institutions | Annual contract · invoiced per contract | contract | Contact sales |

No platform fee. Pick the tier per session with `"tier": "standard" | "priority"` in `POST /api/sessions`.

## Same call in other languages

```js
const res = await fetch("https://chatwithhuman.chrismai.ai/api/sessions", {
  method: "POST",
  headers: {
    Authorization: `Bearer ${process.env.CHATWITHHUMAN_API_KEY}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "agent_id": "agent_abc123",
    "context": "User is asking about a refund for order #8821",
    "tier": "standard"
  }),
});
const { session_id, eta_seconds } = await res.json();
```

```python
import os, requests

r = requests.post(
    "https://chatwithhuman.chrismai.ai/api/sessions",
    headers={"Authorization": f"Bearer {os.environ['CHATWITHHUMAN_API_KEY']}"},
    json={
        "agent_id": "agent_abc123",
        "context": "User is asking about a refund for order #8821",
        "tier": "standard",  # or "priority" ($25/min)
    },
)
session = r.json()  # {"session_id": "ses_x9k2m", "status": "queued", "tier": "standard", ...}
```

## MCP (planned)

There is no MCP server yet. The descriptor at /.well-known/mcp.json documents the intended shape so agent runtimes can plan for it. Until then, use the REST API in /openapi.json.

| Planned tool | Maps to | Arguments |
| --- | --- | --- |
| escalate_to_human | `POST /api/sessions` | agent_id, context, priority?, metadata? |
| send_message | `POST /api/sessions/{id}/messages` | session_id, content |
| get_session | `GET /api/sessions/{id}` | session_id |
| close_session | `PATCH /api/sessions/{id}` | session_id (status: "closed") |

## Contact sales (Enterprise or any plan question)

No API key needed. Store a lead directly, or talk to the AI sales assistant:

```bash
curl -X POST https://chatwithhuman.chrismai.ai/api/leads \
  -H "Content-Type: application/json" \
  -d '{"name":"Alice Chen","company":"Example Corp","email":"alice@example.com","use_case":"Escalate compliance questions","volume":"20,000 min/month","timeline":"Q1","plan":"enterprise"}'

curl -X POST https://chatwithhuman.chrismai.ai/api/sales-chat \
  -H "Content-Type: application/json" \
  -d '{"message":"What does Enterprise include?","plan":"enterprise"}'
# → { "conversation_id": "lead_…", "mode": "llm" | "scripted", "reply": "…", "missing": [...], "handoff": { … } }
```

Pass `conversation_id` back on each turn. Rate-limited per IP. Human handoff: text or call Chris Mai, 415-375-5872.

## Machine-readable

- [/llms.txt](https://chatwithhuman.chrismai.ai/llms.txt): llmstxt.org index: summary + links
- [/llms-full.txt](https://chatwithhuman.chrismai.ai/llms-full.txt): All docs, pricing and FAQ inlined in one file
- [/openapi.json](https://chatwithhuman.chrismai.ai/openapi.json): OpenAPI 3.1 spec of the implemented /api routes
- [/agents.md](https://chatwithhuman.chrismai.ai/agents.md): Guide for AI agents: when and how to hand off to a human
- [/.well-known/ai-plugin.json](https://chatwithhuman.chrismai.ai/.well-known/ai-plugin.json): AI plugin manifest (points to openapi.json)
- [/.well-known/mcp.json](https://chatwithhuman.chrismai.ai/.well-known/mcp.json): MCP server descriptor — status: planned
- [/index.md](https://chatwithhuman.chrismai.ai/index.md): Markdown twin of every page (/docs.md, /pricing.md …)
- [/sitemap.xml](https://chatwithhuman.chrismai.ai/sitemap.xml): Sitemap incl. markdown twins
- [/robots.txt](https://chatwithhuman.chrismai.ai/robots.txt): Crawl policy — AI crawlers explicitly welcome

---

# Build with ChatWithHuman.ai

> Everything you need to integrate human escalation into your AI agent: REST API, live event stream, and copy-paste examples.

Machine-readable spec of the implemented routes: https://chatwithhuman.chrismai.ai/openapi.json (OpenAPI 3.1). Full text for LLMs: https://chatwithhuman.chrismai.ai/llms-full.txt.

## Quickstart

1. **Get your API key** — Sign up and generate a key from your dashboard (/dashboard/keys). Keys are prefixed cwh_live_, shown once, and can be revoked at any time.
2. **Escalate a session** — POST to /api/sessions with your agent_id and context. Add "tier": "priority" for guaranteed fast response at $25/min (Standard is $10/min). ChatWithHuman.ai matches the session to an available human expert.
3. **Stream the reply** — Open GET /api/sessions/{id}/events (Server-Sent Events) to receive status changes and the human's messages, then resume your agent flow. Webhooks are planned.

## API reference

Base URL: `https://chatwithhuman.ai/api`

### `POST /sessions`

Create a new escalation session. Returns a session_id, estimated wait time, and the tier and rate that apply.

| Field | Type | Required | Description |
| --- | --- | --- | --- |
| `agent_id` | string | yes | Your registered agent identifier. |
| `context` | string | no | Plain-text summary of the issue for the human expert. Strongly recommended. |
| `tier` | "standard" \| "priority" | no | Pricing tier for this session. Defaults to standard ($10/min); priority is $25/min with guaranteed fast human response. Legacy priority: "high" also selects priority. |
| `webhook_url` | string | no | Stored with the session. Webhook delivery is planned, not live — use the event stream. |
| `metadata` | object | no | Arbitrary key-value pairs, echoed back in the response. |

```json
{
  "session_id": "ses_x9k2m",
  "status": "queued",
  "eta_seconds": 12,
  "billing_started": false,
  "tier": "standard",
  "rate_cents_per_minute": 1000,
  "metadata": {}
}
```

### `GET /sessions/{id}`

Retrieve the current state of a session, including its tier and full message transcript.

```json
{
  "id": 42,
  "sessionId": "ses_x9k2m",
  "agentId": "agent_abc123",
  "status": "connected",
  "priority": "normal",
  "tier": "standard",
  "context": "User is asking about a refund for order #8821",
  "webhookUrl": null,
  "operatorId": "operator_1",
  "billingStartedAt": "2026-10-14T21:18:04.000Z",
  "closedAt": null,
  "createdAt": "2026-10-14T21:17:52.000Z",
  "userId": "usr_\u2026",
  "messages": [
    {
      "id": 7,
      "sessionId": "ses_x9k2m",
      "role": "human",
      "content": "Hi \u2014 I can help with that refund.",
      "createdAt": "2026-10-14T21:18:10.000Z"
    }
  ]
}
```

### `POST /sessions/{id}/messages`

Send a message into a session. Agents should pass role "agent".

| Field | Type | Required | Description |
| --- | --- | --- | --- |
| `content` | string | yes | The message text to send. |
| `role` | "agent" \| "human" \| "system" | no | Defaults to human — set "agent" when your agent is speaking. |

```json
{
  "message_id": "msg_7",
  "created_at": "2026-10-14T21:18:04.000Z"
}
```

### `GET /sessions/{id}/events`

Server-Sent Events stream: status changes, new messages, and a ping every 20 s.

```json
data: {"type":"status","status":"connected"}

data: {"type":"message","message":{"id":7,"role":"human","content":"Hi — I can help with that refund.", …}}

data: {"type":"ping"}
```

### `PATCH /sessions/{id}`

Close a session with {"status": "closed"}. Billing stops and an invoice is created (whole minutes × tier rate, 1-minute minimum, no platform fee). Returns the updated session.

| Field | Type | Required | Description |
| --- | --- | --- | --- |
| `status` | "connected" \| "closed" | yes | "closed" ends the session; "connected" is set when an operator joins. |
| `operator_id` | string | no | Operator joining the session (with status "connected"). |

```json
{
  "sessionId": "ses_x9k2m",
  "status": "closed",
  "priority": "normal",
  "billingStartedAt": "2026-10-14T21:18:04.000Z",
  "closedAt": "2026-10-14T21:20:18.000Z",
  "\u2026": "\u2026"
}
```

### `GET /billing/usage`

Invoices plus all-time and 30-day totals for your account (signed-in session). Filter by agent.

| Field | Type | Required | Description |
| --- | --- | --- | --- |
| `agentId` | string (query) | no | Only this agent's invoices. |
| `limit / offset` | integer (query) | no | Pagination; defaults 20 / 0. |

```json
{
  "invoices": [
    {
      "invoiceId": "inv_3f9a\u2026",
      "sessionId": "ses_x9k2m",
      "totalMinutes": 2,
      "ratePerMinute": "10.0000",
      "subtotalCents": 2000,
      "platformFeeCents": 0,
      "totalCents": 2000,
      "currency": "usd",
      "status": "pending"
    }
  ],
  "totals": {
    "totalSessions": 47,
    "totalMinutes": 312,
    "totalCents": 312000
  },
  "last30Days": {
    "sessions": 12,
    "minutes": 80,
    "revenueCents": 80000
  }
}
```

## Webhooks (planned)

Not live yet: the server stores webhook_url but does not deliver events. Today, consume the same events from GET /api/sessions/{id}/events (Server-Sent Events). The planned events are listed below; signing will be documented when delivery ships.

| Event | Description |
| --- | --- |
| `session.queued` | Session created and waiting for a human expert. |
| `session.connected` | Human expert joined. Billing starts. |
| `session.message` | New message from the human expert. |
| `session.closed` | Session ended. Includes final duration and cost. |

```js
// Live today: stream session events over SSE
const res = await fetch(`https://chatwithhuman.ai/api/sessions/${sessionId}/events`, {
  headers: { Authorization: `Bearer ${process.env.CHATWITHHUMAN_API_KEY}` },
});
for await (const chunk of res.body) {
  // data: {"type":"message","message":{...}}
  process.stdout.write(chunk);
}
```

## API keys

Keys are prefixed cwh_live_ and shown once at creation. Sandbox (test) keys are planned; today every session is matched to real humans and billed.

- Store keys in environment variables — never commit them to source control.
- Rotate by creating a new key, deploying it, then revoking the old one (DELETE /api/keys/{keyId}).
- Scope keys per agent to isolate usage and billing.

## SDKs

| SDK | Install | Status |
| --- | --- | --- |
| Node.js | `npm install @chatwithhuman/node` | planned |
| Python | `pip install chatwithhuman` | planned |
| Go | `go get github.com/chatwithhuman/go-sdk` | planned |
| REST | `No install required` | stable |

## Implemented routes (current server)

| Method | Path | Summary |
| --- | --- | --- |
| POST | `/api/sessions` | Escalate: create a session (queued for a human) |
| GET | `/api/sessions` | List sessions (operator queue) |
| GET | `/api/sessions/history` | Search past sessions with duration and invoice |
| GET | `/api/sessions/{id}` | Get a session with its full transcript |
| PATCH | `/api/sessions/{id}` | Change session status (connect = billing starts, close = invoice) |
| POST | `/api/sessions/{id}/messages` | Send a message into a session |
| GET | `/api/sessions/{id}/events` | Server-Sent Events stream for a session |
| GET | `/api/operators` | List human operators |
| PATCH | `/api/operators/status` | Set an operator online/offline |
| GET | `/api/schedule` | Bookings, operators and availability |
| POST | `/api/schedule` | Book a session with an operator in advance |
| GET | `/api/keys` | List the signed-in user's API keys (hash never returned) |
| POST | `/api/keys` | Create an API key (raw key returned once, prefix cwh_live_) |
| DELETE | `/api/keys/{keyId}` | Revoke an API key |
| GET | `/api/billing/usage` | Invoices plus all-time and 30-day totals |
| POST | `/api/billing/meter` | Record a billing event for a session |
| GET | `/api/billing/invoices/{invoiceId}` | Invoice with its billing events |
| POST | `/api/billing/invoices/{invoiceId}/charge` | Charge an invoice to the signed-in user's saved card (Stripe) |
| GET | `/api/stripe/config` | Whether payments are configured (publishable key, mode) |
| GET | `/api/stripe/products` | Active Stripe products with their default price |
| POST | `/api/stripe/create-checkout-session` | Create a Stripe Checkout session (single price or cart) |
| GET | `/api/stripe/session/{sessionId}` | Verify a Checkout session after redirect |
| POST | `/api/stripe/webhook` | Stripe webhook receiver (verifies stripe-signature) |
| GET | `/api/auth/{path}` | better-auth GET handler (e.g. get-session) |
| POST | `/api/auth/{path}` | better-auth POST handler (sign-in, sign-up, sign-out) |
| GET | `/api/sales-chat` | Sales chat mode (llm \| scripted), lead fields, handoff contact and limits |
| POST | `/api/sales-chat` | Send one message to the AI sales assistant (lead qualification + human handoff) |
| POST | `/api/leads` | Submit a sales lead directly (for agents and forms) |
| GET | `/api/admin/leads/{leadId}` | Full lead + transcript (admins only; linked from lead alert emails) |
| GET | `/api/health` | Liveness probe |
| GET | `/api/status` | Service health checks (API, Database, Authentication, Chat Sessions, Webhook Handler) |

## MCP (planned)

There is no MCP server yet. The descriptor at /.well-known/mcp.json documents the intended shape so agent runtimes can plan for it. Until then, use the REST API in /openapi.json.

| Planned tool | Maps to | Arguments |
| --- | --- | --- |
| escalate_to_human | `POST /api/sessions` | agent_id, context, priority?, metadata? |
| send_message | `POST /api/sessions/{id}/messages` | session_id, content |
| get_session | `GET /api/sessions/{id}` | session_id |
| close_session | `PATCH /api/sessions/{id}` | session_id (status: "closed") |

---

# ChatWithHuman.ai pricing — Pay for what you use

> Pay-as-you-go per minute for Standard and Priority, or an annual Enterprise contract. No platform fee, no seat fees.

| Plan | Rate | For | Billing | API `tier` | CTA |
| --- | --- | --- | --- | --- | --- |
| Standard | $10 / min | Developers and small teams | Pay-as-you-go · whole minutes while a human is connected, 1-minute minimum | `standard` | Get API key |
| Priority | $25 / min | Funded startups and crypto projects | Pay-as-you-go · choose per session with tier: "priority" | `priority` | Get API key |
| Enterprise | from $250,000 / year | Public companies and large institutions | Annual contract · invoiced per contract | contract | Contact sales |

## Standard

- Pay-as-you-go, no commitment
- Verified human experts
- Any agent framework (REST API)
- Live event stream (SSE)
- Session transcripts
- Usage dashboard & per-session invoices

## Priority

- Everything in Standard
- Guaranteed fast human response
- Selectable per session — mix with Standard on one key
- Same API, one field: tier: "priority"

## Enterprise

- Everything in Priority
- Dedicated expert
- SLA
- Contract & custom invoicing

## At a glance

| Item | Value | Unit | Note |
| --- | --- | --- | --- |
| Standard | $10 | / min | Pay-as-you-go · developers, small teams |
| Priority | $25 | / min | Guaranteed fast human response |
| Enterprise | from $250,000 | / year | Dedicated expert, SLA, contract |
| Platform fee | None | — | No subscriptions or seat fees |

Choose Standard or Priority per session: `POST /api/sessions` with `"tier": "standard"` (default, $10/min) or `"tier": "priority"` ($25/min). Enterprise is an annual contract (contact sales).

## Frequently asked questions

### How is billing calculated?

Sessions are metered from the moment a human expert joins (status "connected") until the session is closed, in whole minutes with a 1-minute minimum, at the session's tier rate: Standard $10/min or Priority $25/min. There is no platform fee, setup fee, or monthly commitment. Enterprise is billed per annual contract.

### What counts as a session?

A session starts when your agent calls POST /api/sessions and a human expert accepts. It ends when the session is closed with PATCH /api/sessions/{id} {"status": "closed"}; an invoice is created at that moment.

### How do I choose Standard or Priority?

Per session. Send "tier": "standard" (the default) or "tier": "priority" in POST /api/sessions; the legacy "priority": "high" also selects Priority. The response confirms the tier and rate_cents_per_minute.

### Is there a free tier or sandbox?

Not yet — sandbox keys are planned. Today every key is a live key (prefixed cwh_live_) and sessions are matched to real humans and billed.

### Can I set a spending cap?

Planned, not live yet. Until then, track spend in real time with GET /api/billing/usage or the usage dashboard.

### How do I get invoiced?

Each session gets its own invoice when it closes (minutes × tier rate). Pull usage and invoices any time via GET /api/billing/usage. Enterprise contracts are invoiced per contract.

### What does Enterprise include?

A dedicated expert, an SLA and a negotiated contract, from $250,000 per year — for public companies and large institutions. Contact sales to start.

## Get an API key and escalate your first session

Generate a cwh_live_ key and make your first escalation in under 5 minutes.

---

# ChatWithHuman.ai system status

Live health checks are served as JSON at `https://chatwithhuman.chrismai.ai/api/status` and the human page at https://chatwithhuman.chrismai.ai/status.

```bash
curl https://chatwithhuman.chrismai.ai/api/status
# {"overall":"operational","services":[{"name":"API","status":"operational","latencyMs":…}, …],"checkedAt":"…"}
```

Services checked: API, Database, Authentication, Chat Sessions, Webhook Handler. Liveness probe: `GET https://chatwithhuman.chrismai.ai/api/health`.