Parlay — sales-call intelligence API

The Parlay MCP server runs as a local subprocess via npx. No global install required — your AI client spawns a fresh @goparlay/mcp-server process per session.

Before you start

You need:

A Parlay API key (pk_sandbox_… or pk_live_…). Get one if you haven’t already.
Node.js 18+ installed on your machine (for npx).

That’s it. No Bun, no Docker, no cloud deploy.

Pick your client

Claude’s desktop app reads MCP servers from a JSON config file.

Open the config file

macOS: ~/Library/Application Support/Claude/claude_desktop_config.jsonWindows: %APPDATA%\Claude\claude_desktop_config.jsonCreate the file if it doesn’t exist.

Add Parlay

{
  "mcpServers": {
    "parlay": {
      "command": "npx",
      "args": ["-y", "@goparlay/mcp-server@latest"],
      "env": {
        "PARLAY_API_KEY": "pk_sandbox_YOUR_KEY"
      }
    }
  }
}

If you already have other MCP servers, add "parlay" as a sibling key.

Restart Claude Desktop

Fully quit (Cmd+Q / Ctrl+Q) and reopen. Look for the tool icon in the conversation toolbar — you should see Parlay listed with 63 tools.

Cursor uses the same MCP config format as Claude Desktop.

Open MCP settings

Cmd+Shift+P (or Ctrl+Shift+P) → “Cursor Settings” → MCP tab → “Edit in settings.json”Or open ~/.cursor/mcp.json directly.

Add Parlay

{
  "mcpServers": {
    "parlay": {
      "command": "npx",
      "args": ["-y", "@goparlay/mcp-server@latest"],
      "env": {
        "PARLAY_API_KEY": "pk_sandbox_YOUR_KEY"
      }
    }
  }
}

Reload Cursor

Cmd+Shift+P → “Reload Window”. Parlay tools become available in agent mode.

Windsurf supports MCP via its config file.

Open Windsurf MCP config

~/.codeium/windsurf/mcp_config.json

Add Parlay

{
  "mcpServers": {
    "parlay": {
      "command": "npx",
      "args": ["-y", "@goparlay/mcp-server@latest"],
      "env": {
        "PARLAY_API_KEY": "pk_sandbox_YOUR_KEY"
      }
    }
  }
}

Restart Windsurf

Fully quit and reopen. Parlay tools appear in Cascade.

Claude Code lets you add MCP servers without editing JSON.

claude mcp add parlay \
  -e PARLAY_API_KEY=pk_sandbox_YOUR_KEY \
  -- npx -y @goparlay/mcp-server@latest

Then start a session:

claude

Verify it’s loaded with /mcp inside the conversation. Parlay should appear with 63 tools.To remove later: claude mcp remove parlay.

Continue supports MCP servers via its config file.

Open Continue config

~/.continue/config.json

Add Parlay under experimental.modelContextProtocolServers

{
  "experimental": {
    "modelContextProtocolServers": [
      {
        "transport": {
          "type": "stdio",
          "command": "npx",
          "args": ["-y", "@goparlay/mcp-server@latest"],
          "env": {
            "PARLAY_API_KEY": "pk_sandbox_YOUR_KEY"
          }
        }
      }
    ]
  }
}

Reload your IDE

Continue picks up the change on next agent invocation.

Zed supports MCP servers as “context servers” in its config.

Open Zed settings

Cmd+, → “Open settings.json”

Add Parlay under context_servers

{
  "context_servers": {
    "parlay": {
      "command": {
        "path": "npx",
        "args": ["-y", "@goparlay/mcp-server@latest"],
        "env": {
          "PARLAY_API_KEY": "pk_sandbox_YOUR_KEY"
        }
      }
    }
  }
}

Reload Zed

Settings auto-reload on save.

If you’re building a custom agent with @anthropic-ai/sdk, use the @modelcontextprotocol/sdk client to spawn Parlay’s MCP server as a subprocess and forward tool calls.

import Anthropic from "@anthropic-ai/sdk";
import { Client } from "@modelcontextprotocol/sdk/client/index.js";
import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";

const transport = new StdioClientTransport({
  command: "npx",
  args: ["-y", "@goparlay/mcp-server@latest"],
  env: { ...process.env, PARLAY_API_KEY: process.env.PARLAY_API_KEY! },
});

const mcp = new Client({ name: "my-agent", version: "0.1.0" }, { capabilities: {} });
await mcp.connect(transport);

const { tools } = await mcp.listTools();
const anthropic = new Anthropic();

const response = await anthropic.messages.create({
  model: "claude-opus-4-7",
  max_tokens: 4096,
  tools: tools.map((t) => ({
    name: t.name,
    description: t.description ?? "",
    input_schema: t.inputSchema as Anthropic.Tool["input_schema"],
  })),
  messages: [{ role: "user", content: "Analyze mock://perfect-pitch under acme/alex." }],
});

// On each tool_use block in response.content, call mcp.callTool({ name, arguments }) and feed the result back.

Loop the model + mcp.callTool until the model returns a final assistant turn.

If your client speaks the MCP protocol directly, here’s the canonical stdio invocation:

npx -y @goparlay/mcp-server@latest

The process reads JSON-RPC requests on stdin and writes responses to stdout. Logs go to stderr (never stdout — stdout is reserved for protocol).Required env:

PARLAY_API_KEY — your Parlay key

Optional env:

PARLAY_MCP_LOG_LEVEL — debug, info (default), warn, error
PARLAY_API_BASE_URL — don’t set this. Defaults to https://api.goparlay.io (production), which is what you want for both sandbox and live keys. Sandbox keys (pk_sandbox_…) are gated by your API key prefix, not the URL — they bill at $0 against test data on the same prod endpoint. Only override this for self-hosted Parlay deployments.

Send initialize, then notifications/initialized, then any tools/list or tools/call request.

Verify it’s working

In your AI client, paste this:

Use parlay tools to ping the server and tell me which environment I'm connected to.

You should see something like:

{
  "pong": true,
  "echo": null,
  "timestamp": "2026-04-24T17:56:41.748Z",
  "base_url": "https://api.goparlay.io",
  "key_environment": "sandbox",
  "server": "@goparlay/mcp-server@0.1.0"
}

If key_environment: "sandbox" matches the prefix of your key, you’re good.

Environment variables reference

Variable	Required	Default	Notes
`PARLAY_API_KEY`	yes	—	Your Parlay key (`pk_sandbox_…` or `pk_live_…`)
`PARLAY_MCP_LOG_LEVEL`	no	`info`	`debug` for full request/response logs
`PARLAY_API_BASE_URL`	no	`https://api.goparlay.io`	Don’t set this. Sandbox vs live is determined by your API key prefix, not by URL. Override only for self-hosted Parlay or internal staging. The MCP refuses to start if you pair a `pk_live_*` key with a known dev URL — protects you from accidentally sending live traffic to a non-prod cluster.

Common pitfall — don’t set PARLAY_API_BASE_URL. Older config snippets online may show this pointing at a Vercel preview URL or parlay-api-dev. Those are stale. The default (production) is correct for everyone.

Troubleshooting

The Parlay server shows red / not running

Open your client’s MCP logs (Claude Desktop: ~/Library/Logs/Claude/mcp-server-parlay.log). Common causes:

PARLAY_API_KEY is not set — env block isn’t reaching the subprocess. Double-check the JSON config.
Cannot find module @goparlay/mcp-server — npx couldn’t resolve the package. Run npx -y @goparlay/mcp-server@latest --help from a terminal to verify it works standalone.
npx: command not found — install Node.js 18+.

Tools appear but every call fails with `authentication_required`

Your key is invalid or expired. Test with:

curl https://api.goparlay.io/v1/personas \
  -H "Authorization: Bearer YOUR_KEY"

If that returns 401, regenerate your key.

Tool calls hang for minutes

Async tools (analyze_recording, assign_rep_persona, etc.) wait for the AI job to complete. Real audio takes 30–90 seconds. Mock fixtures should be near-instant — if they hang, your key may not have access to the right environment.

I'm using a corporate proxy / firewall

The MCP server makes outbound HTTPS calls to api.goparlay.io. Whitelist that domain (or your live equivalent). The MCP server reads HTTPS_PROXY from the environment if set.

Get started

MCP server

Guides

Install the MCP server

Before you start

Pick your client

Verify it’s working

Environment variables reference

Troubleshooting

Next steps

Tool catalog

Examples

​Before you start

​Pick your client

​Verify it’s working

​Environment variables reference

​Troubleshooting

​Next steps

Tool catalog

Examples

Before you start

Pick your client

Verify it’s working

Environment variables reference

Troubleshooting

Next steps