MCP-native

Run support from your code or your agents.

Parly is an MCP server. One scoped key lets the Claude API, Claude Code, or any MCP client read, search, and reply to conversations, under the same send rules and audit trail as a person. Copy a snippet, paste your key, and you're driving the help desk.

Streamable-HTTP MCP at /api/mcp
One bearer key, shown once
Mailbox-scoped, read or reply
Five typed tools
Restricted-send still enforced
Rate-limited and fully audited

Request access Explore the snippets

1{
2  "mcpServers": {
3    "parly": {
4      "type": "http",
5      "url": "https://app.parlyparly.com/api/mcp",
6      "headers": {
7        "Authorization": "Bearer parly_sk_<your-key>"
8      }
9    }
10  }
11}

How it works

MCP for agents

Streaming-HTTP MCP at /api/mcp, JSON-RPC 2.0. Drops five typed tools into Claude Code, the Claude API connector, MCP Inspector, and any MCP-aware client.

Scoped keys

Company-owned bearer keys, scoped to specific mailboxes and to read or reply. The scopes you grant are the scopes the tools see.

Same send rules

A reply from an agent goes through the exact path a human reply does: restricted-send allowlists and suppressions are enforced, and the message lands in the thread with the same audit trail.

Tenant-isolated

A key only ever resolves to its own company and mailbox allowlist, re-checked in code on every call. There is no “global” endpoint.

30-second setup

1. Create a key. In Parly, open Admin → API keys. Pick the mailboxes and whether it can reply; copy the raw key (shown once).
2. Pick a snippet below. Paste your key into the connector config or the one-liner.
3. Call something. tools/list to see what the key can do, then list_conversations. JSON back means you're wired up.

Snippets

Replace parly_sk_<your-key> with the raw key from Admin → API keys. It is shown exactly once at creation, so capture it then.

Claude Code (one-liner)

Adds Parly to the local project's MCP servers.

claude mcp add --transport http parly \
  https://app.parlyparly.com/api/mcp \
  -H "Authorization: Bearer parly_sk_<your-key>"

.mcp.json (Claude Desktop, Cursor, MCP clients)

Drop into your client's MCP config file.

{
  "mcpServers": {
    "parly": {
      "type": "http",
      "url": "https://app.parlyparly.com/api/mcp",
      "headers": {
        "Authorization": "Bearer parly_sk_<your-key>"
      }
    }
  }
}

cURL

Same key, plain HTTPS. Lists the tools the key can call.

curl -s https://app.parlyparly.com/api/mcp \
  -H "Authorization: Bearer parly_sk_<your-key>" \
  -H "Content-Type: application/json" \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/list"}'

The tools

Five typed tools. Reads are safe to run in parallel; send_reply is the one write, and it needs the reply scope.

list_mailboxes

The mailboxes this key can access.

list_conversations

Recent conversations in a mailbox, by email address.

get_conversation

One conversation and its messages, by ref number.

search

Find conversations in a mailbox by subject text.

send_reply

Reply to the latest inbound sender. Needs the reply scope; restricted-send is enforced.

Reference

Auth: A bearer key that starts with parly_sk_, hashed at rest, shown once, revocable in one click.
Scopes: read always, plus optional reply. A mailbox allowlist limits the key; none selected means every mailbox in the company.
Rate limit: 120 requests per minute per key. Over budget returns HTTP 429.
Errors: JSON-RPC 2.0 over HTTP. A tool that fails returns its message as an isError result so the model sees it inline. Every call is written to the audit log.

Build on it.

Request a workspace and you'll have a key to ship against within the hour.

Request access See it on the homepage