Outdoo MCP

Connect any MCP-compatible client to your Outdoo workspace — conversations, CRM, and revenue intelligence — via the Model Context Protocol.

What is the Outdoo MCP?

The Outdoo MCP server exposes your conversation intelligence, CRM data, and company context as tools that any MCP-compatible client can invoke. You get 39 tools across three namespaces: Organizations, Conversations, and CRMs.

Prerequisites

• An Outdoo API key and workspace ID (from your Outdoo admin)
• An MCP-compatible client — see Client Setup for supported options

Configuration

The Outdoo MCP server runs over HTTP. You configure it once using the standard MCP JSON format and every tool becomes available to your client automatically.

MCP config snippet

Add the following to your client's MCP configuration (the exact file or location depends on your client — see Client Setup below):

{
  "mcpServers": {
    "outdoo": {
      "type": "http",
      "url": "https://mcp.outdoo.ai/v1/mcp",
      "headers": {
        "x-api-key": "YOUR_OUTDOO_API_KEY",
        "x-workspace-id": "YOUR_WORKSPACE_ID"
      }
    }
  }
}

Keep your API key secret.
Never commit a config file with a real API key to version control. Add it to .gitignore or use your client's environment variable substitution feature.

Client Setup

The Outdoo MCP works with any client that supports the MCP HTTP transport. Select your client below for setup instructions.

Claude Code
Glean
Other Clients

Claude Code (the CLI) picks up .mcp.json automatically from your project root. Once the file is in place, all Outdoo tools are available in every conversation in that directory.

1. Create .mcp.json in your project root

my-project/
├── .mcp.json        # ← add the Outdoo MCP config here
├── main.py
└── ...

Paste the configuration snippet above into .mcp.json, replacing the placeholder values with your Outdoo API key and workspace ID.

2. Start Claude Code

cd my-project
claude

Claude Code will detect .mcp.json on startup and register the Outdoo tools automatically.

3. Use Outdoo tools in your prompt

Get all conversations from last week and summarize key points,
risks, and feature requests.

Claude Code will call the relevant Outdoo MCP tools and synthesize the results inline.

Global setup.
To make Outdoo tools available across all projects, place .mcp.json in your home directory (~/.mcp.json) instead of a project root.

Glean supports MCP connectors, letting you surface Outdoo data alongside your other enterprise knowledge sources in Glean's AI assistant.

• In Glean, go to Admin > Connectors > MCP and add a new MCP server.
• Set the server URL to https://mcp.outdoo.ai/v1/mcp.
• Add the required headers: x-api-key and x-workspace-id with your Outdoo credentials.
• Save and enable the connector. Outdoo tools will appear in Glean's tool catalog.

Glean connector docs.
For detailed steps and screenshots, refer to Glean's official MCP connector documentation. The exact navigation and field names may vary by Glean version.

Any client that supports the MCP HTTP transport can connect to Outdoo. The general steps are the same regardless of client:

• Find where your client stores its MCP server configuration (a JSON file, a settings UI, or environment variables).
• Add a new MCP server entry using the configuration snippet above.
• Set the server URL to https://mcp.outdoo.ai/v1/mcp and pass x-api-key and x-workspace-id as headers.
• Restart or reload your client — Outdoo tools will appear in its tool list.

Refer to your client's documentation for the exact steps to register an HTTP MCP server.

Using with the Anthropic Python SDK

For developers building pipelines, scheduled reports, or custom agents, you can call the Outdoo MCP programmatically using the Anthropic Python SDK.

Prerequisites: Python 3.9 or later, the anthropic package (pip install anthropic), and an Anthropic API key from console.anthropic.com.

With MCP Client
Direct HTTP (no SDK)

import anthropic
from anthropic import Anthropic

client = Anthropic()  # reads ANTHROPIC_API_KEY from env

# Define the Outdoo MCP server
mcp_servers = [
    {
        "type": "url",
        "url": "https://mcp.outdoo.ai/v1/mcp",
        "name": "outdoo",
        "authorization_token": "YOUR_OUTDOO_API_KEY",
    }
]

response = client.beta.messages.create(
    model="claude-sonnet-4-6",
    max_tokens=4096,
    mcp_servers=mcp_servers,
    messages=[
        {
            "role": "user",
            "content": "Get conversations from the last 7 days and summarize key points."
        }
    ],
    betas=["mcp-client-2025-04-04"],
)

print(response.content[0].text)

import requests
from datetime import datetime, timedelta, timezone

OUTDOO_API_KEY = "YOUR_OUTDOO_API_KEY"
OUTDOO_WORKSPACE_ID = "YOUR_WORKSPACE_ID"
MCP_URL = "https://mcp.outdoo.ai/v1/mcp"

headers = {
    "x-api-key": OUTDOO_API_KEY,
    "x-workspace-id": OUTDOO_WORKSPACE_ID,
    "Content-Type": "application/json",
}

# Call a tool directly over MCP HTTP protocol
payload = {
    "jsonrpc": "2.0",
    "id": 1,
    "method": "tools/call",
    "params": {
        "name": "conversations_get_key_points",
        "arguments": {
            "params": {
                "from_created_at": "2026-05-22T00:00:00Z",
                "to_created_at": "2026-05-28T23:59:59Z",
                "scope": "external",
                "limit": 20
            }
        }
    }
}

resp = requests.post(MCP_URL, json=payload, headers=headers)
print(resp.json())

Complete example

Get last week's external conversations with key points and ask Claude to summarize:

import os
from datetime import datetime, timedelta, timezone
import anthropic

client = anthropic.Anthropic(api_key=os.environ["ANTHROPIC_API_KEY"])

# Date range: last 7 days
now = datetime.now(timezone.utc)
week_ago = now - timedelta(days=7)

prompt = f"""
Get all external conversations between {week_ago.strftime('%Y-%m-%dT%H:%M:%SZ')}
and {now.strftime('%Y-%m-%dT%H:%M:%SZ')}.

For each conversation summarize:
- Key points discussed
- Positives and buying signals
- Risks and objections
- Any feature or integration requests
- Deadlines or next steps with due dates
"""

mcp_servers = [
    {
        "type": "url",
        "url": "https://mcp.outdoo.ai/v1/mcp",
        "name": "outdoo",
        "authorization_token": os.environ["OUTDOO_API_KEY"],
    }
]

response = client.beta.messages.create(
    model="claude-sonnet-4-6",
    max_tokens=8192,
    mcp_servers=mcp_servers,
    messages=[{"role": "user", "content": prompt}],
    betas=["mcp-client-2025-04-04"],
)

print(response.content[0].text)

Authentication

The Outdoo MCP uses JWT-based API keys. Keys are scoped to a workspace and carry an expiry date.

Using environment variables (recommended):

# .env
OUTDOO_API_KEY=eyJhbGci...
OUTDOO_WORKSPACE_ID=1429

import os
from dotenv import load_dotenv
load_dotenv()

api_key = os.environ["OUTDOO_API_KEY"]
workspace_id = os.environ["OUTDOO_WORKSPACE_ID"]

API key expiry.
Outdoo API keys include an expiry date in their JWT payload. If you get a 401 response, decode your JWT at jwt.io and check the exp field. Request a new key from your Outdoo admin.

Related articles

• Tools Reference