Connect Claude, Cursor and more

Any MCP client that supports remote Streamable HTTP servers with a custom header can connect to StickyPrompts. You need two things: the endpoint and an API key.

URL:     https://api.stickyprompts.com/mcp/
Header:  Authorization: Bearer STICKY-API-...

Keep the trailing slash on the URL. The tools your client sees depend on the key’s permissions, so create a key for the assistant with only the permissions it needs - see Permissions reference.

Before you start

1. Create a key for your assistant

   In Settings > API keys, select Generate key, name it after the client (for example Claude Code - laptop) and tick the permissions for the tools you want. Copy the key; it is shown once.

2. Put it in an environment variable

   export STICKY_API_KEY="STICKY-API-..."

   Config files that contain a key belong in your secret store or your home directory, never in a shared repository.

Claude Code

Add the server with one command:

zsh

$ claude mcp add --transport http stickyprompts https://api.stickyprompts.com/mcp/ --header "Authorization: Bearer $STICKY_API_KEY"

$ claude mcp list

Your shell expands $STICKY_API_KEY when you run the command, so the key is stored in Claude Code’s configuration. Run claude mcp add --help to choose where it is saved (just you, or a project). Inside a Claude Code session, /mcp shows the server’s connection status and its tools.

To share the setup with a team without sharing a key, you can instead commit a project .mcp.json that reads the key from each developer’s environment (example):

{
  "mcpServers": {
    "stickyprompts": {
      "type": "http",
      "url": "https://api.stickyprompts.com/mcp/",
      "headers": {
        "Authorization": "Bearer ${STICKY_API_KEY}"
      }
    }
  }
}

Claude Desktop and claude.ai

Custom connectors in Claude Desktop and claude.ai are added by URL and sign in with OAuth. The StickyPrompts MCP server authenticates with an API key header and has no OAuth sign-in, so a URL-only custom connector cannot connect to it.

What works instead is a local bridge that forwards to the remote server and adds the header. For example, with mcp-remote in Claude Desktop’s claude_desktop_config.json (example; requires Node.js):

{
  "mcpServers": {
    "stickyprompts": {
      "command": "npx",
      "args": [
        "mcp-remote",
        "https://api.stickyprompts.com/mcp/",
        "--header",
        "Authorization:${AUTH_HEADER}"
      ],
      "env": {
        "AUTH_HEADER": "Bearer STICKY-API-..."
      }
    }
  }
}

Passing the value through env avoids problems some systems have with spaces inside args. Restart Claude Desktop after editing the file.

Cursor

Add the server to .cursor/mcp.json in your project, or to the global mcp.json in your Cursor settings folder to use it everywhere (example):

{
  "mcpServers": {
    "stickyprompts": {
      "url": "https://api.stickyprompts.com/mcp/",
      "headers": {
        "Authorization": "Bearer STICKY-API-..."
      }
    }
  }
}

Open Cursor’s MCP settings to check that the server is connected and to see its tools. If you use a project file, add it to .gitignore or use Cursor’s environment-variable syntax so the key is not committed.

VS Code

VS Code reads MCP servers from .vscode/mcp.json. Its format uses a servers key and can prompt for the key instead of storing it (example):

{
  "inputs": [
    {
      "type": "promptString",
      "id": "sticky-api-key",
      "description": "StickyPrompts API key",
      "password": true
    }
  ],
  "servers": {
    "stickyprompts": {
      "type": "http",
      "url": "https://api.stickyprompts.com/mcp/",
      "headers": {
        "Authorization": "Bearer ${input:sticky-api-key}"
      }
    }
  }
}

Start the server from the file or from the MCP servers view, enter your key when asked, and the StickyPrompts tools appear in agent mode’s tool picker.

Other clients

For any client that supports remote HTTP servers with headers, the generic shape is (example; key names vary slightly between clients, for example type or transport):

{
  "mcpServers": {
    "stickyprompts": {
      "type": "http",
      "url": "https://api.stickyprompts.com/mcp/",
      "headers": {
        "Authorization": "Bearer STICKY-API-..."
      }
    }
  }
}

Clients that only speak stdio can use the mcp-remote bridge shown in the Claude Desktop section.

MCP Inspector

MCP Inspector is the quickest way to see exactly which tools your key exposes and to call them by hand.

zsh

$ npx @modelcontextprotocol/inspector

In the Inspector, choose the Streamable HTTP transport, enter https://api.stickyprompts.com/mcp/, add an Authorization header with Bearer STICKY-API-..., and connect. List Tools shows the tools your key’s permissions allow.

Raw handshake with curl

Speaking the protocol by hand is useful for debugging. First, initialize a session and note the Mcp-Session-Id response header:

curl -i https://api.stickyprompts.com/mcp/ \
  -H "Authorization: Bearer $STICKY_API_KEY" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json, text/event-stream" \
  -d '{"jsonrpc":"2.0","id":1,"method":"initialize","params":{"protocolVersion":"2025-06-18","capabilities":{},"clientInfo":{"name":"curl","version":"0"}}}'

The response reports the server as StickyPrompts 1.0.0 with the tools capability, and carries a header like Mcp-Session-Id: mcp-session-<uuid>. Then list the tools, sending that session id:

curl https://api.stickyprompts.com/mcp/ \
  -H "Authorization: Bearer $STICKY_API_KEY" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json, text/event-stream" \
  -H "Mcp-Session-Id: mcp-session-..." \
  -d '{"jsonrpc":"2.0","id":2,"method":"tools/list"}'

And call one:

curl https://api.stickyprompts.com/mcp/ \
  -H "Authorization: Bearer $STICKY_API_KEY" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json, text/event-stream" \
  -H "Mcp-Session-Id: mcp-session-..." \
  -d '{"jsonrpc":"2.0","id":3,"method":"tools/call","params":{"name":"list_agents","arguments":{}}}'

The result’s content[0].text is a JSON string, for example {"agents":[{"id":3,"name":"Support Triage","slug":"...","tag":"support-triage"}]}.

Test it

Once connected, try prompts like these in your client. Each needs the permission shown.

Try asking	Tool it uses	Permission
“List my StickyPrompts agents.”	list_agents	agents_get
“Search my knowledge base for our refund policy.”	list_knowledge_bases, search_knowledge_base	knowledge_bases_get
“Which AI models can I use in StickyPrompts?”	list_ai_models	ai_models_get
“Show my last five StickyPrompts conversations.”	list_conversations	conversations_get
“Run my Renewal Check-in Email prompt for Bluebird Market.”	get_prompt, run_prompt	prompts_get, run_prompt
“Which Pipedrive deals are in Proposal Made?”	list_crm_connections, search_crm_deals	integration_crm_get
“What tables are in the Northwind retail database?”	list_database_connections, list_database_tables	integration_database_get

Troubleshooting

Symptom	Likely cause
401 {"error":"unauthorized"}	The header is missing or not in the form Bearer STICKY-API-....
401 {"error":"Invalid API key"}	The key was mistyped, truncated or deleted.
Connected, but no tools or a tool is missing	The key lacks that tool’s permission. Edit the key in Settings > API keys.
tool '<name>' not found	Same as above: a tool without permission looks exactly like one that does not exist.
The client cannot connect to /mcp	Use /mcp/ with the trailing slash; some clients do not follow the redirect.
Long calls time out	Music, speech, transcription and slow models can take a while. Raise your client’s request timeout.

See MCP overview for how sessions, results and errors work, and the tool reference for every tool’s arguments.