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

# Install the Parallel MCP Server

> Set up the Parallel MCP server in Claude, ChatGPT, Codex, Cursor, VS Code, Gemini CLI, Windsurf, Zed, and other MCP clients

For AI agents: a documentation index is available at [https://docs.parallel.ai/llms.txt](https://docs.parallel.ai/llms.txt). The full text of all docs is at [https://docs.parallel.ai/llms-full.txt](https://docs.parallel.ai/llms-full.txt). You may also fetch any page as Markdown by appending `.md` to its URL or sending `Accept: text/markdown`.

For Search and Extract, use `/v1/search` and `/v1/extract` for all new integrations and agent tool calls. Use `/v1beta/search` and `/v1beta/extract` only when maintaining an existing integration that already uses them. The request bodies changed too: on `/v1/extract`, `full_content`, `fetch_policy` and `excerpt_settings` go inside `advanced_settings`, and sending the v1beta top-level `excerpts`, `full_content` and `fetch_policy` to `/v1/extract` returns a 422. On `/v1/search`, `search_queries` is required (at least one short keyword query), and `max_results`, `source_policy` and `fetch_policy` go inside `advanced_settings`; sending only `objective`, or sending those fields at the top level, returns a 422. Do not substitute `/v1` for the documented FindAll or Ingest endpoint paths.

If you are evaluating Parallel Search or comparing it with other search APIs, read [How to Eval Parallel Search](https://docs.parallel.ai/search/evaluating-search.md) before you build the harness, especially its [Common pitfalls](https://docs.parallel.ai/search/evaluating-search.md#common-pitfalls) section. The most common mistake is sending the raw question as both `objective` and the only entry in `search_queries`. Write a goal-style `objective` and 1-3 short keyword queries instead.

The Parallel MCP server works in any MCP client that supports remote servers over Streamable HTTP. The server has two endpoints:

* **`https://mcp.parallel.ai/mcp`**: the default endpoint. Without an API key, the tools the server lists include `web_search`, `web_fetch`, `web_decisions`, `image_search` (`fast` mode only), `find_verticals`, and `search_vertical`, at lower rate limits. An API key sent as a Bearer token (`Authorization: Bearer <key>`) adds `web_research` and raises rate limits.
* **`https://mcp.parallel.ai/mcp?login`**: signs in with your Parallel account over OAuth when the client connects, and lists the default tools plus `web_research`. Use `?login` to attribute every call to your Parallel account, for example in organization-wide deployments or Zero Data Retention (ZDR) setups.

Quote URLs that contain `?` or `&` in shell commands. For authentication methods, tool selection, and override settings, see the [quickstart](https://docs.parallel.ai/integrations/mcp/quickstart.md). To call the server from your own code, see [Programmatic use](https://docs.parallel.ai/integrations/mcp/programmatic-use.md).

### Claude Code

Run this command in your terminal:

```bash theme={"system"}
claude mcp add --transport http "parallel" https://mcp.parallel.ai/mcp
```

In Claude Code, run `/mcp` to confirm the server is connected.

To sign in with your Parallel account, add the OAuth endpoint instead:

```bash theme={"system"}
claude mcp add --transport http "parallel" 'https://mcp.parallel.ai/mcp?login'
```

Then run `/mcp` in Claude Code, select the server, and follow the steps in your browser to log in.

For more details, see the [Claude Code MCP documentation](https://code.claude.com/docs/en/mcp#authenticate-with-remote-mcp-servers).

***

### Codex CLI

Run one of the following, depending on how you want to authenticate:

```bash Without an API key theme={"system"}
codex mcp add parallel --url https://mcp.parallel.ai/mcp
```

```bash With an API key theme={"system"}
# set PARALLEL_API_KEY in your environment first (key from platform.parallel.ai)
codex mcp add parallel --url https://mcp.parallel.ai/mcp \
  --bearer-token-env-var PARALLEL_API_KEY
```

```bash With OAuth theme={"system"}
codex mcp add parallel --url 'https://mcp.parallel.ai/mcp?login'
# complete the browser authorization when prompted
```

Each command writes the equivalent `[mcp_servers.parallel]` entry to `~/.codex/config.toml` — you can also hand-edit it if you prefer.

Restart Codex after adding the server. For more details, see the [Codex MCP documentation](https://developers.openai.com/codex/mcp/).

***

### Claude Desktop / Claude.ai

The easiest path is the [Parallel Search listing in Claude's connector directory](https://claude.com/marketplace/connectors/parallel-search). Open the listing and click Add to Claude, or search for "Parallel Search" under Settings → Connectors → Browse connectors. The steps below add the server as a custom connector instead.

* **Pro / Max plans:** go to Customize → Connectors → "+ Add" → "Add custom connector".
* **Team / Enterprise plans:** an Owner or Primary Owner must first go to Organization settings → Connectors → "Add" → "Custom" → "Web" to add the connector for the organization.

Enter the following connector details and complete the setup prompts:

```text theme={"system"}
Name: Parallel
URL: https://mcp.parallel.ai/mcp
```

To sign in with your Parallel account and use `web_research`, use `https://mcp.parallel.ai/mcp?login` instead.

**Team / Enterprise members:** after your owner adds the connector, go to Customize → Connectors, find it in the list, and click "Connect" to authenticate. Contact your organization owner if the connector is not available.

> [!TIP]
>
> **Org admins (Team / Enterprise plans):** to route Claude's web queries through the Parallel MCP instead of Claude's built-in web search, disable the native web search tool at [**Organization settings → Capabilities**](https://claude.ai/admin-settings/capabilities). Once off at the workspace level, members cannot re-enable it individually. See the [Claude web search docs](https://support.claude.com/en/articles/10684626-enabling-and-using-web-search).
>
> For the org-wide deployment, also point the connector at the [`/mcp?login` URL](https://docs.parallel.ai/integrations/mcp/quickstart#oauth-sign-in) (not `/mcp`) so every request requires a Parallel API key or OAuth — useful when you need every call attributed to the organization.

If you are not an admin, in Claude Desktop go to Settings → Developer → Edit Config and use the following JSON. If your config already has an `mcpServers` object, add the `Parallel` entry inside it without replacing your other servers.

```json theme={"system"}
{
  "mcpServers": {
    "Parallel": {
      "command": "npx",
      "args": [
        "-y",
        "mcp-remote",
        "https://mcp.parallel.ai/mcp"
      ]
    }
  }
}
```

No API key is required for `web_search` and `web_fetch`. To use `web_research` and raise your rate limits, grab a key from [Platform](https://platform.parallel.ai) and append `"--header", "authorization: Bearer YOUR-PARALLEL-API-KEY"` to the `args` array.

For more details, see the [Claude remote MCP documentation](https://support.claude.com/en/articles/11175166-getting-started-with-custom-connectors-using-remote-mcp).

***

### Cursor

Add to `~/.cursor/mcp.json` or `.cursor/mcp.json` (project-specific):

```json theme={"system"}
{
  "mcpServers": {
    "Parallel": {
      "url": "https://mcp.parallel.ai/mcp"
    }
  }
}
```

For more details, see the [Cursor MCP documentation](https://cursor.com/docs/context/mcp).

***

### VS Code

The quickest path is the guided flow — no file editing required. Run **MCP: Add Server** from the Command Palette (⇧⌘P / Ctrl+Shift+P), pick **HTTP**, and paste the server URL:

```text theme={"system"}
https://mcp.parallel.ai/mcp
```

VS Code then prompts for a server name (`Parallel`) and whether to add it as **Global** (available in every workspace) or **Workspace** (this project only), and writes the configuration for you. Confirm the trust prompt the first time the server starts.

To configure it by hand instead, add the following to `.vscode/mcp.json` in your workspace, or to the user-level `mcp.json` that the **MCP: Open User Configuration** command opens:

```json theme={"system"}
{
  "servers": {
    "Parallel": {
      "type": "http",
      "url": "https://mcp.parallel.ai/mcp"
    }
  }
}
```

> [!WARNING]
>
> The user-level `mcp.json` lives inside your VS Code profile folder, **not** at `~/.vscode/mcp.json`. Open it with **MCP: Open User Configuration** rather than typing the path — a file you create at `~/.vscode/mcp.json` is ignored, with no error to tell you why.

For more details, see the [VS Code MCP documentation](https://code.visualstudio.com/docs/agent-customization/mcp-servers).

***

### fx (Vercel)

[fx](https://github.com/vercel-labs/fx) connects to the Parallel MCP through `mcp-remote`. This setup requires Node.js and `npx`. Run this command inside fx:

```text theme={"system"}
/mcp add parallel -- npx -y mcp-remote https://mcp.parallel.ai/mcp
```

fx saves the server to `~/.fx/mcp.json` without removing your existing MCP servers and reloads the configuration. Run `/mcp list` to confirm `parallel` is listed and check its status.

To use `web_research` and raise your rate limits, get an API key from [platform.parallel.ai](https://platform.parallel.ai) and export `PARALLEL_API_KEY` before launching fx. Add `"--header"` and `"Authorization: Bearer ${PARALLEL_API_KEY}"` to the `parallel` entry's `args` array in `~/.fx/mcp.json`, then run `/mcp list`. fx loads a changed `mcp.json` on your next prompt or `/mcp` command.

For more details, see the [fx MCP documentation](https://fx.sh/docs/capabilities/mcp).

***

### Other Clients

> [accordion] Windsurf
>
> Add to `~/.codeium/windsurf/mcp_config.json`:
>
> ```json theme={"system"}
> {
>   "mcpServers": {
>     "Parallel": {
>       "serverUrl": "https://mcp.parallel.ai/mcp"
>     }
>   }
> }
> ```
>
> For more details, see the [Windsurf MCP documentation](https://docs.windsurf.com/windsurf/cascade/mcp).

> [accordion] Cline
>
> In the Cline panel, open MCP Servers → Configure → Configure MCP Servers, then add the following under `mcpServers`:
>
> ```json theme={"system"}
> {
>   "mcpServers": {
>     "Parallel": {
>       "type": "streamableHttp",
>       "url": "https://mcp.parallel.ai/mcp"
>     }
>   }
> }
> ```
>
> For more details, see the [Cline MCP documentation](https://docs.cline.bot/mcp/mcp-overview).

> [accordion] Gemini CLI
>
> Add to `~/.gemini/settings.json`:
>
> ```json theme={"system"}
> {
>   "mcpServers": {
>     "Parallel": {
>       "httpUrl": "https://mcp.parallel.ai/mcp"
>     }
>   }
> }
> ```
>
> For more details, see the [Gemini CLI MCP documentation](https://geminicli.com/docs/tools/mcp-server/).

> [accordion] ChatGPT
>
> The easiest path is the [Parallel Search app in the ChatGPT app directory](https://chatgpt.com/plugins/plugin_asdk_app_69fb9378663481919a68e8a2109644e5). Open the listing, or search for "Parallel Search" at [chatgpt.com/apps](https://chatgpt.com/apps), and click Install. The steps below add the server as a custom connector instead.
>
> **Warning:** [Developer Mode](https://help.openai.com/en/articles/12584461-developer-mode-apps-and-full-mcp-connectors-in-chatgpt-beta) must be enabled, and this feature may not be available to everyone. MCPs in ChatGPT are experimental and may not work reliably.
>
> First, go to Settings → Connectors → Advanced Settings, and turn on Developer Mode.
>
> Then, in connector settings, click Create and fill in one of the following. For use without an account, pair the default URL with **No authentication**:
>
> ```text theme={"system"}
> Name: Parallel
> URL: https://mcp.parallel.ai/mcp
> Authentication: No authentication
> ```
>
> To use every tool, including `web_research`, sign in with OAuth:
>
> ```text theme={"system"}
> Name: Parallel
> URL: https://mcp.parallel.ai/mcp?login
> Authentication: OAuth
> ```
>
> In a new chat, ensure Developer Mode is turned on with the connector(s) selected.
>
> For more details, see the [ChatGPT Developer Mode documentation](https://help.openai.com/en/articles/12584461-developer-mode-apps-and-full-mcp-connectors-in-chatgpt-beta).

> [accordion] Amp
>
> Run this command in your terminal:
>
> ```bash theme={"system"}
> amp mcp add "parallel" https://mcp.parallel.ai/mcp
> ```
>
> `web_search` and `web_fetch` work without signing in. To sign in with OAuth, add the OAuth endpoint instead:
>
> ```bash theme={"system"}
> amp mcp add "parallel" 'https://mcp.parallel.ai/mcp?login'
> ```
>
> Amp starts the OAuth flow in your browser the next time you start it.
>
> For more details, see the [Amp MCP documentation](https://ampcode.com/docs/customize/mcp).

> [accordion] Kiro
>
> Add to `.kiro/settings/mcp.json` (workspace) or `~/.kiro/settings/mcp.json` (global):
>
> ```json theme={"system"}
> {
>   "mcpServers": {
>     "Parallel": {
>       "url": "https://mcp.parallel.ai/mcp"
>     }
>   }
> }
> ```
>
> For more details, see the [Kiro MCP documentation](https://kiro.dev/docs/mcp/configuration/).

> [accordion] Google Antigravity
>
> In the Antigravity Agent pane, click the menu (⋮) → MCP Servers → Manage MCP Servers → View raw config, then add:
>
> ```json theme={"system"}
> {
>   "mcpServers": {
>     "parallel": {
>       "serverUrl": "https://mcp.parallel.ai/mcp"
>     }
>   }
> }
> ```
>
> To use `web_research` and raise your rate limits, add a `headers` block with `"Authorization": "Bearer YOUR_API_KEY"` and your key from [platform.parallel.ai](https://platform.parallel.ai).
>
> For more details, see the [Antigravity MCP documentation](https://antigravity.google/docs/mcp).

> [accordion] OpenCode
>
> Add to `opencode.json` (project) or `~/.config/opencode/opencode.json` (global):
>
> ```json theme={"system"}
> {
>   "mcp": {
>     "parallel": {
>       "type": "remote",
>       "url": "https://mcp.parallel.ai/mcp",
>       "enabled": true
>     }
>   }
> }
> ```
>
> For more details, see the [OpenCode MCP documentation](https://opencode.ai/docs/mcp-servers/).

> [accordion] Roo Code
>
> Add to `.roo/mcp.json` in your workspace (or edit the global `mcp_settings.json` from the Roo Code MCP settings view):
>
> ```json theme={"system"}
> {
>   "mcpServers": {
>     "Parallel": {
>       "type": "streamable-http",
>       "url": "https://mcp.parallel.ai/mcp"
>     }
>   }
> }
> ```
>
> Project config takes precedence over global. For more details, see the [Roo Code MCP documentation](https://docs.roocode.com/features/mcp/using-mcp-in-roo).

> [accordion] OpenHands
>
> Run this command in your terminal:
>
> ```bash theme={"system"}
> openhands mcp add parallel --transport http https://mcp.parallel.ai/mcp
> ```
>
> Or add manually to `~/.openhands/mcp.json`:
>
> ```json theme={"system"}
> {
>   "mcpServers": {
>     "Parallel": {
>       "url": "https://mcp.parallel.ai/mcp"
>     }
>   }
> }
> ```
>
> Inside an OpenHands conversation, use `/mcp` to verify the server is active. For more details, see the [OpenHands MCP documentation](https://docs.openhands.dev/openhands/usage/cli/mcp-servers).

> [accordion] Factory CLI (droid)
>
> Run this command in your terminal:
>
> ```bash theme={"system"}
> droid mcp add parallel https://mcp.parallel.ai/mcp --type http
> ```
>
> Inside droid, type `/mcp` to open the interactive manager and verify the server is connected. For more details, see the [Factory MCP documentation](https://docs.factory.ai/cli/configuration/mcp).

> [accordion] Pi
>
> Pi has built-in MCP support. Add the server in your terminal:
>
> ```bash theme={"system"}
> pi mcp add parallel --url https://mcp.parallel.ai/mcp
> ```
>
> If Pi is already open, run `/reload` in that session after adding the server. Then run `/mcp` inside Pi to verify the connection. See the [Pi MCP documentation](https://github.com/earendil-works/pi/blob/main/packages/coding-agent/docs/mcp.md).
>
> Alternatively, install the [`pi-mcp-adapter`](https://github.com/nicobailon/pi-mcp-adapter) package:
>
> ```bash theme={"system"}
> pi install npm:pi-mcp-adapter
> ```
>
> Restart Pi, then add the Parallel MCP to `.mcp.json` in your project (or `~/.config/mcp/mcp.json` for a user-global config):
>
> ```json theme={"system"}
> {
>   "mcpServers": {
>     "parallel": {
>       "url": "https://mcp.parallel.ai/mcp",
>       "directTools": true
>     }
>   }
> }
> ```
>
> `directTools: true` registers the Parallel tools alongside Pi's built-in tools instead of hiding them behind the adapter's `mcp` proxy. Run `/mcp` inside Pi to verify the server is detected. For more details, see the [pi-mcp-adapter README](https://github.com/nicobailon/pi-mcp-adapter).
>
> Alternatively, skip MCP entirely and use the [Parallel CLI](https://docs.parallel.ai/integrations/cli.md) as a Pi skill — that's the same pattern as our [ClawHub / OpenClaw](https://docs.parallel.ai/integrations/clawhub.md) integration.

> [accordion] OpenClaw
>
> OpenClaw stores MCP server definitions in `~/.openclaw/openclaw.json` under `mcp.servers`. Save the Parallel MCP via the `openclaw mcp set` CLI:
>
> ```bash theme={"system"}
> openclaw mcp set parallel '{"url":"https://mcp.parallel.ai/mcp","transport":"streamable-http"}'
> ```
>
> Or edit `~/.openclaw/openclaw.json` directly:
>
> ```json theme={"system"}
> {
>   "mcp": {
>     "servers": {
>       "parallel": {
>         "url": "https://mcp.parallel.ai/mcp",
>         "transport": "streamable-http"
>       }
>     }
>   }
> }
> ```
>
> The `transport` field is required — OpenClaw defaults to SSE when it's omitted, but the Parallel MCP uses Streamable HTTP. No API key is required for `web_search` and `web_fetch`; to use `web_research` and raise your rate limits, add an optional `headers` map with `"Authorization": "Bearer YOUR-PARALLEL-API-KEY"` (key from [platform.parallel.ai](https://platform.parallel.ai)).
>
> `openclaw mcp set` only writes to config — it doesn't connect to the server or reload running agents. Start a new OpenClaw agent session (or restart your current one) for the tools to show up. Verify the saved definition with `openclaw mcp list` / `openclaw mcp show parallel`. For the full MCP CLI reference, see the [OpenClaw MCP docs](https://docs.openclaw.ai/cli/mcp).
>
> You can also skip MCP entirely and use the [Parallel CLI](https://docs.parallel.ai/integrations/cli.md) as an OpenClaw skill — see the [ClawHub integration](https://docs.parallel.ai/integrations/clawhub.md).

> [accordion] Hermes Agent
>
> Add to `~/.hermes/config.yaml`:
>
> ```yaml theme={"system"}
> mcp_servers:
>   parallel:
>     url: "https://mcp.parallel.ai/mcp"
> ```
>
> For more details, see the [Hermes Agent MCP documentation](https://hermes-agent.nousresearch.com/docs/user-guide/features/mcp).

> [accordion] Continue.dev
>
> Add a file at `.continue/mcpServers/parallel.yaml` in your workspace:
>
> ```yaml theme={"system"}
> name: Parallel
> version: 0.0.1
> schema: v1
> mcpServers:
>   - name: Parallel
>     type: streamable-http
>     url: https://mcp.parallel.ai/mcp
> ```
>
> For more details, see the [Continue.dev MCP documentation](https://docs.continue.dev/customize/deep-dives/mcp).

> [accordion] Zed
>
> Open Settings → AI → MCP Servers, click Add Server, and choose Add Remote Server. Or add the entry to your Zed `settings.json` (open it with the `zed: open settings file` action). Zed uses a top-level `context_servers` object:
>
> ```json theme={"system"}
> {
>   "context_servers": {
>     "Parallel": {
>       "url": "https://mcp.parallel.ai/mcp"
>     }
>   }
> }
> ```
>
> To use `web_research` and raise your rate limits, add a `headers` object with `"Authorization": "Bearer YOUR-PARALLEL-API-KEY"` and a key from [platform.parallel.ai](https://platform.parallel.ai). To sign in with OAuth instead, set `url` to `https://mcp.parallel.ai/mcp?login` and leave out the `Authorization` header. Zed then prompts you to authenticate in your browser.
>
> For more details, see the [Zed MCP documentation](https://zed.dev/docs/ai/mcp).

> [accordion] Warp
>
> Open Settings → Agents → MCP servers, click + Add, and paste:
>
> ```json theme={"system"}
> {
>   "mcpServers": {
>     "Parallel": {
>       "url": "https://mcp.parallel.ai/mcp"
>     }
>   }
> }
> ```
>
> You can also save the same entry to `~/.warp/.mcp.json` (global) or `.warp/.mcp.json` at the project root. To use `web_research` and raise your rate limits, add a `headers` object with `"Authorization": "Bearer YOUR-PARALLEL-API-KEY"` and a key from [platform.parallel.ai](https://platform.parallel.ai). To sign in with OAuth instead, set `url` to `https://mcp.parallel.ai/mcp?login`. Warp opens a browser sign-in flow when the server starts.
>
> For more details, see the [Warp MCP documentation](https://docs.warp.dev/agents/capabilities/mcp/).

> [accordion] Raycast
>
> Run the **Install MCP Server** command and fill in:
>
> ```text theme={"system"}
> Name: Parallel
> Transport: HTTP
> URL: https://mcp.parallel.ai/mcp
> ```
>
> To use `web_research` and raise your rate limits, add an HTTP header `Authorization: Bearer YOUR-PARALLEL-API-KEY` with a key from [platform.parallel.ai](https://platform.parallel.ai). To sign in with OAuth instead, set the URL to `https://mcp.parallel.ai/mcp?login` and keep the OAuth type on Dynamic. Raycast then prompts you to Sign In before the tools become available.
>
> For more details, see the [Raycast MCP documentation](https://manual.raycast.com/ai/model-context-protocol).

> [accordion] LM Studio
>
> [Add to LM Studio](lmstudio://add_mcp?name=Parallel\&config=eyJ1cmwiOiJodHRwczovL21jcC5wYXJhbGxlbC5haS9tY3AifQ%3D%3D) installs the server in one click.

> [accordion] Goose
>
> [Add to Goose](goose://extension?url=https%3A%2F%2Fmcp.parallel.ai%2Fmcp\&type=streamable_http\&timeout=300\&id=parallel\&name=Parallel\&description=Parallel%20MCP%20server) installs the server in one click.

If your client isn't listed, most MCP clients accept the `mcpServers` format shown in the Cursor section. For clients that use a different wrapper (e.g., VS Code's top-level `servers`, Windsurf's `serverUrl`), check the client's documentation for the correct field names.

## Troubleshooting

### Common Installation Issues

> [accordion] Cline: 'Authorization Error redirect\_uri must be https'
>
> This error occurs when Cline attempts OAuth authentication but the redirect URI isn't using HTTPS. `web_search` and `web_fetch` at `/mcp` don't require OAuth — wrap it in `mcp-remote` so Cline treats it as a plain stdio server:
>
> ```json theme={"system"}
> {
>   "mcpServers": {
>     "Parallel": {
>       "command": "npx",
>       "args": [
>         "-y",
>         "mcp-remote",
>         "https://mcp.parallel.ai/mcp"
>       ]
>     }
>   }
> }
> ```
>
> If you want `web_research` or higher rate limits, append `"--header", "authorization: Bearer YOUR-PARALLEL-API-KEY"` to the `args` array with a key from [platform.parallel.ai](https://platform.parallel.ai).

> [accordion] Gemini CLI: Where to provide API key
>
> Gemini CLI uses HTTP MCPs and can authenticate via OAuth. `web_search` and `web_fetch` at `/mcp` don't require an API key or OAuth, so the simplest setup has no auth at all:
>
> ```json theme={"system"}
> {
>   "mcpServers": {
>     "Parallel": {
>       "httpUrl": "https://mcp.parallel.ai/mcp"
>     }
>   }
> }
> ```
>
> Add this to `~/.gemini/settings.json`. If you want `web_research` or higher rate limits, add a `headers` object and pass a key from [platform.parallel.ai](https://platform.parallel.ai) as a Bearer header:
>
> ```json theme={"system"}
> {
>   "mcpServers": {
>     "Parallel": {
>       "httpUrl": "https://mcp.parallel.ai/mcp",
>       "headers": {
>         "Authorization": "Bearer YOUR-PARALLEL-API-KEY"
>       }
>     }
>   }
> }
> ```

> [accordion] VS Code: Server not detected (wrong file location)
>
> VS Code reads two `mcp.json` locations: `.vscode/mcp.json` inside the workspace, and a user-level `mcp.json` in your VS Code profile folder, which the **MCP: Open User Configuration** command opens. `~/.vscode/mcp.json` is **not** one of them — that directory holds `argv.json` and your installed extensions, so a server defined there never loads and VS Code reports no error.
>
> If a hand-written config isn't picked up, run **MCP: Open User Configuration** and check whether the file that opens is the one you edited. Run **MCP: List Servers** to confirm VS Code sees the server, and use **MCP: Add Server** to let VS Code write the entry to the correct file.

> [accordion] VS Code: Incorrect configuration format
>
> VS Code's `mcp.json` uses a different structure than Cursor's `mcp.json`. Common mistake: copying a Cursor-style config into VS Code.
>
> **Incorrect (Cursor format):**
>
> ```json theme={"system"}
> {
>   "mcpServers": {
>     "parallel": {
>       "url": "https://mcp.parallel.ai/mcp"
>     }
>   }
> }
> ```
>
> **Correct (VS Code format, `.vscode/mcp.json` or user-level `mcp.json`):**
>
> ```json theme={"system"}
> {
>   "servers": {
>     "Parallel": {
>       "type": "http",
>       "url": "https://mcp.parallel.ai/mcp"
>     }
>   }
> }
> ```
>
> Note: VS Code uses a top-level `servers` object (not `mcpServers`) and includes `type: "http"` for remote HTTP servers.

> [accordion] Windsurf: Configuration location and format
>
> Windsurf uses a different configuration format than Cursor.
>
> **Correct Windsurf configuration:**
>
> ```json theme={"system"}
> {
>   "mcpServers": {
>     "Parallel": {
>       "serverUrl": "https://mcp.parallel.ai/mcp"
>     }
>   }
> }
> ```
>
> Note: Windsurf uses `serverUrl` instead of `url`. Add this to your Windsurf MCP configuration file.

> [accordion] Connection timeout or 'server unavailable' errors
>
> If you're getting connection errors:
>
> 1. **Check your network:** Ensure you can reach `https://mcp.parallel.ai`
> 2. **Verify API key:** Make sure your key is valid at [platform.parallel.ai](https://platform.parallel.ai)
> 3. **Check balance:** A 402 error means insufficient credits—add funds to your account
> 4. **Restart your IDE:** Some clients cache MCP connections

> [accordion] Tools not appearing in the IDE
>
> If the MCP installs but tools don't show up:
>
> 1. **Restart your IDE** completely (not just reload)
> 2. **Check configuration syntax:** Ensure valid JSON with no trailing commas
> 3. **Verify the server URL:** The base must be `https://mcp.parallel.ai/mcp` (no trailing slash), with [documented query parameters](https://docs.parallel.ai/integrations/mcp/quickstart.md#configuration) such as `?login` allowed
> 4. **Check IDE logs:** Look for MCP-related errors in your IDE's output/debug panel
