The crea8.one MCP server

MCP (Model Context Protocol) is how an AI client calls an outside app. After you connect this server, the client can use the three crea8.one products:

• The social media scheduler, to draft and schedule posts.
• Stalker, to read mention monitoring.
• Link-in-Bio, to read and update the page.

Create an API key in the app at https://app.crea8.one, under developer / API settings. The key is a secret. Prefer OAuth, or a header that reads CREA8_API_KEY, when the client supports it.

The same server accepts all three. Pick the one your client can send.

1. OAuth. Use https://mcp.crea8.one/mcp. The client opens a sign-in and stores its own token. You do not paste the API key.
2. Bearer API key. The client sends Authorization: Bearer plus the key from developer / API settings.
3. Key in the path. Use https://mcp.crea8.one/mcp/YOUR_API_KEY, which is /mcp/:apiKey. Use this when the client can store a URL and cannot send a header. The path contains the secret, so do not commit it or share the URL.

https://mcp.crea8.one/mcp

https://mcp.crea8.one/mcp/YOUR_API_KEY

Each block matches that client's current config format. Replace YOUR_API_KEY only where the snippet shows it. Where the snippet uses CREA8_API_KEY, export the key in the environment that launches the client:

export CREA8_API_KEY="your_api_key"

• ChatGPT
• Claude
• Claude Code
• Cursor
• Gemini CLI
• Codex
• Grok Build
• Manus
• VS Code
• Windsurf
• Zed
• Cline
• Continue

ChatGPT on the web adds a remote MCP server as a plugin. OpenAI's current guide lists OAuth, no authentication, and a mix of the two. It does not list a Bearer header field, so an API key goes in the server URL.

1. Open ChatGPT Plugins.
2. Select the plus button, then Add custom MCP server.
3. Name it crea8.one. Paste the server URL below.
4. For OAuth, set authentication to OAuth. For an API key, set authentication to No authentication and use the key URL.
5. Review the warning, choose I understand and want to continue, then Create as a plugin. Install the plugin before you use it.
6. In a chat, type @ and select crea8.one. Write actions ask you to confirm.

Name: crea8.one
Server URL: https://mcp.crea8.one/mcp
Authentication: OAuth

Name: crea8.one
Server URL: https://mcp.crea8.one/mcp/YOUR_API_KEY
Authentication: No authentication

Full chat steps are on the ChatGPT page. Source: Add custom MCP server.

Claude on the web, Claude Desktop, and Cowork use the same remote connector. Add it from Connectors. Do not put this URL in claude_desktop_config.json. That file is for local stdio servers.

On Free, Pro, and Max: Customize, then Connectors, then Add custom connector. The Free plan allows one custom connector. On Team and Enterprise, an Owner adds it under Organization settings, Connectors, Add, Custom. If Claude asks for a type, choose Web. Members then connect it from Customize, Connectors.

For OAuth, choose Sign in when needed (or Sign in now). Leave the OAuth client on Claude's published identity, or Register automatically, unless you already registered a client of your own.

For an API key, choose No sign-in and add a request header. The header name is authorization. The value is Bearer YOUR_API_KEY, including the word Bearer and the space. Claude sends the value exactly as you type it. Request headers are in beta. If you do not see that section, use the key-in-path URL with No sign-in instead.

Name: crea8.one
MCP server URL: https://mcp.crea8.one/mcp
Authentication: Sign in when needed

Name: crea8.one
MCP server URL: https://mcp.crea8.one/mcp
Authentication: No sign-in
Request header name: authorization
Request header value: Bearer YOUR_API_KEY

Name: crea8.one
MCP server URL: https://mcp.crea8.one/mcp/YOUR_API_KEY
Authentication: No sign-in

Source: Add a connector that isn't in the directory.

HTTP is the remote transport. A JSON entry needs "type": "http". An entry with a URL and no type is treated as a local stdio server and skipped. In .mcp.json, Claude Code expands ${CREA8_API_KEY} in url and headers. The Bearer command uses --scope project so it writes that file. Keep the header quotes single so the shell leaves the variable reference in place.

claude mcp add --transport http crea8one https://mcp.crea8.one/mcp

claude mcp add --transport http --scope project crea8one https://mcp.crea8.one/mcp \
  --header 'Authorization: Bearer ${CREA8_API_KEY}'

{
  "mcpServers": {
    "crea8one": {
      "type": "http",
      "url": "https://mcp.crea8.one/mcp"
    }
  }
}

{
  "mcpServers": {
    "crea8one": {
      "type": "http",
      "url": "https://mcp.crea8.one/mcp",
      "headers": {
        "Authorization": "Bearer ${CREA8_API_KEY}"
      }
    }
  }
}

User scope (--scope user) writes ~/.claude.json. Project scope (--scope project) writes .mcp.json, which Claude Code asks you to approve. After an OAuth add, sign in when Claude Code prompts. Source: Connect Claude Code to tools via MCP.

Put this in ~/.cursor/mcp.json for every project, or .cursor/mcp.json for one project. You can also add it from Customize. A remote server uses url. Cursor interpolates ${env:CREA8_API_KEY} in url and headers. With no Authorization header, Cursor uses OAuth when the server asks you to sign in.

{
  "mcpServers": {
    "crea8one": {
      "url": "https://mcp.crea8.one/mcp"
    }
  }
}

{
  "mcpServers": {
    "crea8one": {
      "url": "https://mcp.crea8.one/mcp",
      "headers": {
        "Authorization": "Bearer ${env:CREA8_API_KEY}"
      }
    }
  }
}

Source: Cursor MCP.

Streamable HTTP uses httpUrl in ~/.gemini/settings.json (--scope user) or .gemini/settings.json (project, the default). Omit headers for OAuth. Gemini CLI discovers the authorization server after a 401 and opens a browser. Run /mcp auth crea8one inside the CLI to sign in again.

The --header flag stores the header value you pass. Export CREA8_API_KEY first so the shell fills it in. The JSON example matches the documented header shape, which is a literal Bearer value.

gemini mcp add --scope user --transport http crea8one https://mcp.crea8.one/mcp

gemini mcp add --scope user --transport http \
  --header "Authorization: Bearer $CREA8_API_KEY" \
  crea8one https://mcp.crea8.one/mcp

{
  "mcpServers": {
    "crea8one": {
      "httpUrl": "https://mcp.crea8.one/mcp"
    }
  }
}

{
  "mcpServers": {
    "crea8one": {
      "httpUrl": "https://mcp.crea8.one/mcp",
      "headers": {
        "Authorization": "Bearer YOUR_API_KEY"
      }
    }
  }
}

Source: MCP servers with Gemini CLI.

Codex stores MCP servers in ~/.codex/config.toml. A streamable HTTP server uses url. The bearer token is the name of an environment variable, bearer_token_env_var, not the key itself. Codex rejects an inline bearer_token field. codex mcp login starts OAuth for a streamable HTTP server. The variable has to be set in the environment that launches Codex.

codex mcp add crea8one --url https://mcp.crea8.one/mcp
codex mcp login crea8one

export CREA8_API_KEY="your_api_key"
codex mcp add crea8one --url https://mcp.crea8.one/mcp --bearer-token-env-var CREA8_API_KEY

[mcp_servers.crea8one]
url = "https://mcp.crea8.one/mcp"

[mcp_servers.crea8one]
url = "https://mcp.crea8.one/mcp"
bearer_token_env_var = "CREA8_API_KEY"

Source: Codex CLI reference and configuration reference.

grok mcp add --transport http writes ~/.grok/config.toml. --scope project writes .grok/config.toml instead. A URL with no header uses OAuth and opens a browser on first use. Header values are stored as written, and ${CREA8_API_KEY} expands when Grok Build loads the file. Use single quotes in the shell command so the shell leaves that reference in place.

grok mcp add --transport http crea8one https://mcp.crea8.one/mcp

grok mcp add --transport http crea8one https://mcp.crea8.one/mcp \
  --header 'Authorization: Bearer ${CREA8_API_KEY}'

[mcp_servers.crea8one]
url = "https://mcp.crea8.one/mcp"

[mcp_servers.crea8one]
url = "https://mcp.crea8.one/mcp"
headers = { Authorization = "Bearer ${CREA8_API_KEY}" }

Source: Grok Build MCP servers.

In Manus, open Settings, then Integrations, then Custom MCP Servers, and choose Add Server. If your account shows Connectors instead, use Create, then Add MCP by URL. Set the name to crea8.one, the URL to the server, and authentication to a Bearer token. The token value includes the Bearer prefix. If that screen has no header field, use the key-in-path URL.

Name: crea8.one
Server URL: https://mcp.crea8.one/mcp
Authentication: Bearer YOUR_API_KEY

Name: crea8.one
Server URL: https://mcp.crea8.one/mcp/YOUR_API_KEY

Source: Manus custom MCP servers.

The VS Code file is .vscode/mcp.json (or the user profile), with a top-level servers object. Command Palette: MCP: Add Server. type is http. VS Code tries streamable HTTP, then falls back to SSE. A Bearer key can be an input variable, which VS Code prompts for once. Agent Host sessions do not receive servers that use ${input:...}. For those, put the key in the URL. The portable file .mcp.json uses mcpServers instead of servers.

{
  "servers": {
    "crea8one": {
      "type": "http",
      "url": "https://mcp.crea8.one/mcp"
    }
  }
}

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

{
  "servers": {
    "crea8one": {
      "type": "http",
      "url": "https://mcp.crea8.one/mcp/YOUR_API_KEY"
    }
  }
}

Source: VS Code MCP configuration.

Cascade reads mcp_config.json. Open it from the MCP menu (Open MCP config file), or from Settings, Tools, Windsurf Settings, Add Server. The current file is ~/.config/devin/mcp_config.json on macOS and Linux. A remote server uses serverUrl. Cascade expands ${env:CREA8_API_KEY} in serverUrl and headers, and it supports OAuth for streamable HTTP when you leave the header off.

{
  "mcpServers": {
    "crea8one": {
      "serverUrl": "https://mcp.crea8.one/mcp"
    }
  }
}

{
  "mcpServers": {
    "crea8one": {
      "serverUrl": "https://mcp.crea8.one/mcp",
      "headers": {
        "Authorization": "Bearer ${env:CREA8_API_KEY}"
      }
    }
  }
}

Source: Cascade MCP integration.

Settings, AI, MCP Servers, Add Remote Server. Zed writes context_servers in settings. A remote server uses url. If there is no Authorization header, Zed starts the MCP OAuth flow. The Bearer example matches Zed's documented header field.

{
  "context_servers": {
    "crea8one": {
      "url": "https://mcp.crea8.one/mcp"
    }
  }
}

{
  "context_servers": {
    "crea8one": {
      "url": "https://mcp.crea8.one/mcp",
      "headers": {
        "Authorization": "Bearer YOUR_API_KEY"
      }
    }
  }
}

Source: Zed MCP.

In the Cline panel, open MCP Servers, then the Remote Servers tab. Choose Streamable HTTP. In JSON, set type to streamableHttp. If you omit type, Cline uses legacy SSE. The CLI can add the same server. OAuth is the config with no Authorization header; use Cline's authorize action to sign in. The extension settings file is the one opened by Configure MCP Servers. The CLI file is ~/.cline/mcp.json.

{
  "mcpServers": {
    "crea8one": {
      "type": "streamableHttp",
      "url": "https://mcp.crea8.one/mcp"
    }
  }
}

{
  "mcpServers": {
    "crea8one": {
      "type": "streamableHttp",
      "url": "https://mcp.crea8.one/mcp",
      "headers": {
        "Authorization": "Bearer YOUR_API_KEY"
      }
    }
  }
}

cline mcp add crea8one https://mcp.crea8.one/mcp --transport http --header "Authorization: Bearer YOUR_API_KEY" --yes

Source: Cline MCP.

Save this as .continue/mcpServers/crea8one.yaml. Continue documents remote servers as type: streamable-http with a url. The documented fields for that block do not include a headers map, so the API key goes in the path. Include name, version, and schema on a standalone file.

name: crea8.one
version: 0.0.1
schema: v1
mcpServers:
  - name: crea8.one
    type: streamable-http
    url: https://mcp.crea8.one/mcp/YOUR_API_KEY

Source: MCP in Continue.

Add a remote streamable HTTP server. Use https://mcp.crea8.one/mcp when the client can complete OAuth or send Authorization: Bearer with your API key. Use https://mcp.crea8.one/mcp/YOUR_API_KEY when it can only store a URL. Field names differ by client. The sections above are the ones checked against current docs. Do not reuse one client's JSON in another client that expects a different shape.

If the agent runs shell commands and does not speak MCP, use the crea8one-agent CLI. It reads CREA8_API_KEY.