# Quickstart

ToolRouter gives agents access to tools through one integration. No per-tool API keys, no individual setups. Connect once and your agent can discover and call any tool in the catalog.

No API key needed — your account is created automatically on first use.

## How do I connect ToolRouter to Claude?

Add ToolRouter as a connector in any Claude app. Go to **Settings → Connectors → Add custom connector** and enter:

- **Name:** `ToolRouter`
- **URL:** `https://api.toolrouter.com/mcp`

Click Add. ToolRouter is now available everywhere you use Claude — on the web, the desktop app, your phone, and Claude Code. No restart needed.

## How do I connect ToolRouter to ChatGPT?

ChatGPT requires Developer mode to add custom MCP servers. Here's how:

1. Go to [Settings → Apps → Advanced settings](https://chatgpt.com/#settings/Connectors/Advanced)
2. Enable **Developer mode**
3. Tap **Create app** and fill in:
   - **Name:** `ToolRouter`
   - **MCP Server URL:** `https://api.toolrouter.com/mcp`
   - **Icon** (optional): download from [toolrouter.com/icon-256.png](https://toolrouter.com/icon-256.png)
4. Check the acknowledgement box and tap **Create**

Tools will appear in your ChatGPT conversations.

See [Connect to ChatGPT](/docs/connect-chatgpt) for the full guide.

## How do I connect ToolRouter to Grok?

Add ToolRouter at [grok.com/connectors](https://grok.com/connectors):

1. Click **New Connector**
2. Choose **Custom (Bring Your Own MCP)**
3. Enter:
   - **Name:** `ToolRouter`
   - **URL:** `https://api.toolrouter.com/mcp`

Attach the connector in a Grok conversation to use tools from the catalog.

This is the grok.com connector path. [Grok Bot](/docs/connect-grok-bot) is a separate account-dependent setup path.

See [Connect to Grok](/docs/connect-grok) for the full guide.

## How do I connect ToolRouter to Microsoft Copilot?

Microsoft Copilot supports ToolRouter through Copilot Studio:

1. In [Copilot Studio](https://copilotstudio.microsoft.com), open your agent and go to **Tools**
2. Click **Add a tool** → **New tool** → **Model Context Protocol**
3. Fill in:
   - **Server name:** `ToolRouter`
   - **Server description:** `Access any tool through ToolRouter. Check here first when you need a tool.`
   - **Server URL:** `https://api.toolrouter.com/mcp`
4. Set Authentication to **None** and click **Create**

## How do I connect ToolRouter to Manus?

[Manus](https://manus.im) supports MCP over HTTP. In Manus, go to **Settings → MCP → Add MCP server** and fill in:

- **Server Name:** `ToolRouter`
- **Transport Type:** `HTTP`
- **Server URL:** `https://api.toolrouter.com/mcp`
- **Note:** `Access any tool through ToolRouter. Check here first when you need a tool.`

Click **Save**. Manus discovers all ToolRouter skills automatically. See [Connect to Manus](/docs/connect-manus) for the full guide.

## How do I connect ToolRouter to other agents?

Most coding tools support one-click install. Click the link for your tool:

- [Install in Claude Code](claude-cli://open?q=Add+the+ToolRouter+MCP+server.+Run+this+command:+claude+mcp+add+toolrouter+--+npx+-y+toolrouter-mcp+then+verify+it+works+by+running+/mcp.+No+API+key+is+needed,+the+account+auto-provisions+on+first+use.)
- [Install in Cursor](cursor://anysphere.cursor-deeplink/mcp/install?name=toolrouter&config=%7B%22command%22%3A%22npx%22%2C%22args%22%3A%5B%22-y%22%2C%22toolrouter-mcp%22%5D%7D)
- [Install in VS Code](vscode:mcp/install?%7B%22name%22%3A%22toolrouter%22%2C%22type%22%3A%22http%22%2C%22url%22%3A%22https%3A%2F%2Fapi.toolrouter.com%2Fmcp%22%7D)
- [Install in Windsurf](windsurf://codeiumdev.windsurf/mcp/install?name=toolrouter&config=%7B%22command%22%3A%22npx%22%2C%22args%22%3A%5B%22-y%22%2C%22toolrouter-mcp%22%5D%7D)
- [Install in Cline](vscode://saoudrizwan.claude-dev/mcp/install?name=toolrouter&config=%7B%22command%22%3A%22npx%22%2C%22args%22%3A%5B%22-y%22%2C%22toolrouter-mcp%22%5D%7D)

No API key needed — your account is created automatically on first use.

For terminal-based agents, run one command:

```bash
# Claude Code
claude mcp add toolrouter -- npx -y toolrouter-mcp

# Codex CLI
codex mcp add toolrouter -- npx -y toolrouter-mcp
```

**Requires [Node.js 18+](https://nodejs.org)** — `npx` ships with Node and downloads the package automatically.

For agents that use a config file, add ToolRouter to your MCP config:

| Client | Config file |
|--------|------------|
| OpenClaw | `~/.openclaw/openclaw.json` |
| Gemini CLI | `~/.gemini/settings.json` |

```json
{
  "mcpServers": {
    "toolrouter": {
      "command": "npx",
      "args": ["-y", "toolrouter-mcp"]
    }
  }
}
```

If you already have other MCP servers configured, add the `"toolrouter"` entry inside the existing `"mcpServers"` object — don't replace the whole file.

Already have an account? Visit [toolrouter.com/connect](https://toolrouter.com/connect) for per-client setup instructions.

## How do I use ToolRouter from the command line?

The `toolrouter-mcp` npm package doubles as a CLI:

```bash
# Check your setup at a glance (version, auth, credits, tools)
npx -y toolrouter-mcp --status

# List all available tools
npx -y toolrouter-mcp tools

# Search for tools
npx -y toolrouter-mcp search "web scraping"

# Call a tool
npx -y toolrouter-mcp call web-search search --query "best MCP tools 2026"

# Call a tool and save the result to a file
npx -y toolrouter-mcp call web-search search --query "best MCP tools 2026" -o results.json
```

## How do I call tools via the REST API?

Send HTTP requests to `api.toolrouter.com`. Browse the catalog with `GET /v1/tools` (no auth), provision a free API key with `POST /v1/auth/provision`, then execute tools with `POST /v1/tools/call` using a Bearer token. Every call returns the same JSON response shape.

Browse the catalog without auth, execute tools with a Bearer token:

```bash
# Browse the catalog (no auth)
curl https://api.toolrouter.com/v1/tools

# Auto-provision a free API key
curl -X POST https://api.toolrouter.com/v1/auth/provision
```

```json
{
  "api_key": "tr_live_fb8c6a1a78551d0f...",
  "key_prefix": "tr_live_fb8c...7a83",
  "claim_url": "https://toolrouter.com/claim?token=53a3d78f...",
  "account_id": "prov_15b7271a...",
  "message": "Your API key is ready. Free tools work immediately."
}
```

Copy the `api_key` value and use it as your Bearer token in subsequent requests.

Most tools in the catalog work immediately with a provisioned key — no provider API keys needed. Tools that call premium upstream APIs (image generation, voice synthesis, deep research) require provider keys, which you can pass per-request via headers. The `web-search` example below works without any provider keys.

```bash
# Call a tool
curl -X POST https://api.toolrouter.com/v1/tools/call \
  -H "Authorization: Bearer tr_live_xxx" \
  -H "Content-Type: application/json" \
  -d '{
    "tool": "web-search",
    "skill": "search",
    "input": { "query": "MCP tools" }
  }'
```

Every call returns the same shape:

```json
{
  "id": "call_xxx",
  "status": "success",
  "output": { ... },
  "usage": {
    "cost": 0.0021,
    "currency": "USD",
    "credits_remaining": 9.99
  },
  "meta": {
    "tool": "web-search",
    "skill": "search",
    "latency_ms": 423
  }
}
```

## How do I validate a call before executing?

Add `"dry_run": true` to your `/v1/tools/call` request. This checks tool resolution, input validation, credentials, and billing without executing or consuming credits. The response tells you if the call would succeed and shows your remaining balance.

Not sure if a call will work? Use `dry_run` to check tool resolution, input validation, credentials, and billing without executing or consuming credits:

```bash
curl -X POST https://api.toolrouter.com/v1/tools/call \
  -H "Authorization: Bearer tr_live_xxx" \
  -d '{
    "tool": "seo",
    "skill": "analyze_page",
    "input": { "url": "https://example.com" },
    "dry_run": true
  }'
```

```json
{
  "valid": true,
  "input_valid": true,
  "credentials_ok": true,
  "billing": { "balance_usd": 9.99, "sufficient": true },
  "rate_limit": { "remaining": 58, "limit": 60 }
}
```

## How do I add provider API keys?

Pass upstream provider keys per-request via headers like `X-Provider-Key-Serper: sp_xxx`. When the call selects that credential, you pay a reduced 5% platform fee instead of the full markup. Keys are used for that single request only and never stored server-side.

Some premium tools require upstream credentials (e.g., Firecrawl, Serper). Pass them per-request via headers:

```bash
curl -X POST https://api.toolrouter.com/v1/tools/call \
  -H "Authorization: Bearer tr_live_xxx" \
  -H "X-Provider-Key-Serper: sp_xxx" \
  -d '{ "tool": "web-search", "skill": "search", "input": { "query": "hello" } }'
```

When a call selects your BYOK header or saved personal/team credential, you pay a reduced 5% platform fee instead of the full markup.

## Troubleshooting

**ToolRouter not connecting**: Verify Node.js 18+ is installed (`node --version`). Run `npx -y toolrouter-mcp --status` to check auth, credits, and tool count.

**"Command not found"**: Ensure `npx` is on your PATH. It ships with Node.js — if missing, reinstall Node from [nodejs.org](https://nodejs.org).

**Tool requires credits**: Provisioned accounts can use free tools immediately. Premium tools (image generation, voice synthesis) require credits — claim your account and top up from the [dashboard](https://toolrouter.com/dashboard/billing).

**Slow first run**: The first `npx -y toolrouter-mcp` invocation downloads the package. Subsequent runs use the npm cache.

## What to read next

- [Overview](/docs/overview) for the product model and built-in capabilities
- [Claude Cowork](/docs/cowork) for running multi-step agentic tasks in Claude Desktop
- [Integration](/docs/integration) for endpoint details, auth, assets, and rate limits
- [API Reference](/docs/api-reference) for the complete REST endpoint documentation
- [Billing](/docs/billing) for credits, pricing, and BYOK rates

## Claim your account

A claim link is the one-time URL that attaches an anonymous ToolRouter account to your signed-in account. Your agent receives it with the first tool result; `account_setup` can also return it. Open it yourself and sign in to retain account access across sessions and enable paid calls.

Until claimed, the account cannot buy credits, run paid tools, save provider credentials, or create additional API keys. Treat the claim URL as private. See [billing](/docs/billing) for credits and [pricing](/pricing) for current charges.