Skip to main content

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.

For AI agents: a documentation index is available at https://docs.parallel.ai/llms.txt. The full text of all docs is at 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.
The Task MCP Server provides two core capabilities: deep research tasks that generate comprehensive reports, and enrichment tasks that transform existing datasets with web intelligence. Built on the same infrastructure that powers our Task API, it delivers the highest quality at every price point while eliminating complex integration work. The Task MCP comprises four tools:
  • createDeepResearch — Initiates a deep research task. Use for complex questions that need thorough multi-step research with citations, where depth matters more than latency.
  • createTaskGroup — Initiates a task group to enrich multiple items in parallel. Use for lists or tabular data (CSV uploads, company lists, entity tables) that need consistent web-sourced fields per row.
  • getStatus — Lightweight status check for an in-flight task (~50 tokens). Use this when polling instead of fetching the full result.
  • getResultMarkdown — Retrieves the final output from a deep research or task group in an LLM-friendly markdown format. Call once the task is complete.
The Task MCP Server uses an async architecture that lets agents start research tasks and continue executing other work without blocking. This allows spawning any number of tasks in parallel while continuing the conversation. Due to current MCP and LLM client limitations, you need to request the result tool call in an additional turn after results are ready. The Task MCP works best when following this process:
  1. Choose a data source - See Enrichment data sources and destinations.
  2. Initiate your tasks - After you have your initial data, the MCP can initiate deep research or task groups. See Use cases for inspiration.
  3. Analyze the results - The LLM provides a link to view progress as results come in. After completion, prompt the LLM to analyze the results and answer your questions.

​
One-Click Install

Install in any of the following clients with a single click.

Install in Cursor

One-click install for Cursor.

Install in VS Code

One-click install for VS Code.

Install in LM Studio

One-click install for LM Studio.

Install in Goose

One-click install for Goose.
The Task MCP requires an API key. After one-click install, add your key from platform.parallel.ai as a Bearer token in the Authorization header (configured in the client’s MCP settings after install). For Claude Code, Codex CLI, Claude Desktop, Windsurf, Zed, Gemini CLI, Warp, Kiro, and other clients, see the Installation section below — those clients use a CLI command or a JSON config file rather than deep-link URLs.

​
Enrichment data sources and destinations

The task group tool can be used directly from LLM memory, but is often combined with a data source. The following data sources work well with the Task Group tool:
  • Upload tabular files - Use the Task MCP with Excel sheets or CSVs. Some LLM clients (such as ChatGPT) allow uploading Excel or CSV files. Availability varies by client.
  • Connect with databases - Several MCPs allow your LLM to retrieve data from your database, such as Supabase MCP and Neon MCP.
  • Connect with documents - Documents may contain vital initial information to start a task group. See Notion MCP and Linear MCP.
  • Connect with web search data - Parallel Search MCP or other web tools can provide an initial list of items, which is often a great starting point for a task group.

​
Use cases

The Task MCP serves two main purposes. First, it makes Parallel APIs accessible to anyone requiring reliable research or enrichment without coding skills. Second, it’s a great tool for developers to experiment with different use cases and see output quality before writing code. Below are examples of using the Task MCP (sometimes in combination with other MCPs): Day-to-day data enrichment and research: Assisting development with Parallel APIs: This is just the tip of the iceberg. Share your most compelling use cases with us to grow this list and inspire others!

​
Installation

The Task MCP can be installed in any MCP client. The server URL is: https://task-mcp.parallel.ai/mcp The Task MCP can also be used programmatically by providing your Parallel API key in the Authorization header as a Bearer token.

​
Cursor

Add to ~/.cursor/mcp.json or .cursor/mcp.json (project-specific): 
{
  "mcpServers": {
    "Parallel Task MCP": {
      "url": "https://task-mcp.parallel.ai/mcp"
    }
  }
}
For more details, see the Cursor MCP documentation.

​
VS Code

Create .vscode/mcp.json in your workspace (or run the MCP: Open User Configuration command for a user-level mcp.json): 
{
  "servers": {
    "Parallel Task MCP": {
      "type": "http",
      "url": "https://task-mcp.parallel.ai/mcp"
    }
  }
}
For more details, see the VS Code MCP documentation.

​
Claude Desktop / Claude.ai

Go to Settings → Connectors → Add Custom Connector, and fill in: 
Name: Parallel Task MCP
URL: https://task-mcp.parallel.ai/mcp
If you are part of an organization, you may not have access to custom connectors. Contact your organization administrator for assistance. If you are not an admin, go to Settings → Developer → Edit Config and add the following JSON after retrieving your API key from Platform: 
"Parallel Task MCP": {
  "command": "npx",
  "args": [
    "-y",
    "mcp-remote",
    "https://task-mcp.parallel.ai/mcp",
    "--header", "authorization: Bearer YOUR-PARALLEL-API-KEY"
  ]
}
For more details, see the Claude remote MCP documentation.

​
Claude Code

Run this command in your terminal: 
claude mcp add --transport http "Parallel-Task-MCP" https://task-mcp.parallel.ai/mcp
In Claude code, use the command: 
/mcp
Then follow the steps in your browser to login. For more details, see the Claude Code MCP documentation.

​
Codex CLI

The Task MCP always requires authentication. Choose one of:
API key via environment variable
# set PARALLEL_API_KEY in your environment first (key from platform.parallel.ai)
codex mcp add parallel-task --url https://task-mcp.parallel.ai/mcp \
  --bearer-token-env-var PARALLEL_API_KEY
OAuth
codex mcp add parallel-task --url https://task-mcp.parallel.ai/mcp
# complete the browser authorization when prompted
Each command writes the equivalent [mcp_servers.parallel-task] 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.

​
Other Clients

Add to ~/.codeium/windsurf/mcp_config.json:
{
  "mcpServers": {
    "Parallel Task MCP": {
      "serverUrl": "https://task-mcp.parallel.ai/mcp"
    }
  }
}
For more details, see the Windsurf MCP documentation.
Go to MCP Servers → Remote Servers → Edit Configuration:
{
  "mcpServers": {
    "Parallel Task MCP": {
      "url": "https://task-mcp.parallel.ai/mcp",
      "headers": {
        "Authorization": "Bearer YOUR-PARALLEL-API-KEY"
      }
    }
  }
}
For more details, see the Cline MCP documentation.
Add to ~/.gemini/settings.json:
{
  "mcpServers": {
    "Parallel Task MCP": {
      "httpUrl": "https://task-mcp.parallel.ai/mcp"
    }
  }
}
For more details, see the Gemini CLI MCP documentation.
Warning: Developer Mode 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:
Name: Parallel Task MCP
URL: https://task-mcp.parallel.ai/mcp
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.
Run this command in your terminal:
amp mcp add "Parallel-Task-MCP" https://task-mcp.parallel.ai/mcp
The OAuth flow will start when you start Amp.For more details, see the Amp MCP documentation.
Add to .kiro/settings/mcp.json (workspace) or ~/.kiro/settings/mcp.json (global):
{
  "mcpServers": {
    "Parallel Task MCP": {
      "url": "https://task-mcp.parallel.ai/mcp"
    }
  }
}
For more details, see the Kiro MCP documentation.
In the Antigravity Agent pane, click the menu (⋮) → MCP Servers → Manage MCP Servers → View raw config, then add:
{
  "mcpServers": {
    "Parallel-Task-MCP": {
      "serverUrl": "https://task-mcp.parallel.ai/mcp",
      "headers": {
        "Authorization": "Bearer YOUR_API_KEY"
      }
    }
  }
}
For more details, see the Antigravity MCP documentation.
Add to opencode.json (project) or ~/.config/opencode/opencode.json (global):
{
  "mcp": {
    "parallel-task": {
      "type": "remote",
      "url": "https://task-mcp.parallel.ai/mcp",
      "enabled": true,
      "headers": {
        "Authorization": "Bearer YOUR-PARALLEL-API-KEY"
      }
    }
  }
}
For more details, see the OpenCode MCP documentation.
Add to .roo/mcp.json in your workspace (or edit the global mcp_settings.json from the Roo Code MCP settings view):
{
  "mcpServers": {
    "Parallel Task MCP": {
      "type": "streamable-http",
      "url": "https://task-mcp.parallel.ai/mcp",
      "headers": {
        "Authorization": "Bearer YOUR-PARALLEL-API-KEY"
      }
    }
  }
}
Project config takes precedence over global. For more details, see the Roo Code MCP documentation.
Run this command in your terminal:
openhands mcp add parallel-task --transport http \
  --header "Authorization: Bearer YOUR-PARALLEL-API-KEY" \
  https://task-mcp.parallel.ai/mcp
Inside an OpenHands conversation, use /mcp to verify the server is active. For more details, see the OpenHands MCP documentation.
Run this command in your terminal:
droid mcp add parallel-task https://task-mcp.parallel.ai/mcp --type http \
  --header "Authorization: Bearer YOUR-PARALLEL-API-KEY"
Inside droid, type /mcp to open the interactive manager and verify the server is connected. For more details, see the Factory MCP documentation.
Pi ships without built-in MCP support, so install the pi-mcp-adapter package first:
pi install npm:pi-mcp-adapter
Restart Pi, then add the Task MCP to .mcp.json in your project (or ~/.config/mcp/mcp.json for a user-global config). The Task MCP requires a Parallel API key:
{
  "mcpServers": {
    "parallel-task": {
      "url": "https://task-mcp.parallel.ai/mcp",
      "auth": "bearer",
      "bearerTokenEnv": "PARALLEL_API_KEY",
      "directTools": true
    }
  }
}
Set PARALLEL_API_KEY in your environment with your key from platform.parallel.ai. directTools: true registers createDeepResearch, createTaskGroup, getStatus, and getResultMarkdown 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.Alternatively, skip MCP entirely and use the Parallel CLI as a Pi skill — that’s the same pattern as our ClawHub / OpenClaw integration.
OpenClaw stores MCP server definitions in ~/.openclaw/openclaw.json under mcp.servers. The Task MCP requires a Parallel API key — OpenClaw’s remote MCP schema accepts it via the headers map, so avoid committing a literal key and pass it through an env-var or secret reference.Save via the openclaw mcp set CLI:
openclaw mcp set parallel-task '{"url":"https://task-mcp.parallel.ai/mcp","transport":"streamable-http","headers":{"Authorization":"Bearer YOUR-PARALLEL-API-KEY"}}'
Or edit ~/.openclaw/openclaw.json directly:
{
  "mcp": {
    "servers": {
      "parallel-task": {
        "url": "https://task-mcp.parallel.ai/mcp",
        "transport": "streamable-http",
        "headers": {
          "Authorization": "Bearer YOUR-PARALLEL-API-KEY"
        }
      }
    }
  }
}
The transport field is required — OpenClaw defaults to SSE when it’s omitted, but the Task MCP uses Streamable HTTP. Replace YOUR-PARALLEL-API-KEY with a key from platform.parallel.ai. Sensitive values in url and headers are redacted in OpenClaw logs.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-task. For the full MCP CLI reference, see the OpenClaw MCP docs.
Add to ~/.hermes/config.yaml:
mcp_servers:
  parallel_task:
    url: "https://task-mcp.parallel.ai/mcp"
    headers:
      Authorization: "Bearer YOUR-PARALLEL-API-KEY"
For more details, see the Hermes Agent MCP documentation.
Add a file at .continue/mcpServers/parallel-task.yaml in your workspace:
name: Parallel Task MCP
version: 0.0.1
schema: v1
mcpServers:
  - name: Parallel Task MCP
    type: streamable-http
    url: https://task-mcp.parallel.ai/mcp
    requestOptions:
      headers:
        Authorization: Bearer YOUR-PARALLEL-API-KEY
For more details, see the Continue.dev MCP documentation.
These clients currently support only stdio-transport MCP servers — they can’t connect directly to remote HTTP endpoints. Wrap the Task MCP with mcp-remote, passing your API key as a Bearer header:
{
  "mcpServers": {
    "Parallel Task MCP": {
      "command": "npx",
      "args": [
        "-y",
        "mcp-remote",
        "https://task-mcp.parallel.ai/mcp",
        "--header",
        "Authorization: Bearer YOUR-PARALLEL-API-KEY"
      ]
    }
  }
}
Placement differs per client — see the Zed MCP docs, Warp MCP docs, or Raycast MCP docs for the exact file location and wrapper format.
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 mcp.servers, Windsurf’s serverUrl), check the client’s documentation for the correct field names.

​
Best Practices

​
Choose enabled MCPs carefully

Be careful which tools and features you have enabled in your MCP client. When using Parallel in combination with many other tools, the increased context window may cause degraded output quality. Additionally, the LLM may prefer standard web search or deep research over Parallel if both are enabled. Turn off other web or deep-research tools, or explicitly mention that you want to use Parallel MCPs.

​
Limit data source context size

The Task MCP is a powerful tool for batch deep research, but it is constrained by the context window size and max output tokens of the LLM. Design your prompts and tool calls to avoid overflowing these limitations, or you may experience failures, degraded performance, or lower output quality. For large datasets, use the API or other no-code integrations. The Task MCP is designed for smaller parallel tasks and experimentation.

​
Follow up on tasks

The Task MCP only initiates Deep Research and Task Groups—it does not wait for tasks to complete. Fetch the status or results using a follow-up tool call after research is complete. The asynchronous nature allows initiating several deep researches and task groups without overflowing the context window. To perform multiple tasks or batches in a workflow, reply each time to verify the task is complete and initiate the next step.

​
Use with larger models only

While our Web Search MCP works well with smaller models (such as GPT OSS 20B), the Task MCP requires strong reasoning capability. Use it with larger models only (such as GPT-5 or Claude Sonnet 4.5). Smaller models may result in degraded output quality.

​
Troubleshooting

​
Common Installation Issues

This error occurs when Cline attempts OAuth authentication but the redirect URI isn’t using HTTPS.Solution: Use the API key approach instead of OAuth:
  1. Get your API key from platform.parallel.ai
  2. Configure Cline with the bearer token method:
{
  "mcpServers": {
    "Parallel Task MCP": {
      "command": "npx",
      "args": [
        "-y",
        "mcp-remote",
        "https://task-mcp.parallel.ai/mcp",
        "--header",
        "authorization: Bearer YOUR-PARALLEL-API-KEY"
      ]
    }
  }
}
Replace YOUR-PARALLEL-API-KEY with your actual API key.
Gemini CLI uses HTTP MCPs and authenticates via OAuth. If OAuth isn’t working, you can provide your API key directly.Solution: Use environment variables or the mcp-remote proxy:
{
  "mcpServers": {
    "Parallel Task MCP": {
      "command": "npx",
      "args": [
        "-y",
        "mcp-remote",
        "https://task-mcp.parallel.ai/mcp",
        "--header",
        "authorization: Bearer YOUR-PARALLEL-API-KEY"
      ]
    }
  }
}
Add this to ~/.gemini/settings.json and replace YOUR-PARALLEL-API-KEY with your key from platform.parallel.ai.
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):
{
  "mcpServers": {
    "parallel-task": {
      "url": "https://task-mcp.parallel.ai/mcp"
    }
  }
}
Correct (VS Code format, .vscode/mcp.json or user-level mcp.json):
{
  "servers": {
    "Parallel Task MCP": {
      "type": "http",
      "url": "https://task-mcp.parallel.ai/mcp"
    }
  }
}
Note: VS Code uses a top-level servers object (not mcpServers) and includes type: "http" for remote HTTP servers.
Windsurf uses a different configuration format than Cursor.Correct Windsurf configuration:
{
  "mcpServers": {
    "Parallel Task MCP": {
      "serverUrl": "https://task-mcp.parallel.ai/mcp"
    }
  }
}
Note: Windsurf uses serverUrl instead of url. Add this to your Windsurf MCP configuration file.
If you’re getting connection errors:
  1. Check your network: Ensure you can reach https://task-mcp.parallel.ai
  2. Verify API key: Make sure your key is valid at 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
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: Must be exactly https://task-mcp.parallel.ai/mcp
  4. Check IDE logs: Look for MCP-related errors in your IDE’s output/debug panel