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

# Connect developer tools

> Use Bouncy in Cursor, VS Code, Devin Desktop (Windsurf), Gemini CLI and MCP Inspector

Every tool on this page can connect to Bouncy in one of two ways:

* **Sign in (recommended):** add the URL and the tool opens the Bouncy approval page. No key to store.
* **API key:** send a Bouncy API key in the `Authorization` header. Useful on servers, in CI, or in tools that cannot open a browser.

The server URL is always:

```text theme={null}
https://mcp.bouncy.ai/mcp
```

For the API key option, create a key in the [API dashboard](https://app.bouncy.ai/api/dashboard) and choose its role (Full Access, Creator or Viewer). The role decides which tools the AI sees, exactly like the access level on the approval page. See [Authentication](/authentication) for key details.

<Warning>
  An API key is as powerful as a password for your Bouncy account. Keep it out of files you commit: use an environment variable or your tool's secure prompt, as shown below.
</Warning>

## Cursor

Add Bouncy to `~/.cursor/mcp.json` (all projects) or `.cursor/mcp.json` (one project).

<CodeGroup>
  ```json Sign in theme={null}
  {
    "mcpServers": {
      "bouncy": {
        "url": "https://mcp.bouncy.ai/mcp"
      }
    }
  }
  ```

  ```json API key theme={null}
  {
    "mcpServers": {
      "bouncy": {
        "url": "https://mcp.bouncy.ai/mcp",
        "headers": {
          "Authorization": "Bearer ${env:BOUNCY_API_KEY}"
        }
      }
    }
  }
  ```
</CodeGroup>

With the sign-in version, open **Cursor Settings**, find **bouncy** in the MCP section and click **Connect** (or **Login**). Cursor opens the Bouncy approval page in your browser. The API key version reads the key from the `BOUNCY_API_KEY` environment variable.

## VS Code

VS Code uses MCP servers in Copilot Chat agent mode. Add Bouncy to `.vscode/mcp.json` in your workspace, or run **MCP: Open User Configuration** from the Command Palette to add it for every workspace.

<CodeGroup>
  ```json Sign in theme={null}
  {
    "servers": {
      "bouncy": {
        "type": "http",
        "url": "https://mcp.bouncy.ai/mcp"
      }
    }
  }
  ```

  ```json API key theme={null}
  {
    "inputs": [
      {
        "type": "promptString",
        "id": "bouncy-api-key",
        "description": "Bouncy API key",
        "password": true
      }
    ],
    "servers": {
      "bouncy": {
        "type": "http",
        "url": "https://mcp.bouncy.ai/mcp",
        "headers": {
          "Authorization": "Bearer ${input:bouncy-api-key}"
        }
      }
    }
  }
  ```
</CodeGroup>

Click **Start** above the server in `mcp.json`. With the sign-in version, VS Code asks you to allow Bouncy to sign in and opens the approval page. With the API key version, VS Code asks for the key once and stores it securely, so the key never appears in the file.

## Devin Desktop (Windsurf)

Devin Desktop (formerly Windsurf) reads MCP servers from `mcp_config.json`. Open it from the MCP settings in Cascade, or edit it directly:

* macOS and Linux: `~/.config/devin/mcp_config.json`
* Windows: `%APPDATA%\devin\mcp_config.json`
* Older Windsurf versions: `~/.codeium/windsurf/mcp_config.json`

Remote servers use `serverUrl` (not `url`):

<CodeGroup>
  ```json Sign in theme={null}
  {
    "mcpServers": {
      "bouncy": {
        "serverUrl": "https://mcp.bouncy.ai/mcp"
      }
    }
  }
  ```

  ```json API key theme={null}
  {
    "mcpServers": {
      "bouncy": {
        "serverUrl": "https://mcp.bouncy.ai/mcp",
        "headers": {
          "Authorization": "Bearer ${env:BOUNCY_API_KEY}"
        }
      }
    }
  }
  ```
</CodeGroup>

Refresh the MCP servers in Cascade after saving. With the sign-in version, follow the prompt to authenticate. If your version does not offer sign-in for remote servers, use the API key version.

## Gemini CLI

<CodeGroup>
  ```bash Sign in theme={null}
  gemini mcp add --transport http --scope user bouncy https://mcp.bouncy.ai/mcp
  ```

  ```bash API key theme={null}
  gemini mcp add --transport http --scope user \
    --header "Authorization: Bearer $BOUNCY_API_KEY" \
    bouncy https://mcp.bouncy.ai/mcp
  ```
</CodeGroup>

With the sign-in version, run `/mcp auth bouncy` inside Gemini CLI to open the Bouncy approval page. Use `/mcp` to check that Bouncy is connected and see its tools.

The command writes to `~/.gemini/settings.json`. If you edit that file by hand, use `httpUrl` for the Bouncy URL.

## MCP Inspector

[MCP Inspector](https://github.com/modelcontextprotocol/inspector) is the official tool for testing MCP servers. It is handy for checking a key or seeing exactly what each Bouncy tool returns.

```bash theme={null}
npx @modelcontextprotocol/inspector
```

In the Inspector window:

1. Set **Transport Type** to **Streamable HTTP**.
2. Set **URL** to `https://mcp.bouncy.ai/mcp`.
3. Either use the OAuth settings to sign in through the Bouncy approval page, or add an `Authorization` header with the value `Bearer bcy_live_pk_YOUR_API_KEY`.
4. Click **Connect**, then **List Tools**.

<Warning>
  Tools you run in the Inspector act on your real Bouncy account. Use a **Viewer** key or connection while exploring, so nothing can be created or deleted by accident.
</Warning>

## Other MCP clients

Any app that supports remote MCP servers over Streamable HTTP can connect:

* Apps that support MCP sign-in (OAuth) only need the URL. Bouncy supports both client registration methods that AI apps use (Client ID Metadata Documents and Dynamic Client Registration), so there is no client ID to set up.
* Apps that let you set request headers can use an API key: `Authorization: Bearer bcy_live_pk_YOUR_API_KEY`.

Next: see every tool in the [tools reference](/mcp/tools).