> ## Documentation Index
> Fetch the complete documentation index at: https://docs.trybloom.ai/llms.txt
> Use this file to discover all available pages before exploring further.

# Connect Bloom

> Connect each agent to Bloom MCP — sign in with Bloom, or use a static API key.

Copy the Bloom MCP server URL:

```text theme={null}
https://www.trybloom.ai/api/mcp
```

Bloom supports two ways to authenticate:

* **Sign in with Bloom (OAuth)** — the default for interactive clients. Sign in through a browser the first time the client connects.
* **API key** — a static `bloom_sk_...` key for a server, continuous-integration job, automation host, or another environment without browser sign-in.

Create an API key from your [account settings](https://www.trybloom.ai/settings/api-keys) and treat it like a password. Reference it from an environment variable or secret store, never commit it or expose it client-side. The examples below use `BLOOM_API_KEY` where the client supports environment variables.

An API key can use either header form; use the one your client expects:

```http theme={null}
x-api-key: bloom_sk_...
```

```http theme={null}
Authorization: Bearer bloom_sk_...
```

## Choose your client

<Tabs>
  <Tab title="Claude">
    ### Sign in with Bloom

    OAuth works in the Claude desktop app and on claude.ai (Pro, Max, Team, and Enterprise).

    <Steps>
      <Step title="Open the connector settings">
        Go to **Settings → Connectors** and click **Add custom connector**.
      </Step>

      <Step title="Add the server">
        Paste the server URL and click **Connect**.
      </Step>

      <Step title="Sign in">Sign in with Bloom when the browser opens.</Step>
    </Steps>

    ### API key

    claude.ai is sign-in only. Claude Desktop can use a key through the [`mcp-remote`](https://www.npmjs.com/package/mcp-remote) bridge, but the key is stored in plaintext in `claude_desktop_config.json`. Keep that file private and add Bloom under **Settings → Developer → Edit Config**:

    ```json theme={null}
    {
      "mcpServers": {
        "bloom": {
          "command": "npx",
          "args": [
            "-y",
            "mcp-remote",
            "https://www.trybloom.ai/api/mcp",
            "--header",
            "x-api-key:bloom_sk_..."
          ]
        }
      }
    }
    ```

    Restart Claude Desktop to pick up the change.
  </Tab>

  <Tab title="Claude Code">
    ### Sign in with Bloom

    <Steps>
      <Step title="Add the server">
        ```bash theme={null}
        claude mcp add --transport http bloom https://www.trybloom.ai/api/mcp
        ```

        Add `--scope user` to make it available across all your projects.
      </Step>

      <Step title="Sign in">
        Run `/mcp` inside Claude Code and sign in with Bloom when prompted.
      </Step>
    </Steps>

    ### API key

    Pass the key as a header when you add the server:

    ```bash theme={null}
    claude mcp add --transport http bloom https://www.trybloom.ai/api/mcp \
      --header 'x-api-key:${BLOOM_API_KEY}'
    ```

    Set `BLOOM_API_KEY` before starting Claude Code. Add `--scope user` to make the server available across all your projects.
  </Tab>

  <Tab title="Codex">
    ### Sign in with Bloom

    Codex CLI, the Codex IDE extension, and the ChatGPT desktop app share MCP configuration.

    <Steps>
      <Step title="Add the server">
        ```bash theme={null}
        codex mcp add bloom --url https://www.trybloom.ai/api/mcp
        ```
      </Step>

      <Step title="Sign in">
        ```bash theme={null}
        codex mcp login bloom
        ```

        Use `/mcp` inside Codex to confirm that Bloom is connected.
      </Step>
    </Steps>

    ### API key

    Set `BLOOM_API_KEY`, then add Bloom to `~/.codex/config.toml` or a trusted project's `.codex/config.toml`:

    ```toml theme={null}
    [mcp_servers.bloom]
    url = "https://www.trybloom.ai/api/mcp"
    bearer_token_env_var = "BLOOM_API_KEY"
    ```
  </Tab>

  <Tab title="Cursor">
    ### Sign in with Bloom

    <Steps>
      <Step title="Add the server">
        Add Bloom to `~/.cursor/mcp.json` (global) or `.cursor/mcp.json` (project):

        ```json theme={null}
        {
          "mcpServers": {
            "bloom": {
              "url": "https://www.trybloom.ai/api/mcp"
            }
          }
        }
        ```
      </Step>

      <Step title="Sign in">Sign in with Bloom when Cursor prompts.</Step>
    </Steps>

    ### API key

    Add a `headers` block to the same file:

    ```json theme={null}
    {
      "mcpServers": {
        "bloom": {
          "url": "https://www.trybloom.ai/api/mcp",
          "headers": {
            "x-api-key": "${env:BLOOM_API_KEY}"
          }
        }
      }
    }
    ```

    Set `BLOOM_API_KEY` before starting Cursor.
  </Tab>

  <Tab title="VS Code">
    ### Sign in with Bloom

    <Steps>
      <Step title="Add the server">
        Add Bloom to `.vscode/mcp.json`:

        ```json theme={null}
        {
          "servers": {
            "bloom": {
              "type": "http",
              "url": "https://www.trybloom.ai/api/mcp"
            }
          }
        }
        ```
      </Step>

      <Step title="Sign in">Sign in with Bloom when VS Code prompts.</Step>
    </Steps>

    ### API key

    Use an `inputs` block so VS Code prompts for the key once and stores it securely:

    ```json theme={null}
    {
      "inputs": [
        {
          "type": "promptString",
          "id": "bloom-api-key",
          "description": "Bloom API Key",
          "password": true
        }
      ],
      "servers": {
        "bloom": {
          "type": "http",
          "url": "https://www.trybloom.ai/api/mcp",
          "headers": {
            "x-api-key": "${input:bloom-api-key}"
          }
        }
      }
    }
    ```
  </Tab>

  <Tab title="ChatGPT desktop">
    The ChatGPT desktop app shares MCP configuration with Codex.

    <Steps>
      <Step title="Open MCP settings">
        Open **Settings → MCP servers** and select **Add server**.
      </Step>

      <Step title="Add Bloom">
        Name the server `Bloom`, choose **Streamable HTTP**, and enter the Bloom MCP server URL.
      </Step>

      <Step title="Restart and sign in">
        Save the server, restart the app, then select **Authenticate** and sign in with Bloom. Use `/mcp` in the composer to confirm the connection.
      </Step>
    </Steps>

    ChatGPT on the web uses MCP tools supplied through installed workspace plugins. Bloom does not currently document a public ChatGPT web installation path.
  </Tab>

  <Tab title="OpenClaw">
    ### Sign in with Bloom

    <Steps>
      <Step title="Add the server">
        ```bash theme={null}
        openclaw mcp add bloom --url https://www.trybloom.ai/api/mcp --transport streamable-http --auth oauth
        ```
      </Step>

      <Step title="Sign in">
        Run `openclaw mcp login bloom` and complete the browser sign-in.
      </Step>
    </Steps>

    ### API key

    ```bash theme={null}
    openclaw mcp add bloom \
      --url https://www.trybloom.ai/api/mcp \
      --transport streamable-http \
      --header "x-api-key:$BLOOM_API_KEY"
    ```
  </Tab>

  <Tab title="Hermes Agent">
    ### Sign in with Bloom

    <Steps>
      <Step title="Add the server">
        ```bash theme={null}
        hermes mcp add bloom --url https://www.trybloom.ai/api/mcp
        ```

        When it asks about authentication, choose OAuth.
      </Step>

      <Step title="Sign in">
        Complete the browser sign-in, then verify with `hermes mcp test bloom`.
      </Step>
    </Steps>

    ### API key

    Add the server, then paste the key when Hermes prompts for authentication:

    ```bash theme={null}
    hermes mcp add bloom --url https://www.trybloom.ai/api/mcp
    ```

    Verify the connection with `hermes mcp test bloom`.
  </Tab>
</Tabs>