Connect Claude Desktop or Cursor to Chat.co with MCP

MCP lets an AI client treat Chat.co like a tool-enabled workspace. Instead of manually writing API calls, you approve access once and let your client use tools for tasks like updating prompts, uploading documents, starting crawls, or reviewing leads.

Start Here if You Want Agent Actions

If you want Claude Desktop, Cursor, or another MCP-compatible client to act on your Chat.co workspace, this guide is the right starting point. If you want raw HTTP requests instead, use the direct API docs.

1. What MCP Setup Gives You

Once connected, your AI client can use Chat.co as a set of tools rather than just a chat endpoint.

Workspace actions

List and inspect chatbots
Update prompts and appearance
Manage whitelist and domain settings
Review analytics, leads, and knowledge gaps

Content operations

Create or update Q&A content
Replace text training
Start crawl jobs
Upload local documents through the MCP server

If you want the comparison first, read API vs MCP.

2. Before You Start

Make sure you have the following ready:

A Chat.co account with at least one chatbot
Access to an MCP-compatible client such as Claude Desktop or Cursor
The Chat.co MCP server available in your local environment
A decision about whether this connection should be scoped to one chatbot or not

Important planning choice

If you want the client to create chatbots or see account-wide analytics, keep the connection unscoped. If you want to restrict it to one bot, plan to use a chatbot ID during login.

3. Run Agent Login

Start the approval flow from your terminal:

chatco-mcp login --name "Claude Desktop"

To limit access to a single chatbot, include a chatbot ID:

chatco-mcp login \
  --name "Claude Desktop" \
  --chatbot-id YOUR_CHATBOT_ID

To customize permissions or expiry, you can also provide scopes and an API key lifetime:

chatco-mcp login \
  --name "Cursor" \
  --scopes "bot:read,bot:write,content:read,content:write" \
  --api-key-expires-in-days 30

The login command prints an approval URL and short code, then waits for approval. You do not have to manually copy a raw API key into the client.

4. Approve Access in Chat.co

Open the URL shown by the login command. If you are not already signed in, Chat.co will ask you to sign in first.

On the approval screen, review:

The requesting client name
The requested scopes
Whether the request is scoped to one chatbot or left unscoped
The API key lifetime
The device approval expiry window

Then choose:

Approve to issue the MCP key
Deny if the request is broader than you intended

After approval, the login command finishes the exchange and writes the issued key to a local file for the MCP server to use.

5. Configure Your MCP Client

Most MCP clients use a configuration entry that launches a local stdio server. The exact file location depends on your client, but the structure usually looks like this:

{
  "mcpServers": {
    "chatco": {
      "type": "stdio",
      "command": "chatco-mcp",
      "env": {
        "CHATCO_API_URL": "https://api.chat.co",
        "CHATCO_API_KEY_FILE": "~/.config/chatco/mcp.key",
        "CHATCO_TIMEOUT_MS": "120000"
      }
    }
  }
}

If your installation runs the Chat.co MCP server differently, keep the same environment variables and replace the command with the one provided by your installer or support team.

What these settings do

Setting	Purpose
CHATCO_API_URL	Points the MCP server at your Chat.co API environment
CHATCO_API_KEY_FILE	Tells the MCP server where to read the approved key
CHATCO_TIMEOUT_MS	Optional request timeout for longer-running operations

6. Verify the Connection

Once your MCP client is configured, confirm the integration with a few safe read operations:

Ask the client to list your chatbots
Ask it to read one chatbot's configuration
Ask it to summarize available tools or describe what it can access

Good first prompts

"List my Chat.co bots."
"Show me the configuration for my support bot."
"Which Chat.co tools are available to you right now?"

If those work, you can move on to write operations like updating prompts, uploading content, or reviewing analytics.

7. Scope & Security Choices

MCP is powerful, so it should be configured intentionally.

Recommended approach

1. Start with the smallest scope that fits the workflow
2. Use a chatbot-scoped connection for single-bot operations
3. Use unscoped access only when you truly need multi-bot or account-level actions
4. Set a reasonable expiry for the approved key
5. Rotate or revoke the connection when the operator or workflow changes

Security reminder

The MCP server runs locally and reads a local key file. Treat that file like any other credential. Do not share it, commit it to version control, or place it in broadly accessible folders.

8. Troubleshooting

The login command keeps waiting

Open the approval URL, make sure you are signed in to Chat.co, and confirm the request has not expired.

The client connects but cannot do much

The approved key may be too narrow or scoped to a single chatbot. Re-run login with the scopes you need.

Account-wide analytics are missing

You likely used a chatbot-scoped key. Reconnect without a chatbot ID if you need account-level operations.

Document upload fails

Make sure the file path is local, readable by the MCP server, and that your bot has the required knowledge base access and available storage credits.

The connection stops working later

The approved key may have expired. Run agent login again to renew it.

For broader integration planning, read API vs MCP. For raw HTTP integrations, continue to the API documentation. For a start-to-finish example, read Build a Private-App Chatbot with MCP in 30 Minutes.

Key Takeaways