CoreSpeed

One MCP for any agent: your connected apps, shared memory, web search, social data and media tools.

Hosted MCP Server

npx add-mcp 'https://api.corespeed.io/mcp'

Installs into Claude Code, Codex, Cursor and more

Documentation

MCP server (/docs/mcp)

Connect your agent to CoreSpeed over the Model Context Protocol, the open standard agents use to discover and call tools.

Quick setup

Give your agent this line. It adds the server, signs you in, and asks which of your apps to connect.

set up https://corespeed.io/SKILL.md (read it raw, e.g. with curl)

The skill it fetches is SKILL.md.

What is the CoreSpeed MCP server?

https://api.corespeed.io/mcp

One remote server over Streamable HTTP, signed in once through the browser or with an API key, gives every agent you run:

  • The tools of every app your organization has connected — Notion, Slack, GitHub, X, and the rest — as notion__create_page, slack__post_message, … (Connectors)
  • Durable memory that follows you across agents and sessions (Memory)
  • Media generation and understanding, live web search, and public social data (Media, Web, Social)
  • A file system every tool shares, mountable as S3 (Drive)
  • Your organization's own MCP servers, as org__<slug>__<tool> (Remote MCP servers)

Every call carries your organization's spend caps, lands in one ledger, and is recorded in the activity trail (Billing & credits, Activity & audit). The server implements the MCP Authorization and Streamable HTTP specifications.

Available tools

The tool list is yours, not a catalog. tools/list returns exactly what your sign-in can call: the tools of your connected accounts, the built-in capabilities you have enabled, and the manage__* account tools. Names are <capability>__<operation>. Each family is documented on its own page — Connectors, Memory, Media, Web, Social, Drive, and the manage__* reference.

Supported clients

Any client that speaks Streamable HTTP and MCP Authorization connects with the URL alone — CoreSpeed's authorization server supports both dynamic client registration and client ID metadata documents, so there is nothing to register first. Clients without OAuth use an API key.

Claude.ai and Claude Desktop and ChatGPT connect too, as custom connectors, and any other client that reads an mcpServers map takes the same entry.

Set up your client

Add the server at user scope — the configuration that applies to every project — and sign in when the client asks. If the client already has an older corespeed entry, replace it: duplicate registrations collide on tool names.

Claude Code

claude mcp add corespeed https://api.corespeed.io/mcp \
  --transport http --scope user   # user scope: every project, not just this one
claude                            # start Claude Code
/mcp                              # pick corespeed and authenticate in the browser

Codex

codex mcp add corespeed --url https://api.corespeed.io/mcp
codex mcp login corespeed   # signs in through the browser

Cursor

Click the button, or add the entry to ~/.cursor/mcp.json yourself. Cursor then shows Needs login beside the server; click it to sign in.

One-click install: cursor://anysphere.cursor-deeplink/mcp/install?name=corespeed&config=eyJ1cmwiOiJodHRwczovL2FwaS5jb3Jlc3BlZWQuaW8vbWNwIn0%3D

{
  "mcpServers": {
    "corespeed": {
      "url": "https://api.corespeed.io/mcp"
    }
  }
}

Copilot in VS Code

Click the button, or run MCP: Add Server from the Command Palette, choose HTTP, enter the URL and the name corespeed, and pick Global. Then run MCP: List Servers, start corespeed, and allow the sign-in when VS Code asks.

One-click install: vscode:mcp/install?%7B%22name%22%3A%22corespeed%22%2C%22type%22%3A%22http%22%2C%22url%22%3A%22https%3A%2F%2Fapi.corespeed.io%2Fmcp%22%7D

{
  "servers": {
    "corespeed": {
      "type": "http",
      "url": "https://api.corespeed.io/mcp"
    }
  }
}

OpenClaw

Add the server to the gateway configuration with OAuth, then sign in from the CLI; it prints the authorization URL to open if it cannot open the browser.

{
  mcp: {
    servers: {
      corespeed: {
        url: "https://api.corespeed.io/mcp",
        transport: "streamable-http",
        auth: "oauth",
      },
    },
  },
}
openclaw mcp login corespeed

Hermes

Hermes runs the OAuth flow itself: on the first connect it opens the browser to sign in and caches the token. In a running session, /reload-mcp picks up the change.

mcp_servers:
  corespeed:
    url: https://api.corespeed.io/mcp
    auth: oauth

Claude.ai and Claude Desktop

Custom connectors are available on the Pro, Max, Team, and Enterprise plans.

Click the button to open the Add custom connector dialog with the name and URL filled in, or add it yourself:

One-click install: https://claude.ai/customize/connectors?modal=add-custom-connector&connectorName=CoreSpeed&connectorUrl=https%3A%2F%2Fapi.corespeed.io%2Fmcp

  1. Open Customize → Connectors and choose Add custom connector.
  2. Name it CoreSpeed and enter the URL https://api.corespeed.io/mcp.
  3. Choose Connect and sign in.

ChatGPT

Custom connectors run under ChatGPT's Developer mode, on Plus and Pro accounts on the web.

  1. Turn on Developer mode under Settings → Connectors → Advanced settings.
  2. In Connectors, choose Create: name CoreSpeed, MCP server URL https://api.corespeed.io/mcp, authentication OAuth.
  3. Sign in when prompted. The connector appears under the composer's Developer mode tools.

Other clients

Any client that reads an mcpServers map takes this entry; add it at user scope and sign in when the client asks.

{
  "mcpServers": {
    "corespeed": {
      "type": "http",
      "url": "https://api.corespeed.io/mcp"
    }
  }
}

Without a browser

Clients that cannot open a browser — CI, headless agents, a client without OAuth — send an API key from Dashboard → API keys instead. A member key acts as you; an agent key acts as an agent principal and reaches shared accounts only. See Authentication.

{
  "mcpServers": {
    "corespeed": {
      "type": "http",
      "url": "https://api.corespeed.io/mcp",
      "headers": {
        "Authorization": "Bearer sk-cs-..."
      }
    }
  }
}

Transport and discovery

The transport is Streamable HTTP and stateless: one JSON-RPC call per HTTP request, batches rejected, and no GET /mcp stream. Discovery is caller-specific, so both answers come from authenticated calls:

QuestionSource of truth
Which apps can this caller connect, and what account state exists?GET /connectors
Which tools can this caller invoke right now?tools/list on POST /mcp

For registries that cannot sign in, GET /.well-known/mcp/server-card.json lists the built-in tools with no credential. It leaves out connector and account tools, so it is never a caller's tool list.

Never construct a tool inventory in application code. Run tools/list after authentication and use the returned names and input schemas. Read it with three caveats:

  • Absence is a decision, not a bug. If a tool is missing, this caller cannot invoke it: the capability is off, or the account is not connected.
  • Presence is not health. A connector account in needs_reauth still contributes tools; those calls fail until the account is reauthorized. Check account status in GET /connectors when a visible tool keeps failing.
  • Presence is not permission. Every manage__* tool is listed for an API-key caller; a call runs with what the key holds, so an agent key is refused on a permission-gated write, on a mint (api_key_cannot_mint) and on a member's own act (member_principal_required) — see Authentication. An account shared with you for some tools lists all of them, and the others answer tool_not_granted.

Toolsets: a session with fewer accounts

Toolsets are being removed. You can no longer create or change a toolset, or bind a key to one: those requests answer toolsets_removed. A toolset that exists keeps working until the removal, and a key bound to one keeps exactly its limits after it. A toolset URL (/mcp/toolset/<slug>, /mcp/env/<name>) stops working at the removal: use /mcp with a key that carries its own scope (Only these in the dashboard's key form).

A toolset is a named subset of connected accounts, each with an optional list of the tools allowed on it, by the names tools/list publishes (github__list_issues). Point a client at https://api.corespeed.io/mcp/toolset/<slug> instead of /mcp, and that session reaches only the toolset's accounts — tools/list drops every other connector and every tool an entry leaves out. Built-in tools (memory, media, web, the manage__* tools) are unaffected. The same sign-in serves every toolset URL; the URL, not the token, picks the toolset, and the model cannot change it. /mcp/env/<name>, the URL's first name, keeps working and reads names.

A toolset is yours, an agent's you manage, or your organization's. Its name is unique in the organization, across personal and organization toolsets. Its slug is the name it was created with and never changes, so a rename keeps its URL. An organization toolset's URL works for everyone in the organization; a personal one's only for its owner. Anyone in the organization may use an organization toolset, and reaches only the part of it they could reach anyway. Only a holder of connections:org creates or edits one.

A key bound to a toolset before the freeze runs in that toolset on /mcp too. A new key carries its own scope instead, scope: { entries: [...] }, with the same entries a toolset holds.

A toolset only narrows. It never adds an account, and an account someone stops sharing with you drops out of it. List and delete the toolsets that exist with the manage__toolsets_* tools from a session outside any toolset. A name that matches no toolset answers 404 toolset_not_found; a key bound to another toolset answers 403 toolset_mismatch; a call outside the toolset answers tool_not_in_toolset.

Calling tools

Organization billing holds and API-key spend caps are checked before a metered tool executes. Every tool on a metered capability is held, even one that costs 0 credits, such as a memory read. Those refusals come back as an MCP isError result inside an HTTP 200, so check result.isError, not just the status. A suspended organization is refused earlier, with HTTP 403 on every request. The request body, response fields, and every code are in the tools/call reference and Error handling.

Security best practices

  • Verify the endpoint. The server is https://api.corespeed.io/mcp and sign-in happens at login.corespeed.io; the consent screen names the client that is asking. A one-click install from a marketplace should point at exactly that URL.
  • Sign-in grants the agent what you can do. Every private and shared connection in your active organization is reachable through it. Connect only the accounts you want agents to act through, and give unattended agents an agent key (sk-csa-), which reaches shared accounts only — see Authentication.
  • Cap the spend. Put a monthly cap on every API key and let the wallet hold stop metered calls before they run — see Billing & credits.
  • Treat fetched content as untrusted. Pages, posts, and documents read through web, social, and connector tools can carry instructions aimed at the agent. Keep your client's confirmation on for actions that write or send, especially when other MCP servers are connected alongside CoreSpeed.
  • Read the trail. Every call is attributed to a member or agent in Dashboard → Activity.