Works with everything

One endpoint, every framework. Connect via MCP, OpenAI functions, A2A, or plain REST. Your agent calls tools the same way regardless of which framework it runs on.

Get Your API KeyFull API Reference
MCP Streamable HTTPOpenAI FunctionsGoogle A2AREST / HTTP
01

Claude Code

Add ToolRoute as an MCP server in your .mcp.json and every tool is available instantly. Streamable HTTP means zero process management — one URL, all 70+ tools.

View full docs
.mcp.json
{
  "mcpServers": {
    "toolroute": {
      "type": "http",
      "url": "https://toolroute.ai/mcp",
      "headers": {
        "Authorization": "Bearer tr_your_api_key"
      }
    }
  }
}
02

Cursor

Same MCP endpoint works in Cursor. Add the server in Settings > MCP Servers and every ToolRoute tool appears as a native action your Cursor agent can call.

View full docs
cursor-settings.json
// Settings > MCP Servers > Add Server
{
  "name": "toolroute",
  "type": "http",
  "url": "https://toolroute.ai/mcp",
  "headers": {
    "Authorization": "Bearer tr_your_api_key"
  }
}
03

OpenAI Agents SDK

Fetch the tool catalog in OpenAI function-calling format and pass it straight to the Agents SDK. ToolRoute handles execution — your agent just calls functions.

View full docs
openai-agent.py
import httpx, json
from agents import Agent, FunctionTool

# Fetch tools in OpenAI format
tools_resp = httpx.get(
    "https://toolroute.ai/api/v1/tools?format=openai"
).json()

# Register each as a FunctionTool
def call_tool(name: str, args: dict):
    return httpx.post(
        "https://toolroute.ai/api/v1/execute",
        headers={"Authorization": "Bearer tr_your_api_key"},
        json={"tool": name, "input": args},
    ).json()

agent = Agent(
    name="researcher",
    tools=[FunctionTool.from_dict(t, call_tool) for t in tools_resp],
)
04

LangChain

Wrap the /api/v1/execute endpoint as a LangChain StructuredTool. Your chains and agents call ToolRoute tools like any other LangChain tool — no adapter library needed.

View full docs
langchain_tool.py
import httpx
from langchain_core.tools import StructuredTool

def toolroute_execute(tool: str, input: dict) -> dict:
    resp = httpx.post(
        "https://toolroute.ai/api/v1/execute",
        headers={"Authorization": "Bearer tr_your_api_key"},
        json={"tool": tool, "input": input},
    )
    return resp.json()

tavily = StructuredTool.from_function(
    func=lambda query: toolroute_execute(
        "tavily/search", {"query": query}
    ),
    name="tavily_search",
    description="Search the web via Tavily",
)
05

CrewAI

Create a CrewAI Tool class that wraps the ToolRoute REST endpoint. Your crew members use it like any other tool — works with any ToolRoute adapter out of the box.

View full docs
crewai_tool.py
import httpx
from crewai.tools import BaseTool

class ToolRouteTool(BaseTool):
    name: str = "toolroute"
    description: str = "Execute any tool via ToolRoute"

    def _run(self, tool: str, input: dict) -> dict:
        resp = httpx.post(
            "https://toolroute.ai/api/v1/execute",
            headers={
                "Authorization": "Bearer tr_your_api_key"
            },
            json={"tool": tool, "input": input},
        )
        return resp.json()

# Usage in a crew
search = ToolRouteTool()
result = search._run("tavily/search", {"query": "MCP tools"})
06

AutoGen

Register ToolRoute functions directly from the OpenAI-format catalog. AutoGen agents discover and call them through the standard function-calling interface.

View full docs
autogen_agent.py
import httpx
from autogen import AssistantAgent, UserProxyAgent

# Fetch OpenAI-format tool definitions
tools = httpx.get(
    "https://toolroute.ai/api/v1/tools?format=openai"
).json()

def execute_tool(name: str, **kwargs):
    return httpx.post(
        "https://toolroute.ai/api/v1/execute",
        headers={"Authorization": "Bearer tr_your_api_key"},
        json={"tool": name, "input": kwargs},
    ).json()

assistant = AssistantAgent("assistant", llm_config={
    "tools": tools,
})
# Register the execution function
for tool in tools:
    assistant.register_function({
        tool["function"]["name"]: execute_tool
    })
07

Google A2A

ToolRoute speaks the Agent-to-Agent protocol natively. Point any A2A client at the /api/a2a endpoint to discover capabilities via the agent card and send tasks.

View full docs
a2a-client.ts
// Discover the agent card
const card = await fetch(
  "https://toolroute.ai/.well-known/agent.json"
).then(r => r.json());

// Send a task via A2A
const task = await fetch("https://toolroute.ai/api/a2a", {
  method: "POST",
  headers: {
    "Content-Type": "application/json",
    "Authorization": "Bearer tr_your_api_key",
  },
  body: JSON.stringify({
    jsonrpc: "2.0",
    method: "tasks/send",
    params: {
      message: {
        role: "user",
        parts: [{ text: "Search for MCP tools" }],
      },
    },
  }),
}).then(r => r.json());
08

Direct REST / curl

No SDK required. The REST API works from any language, any platform — curl, fetch, httpx, whatever you have. One POST with your API key and the tool name.

View full docs
terminal
# List all available tools
curl https://toolroute.ai/api/v1/tools

# Execute a tool
curl -X POST https://toolroute.ai/api/v1/execute \
  -H "Authorization: Bearer tr_your_api_key" \
  -H "Content-Type: application/json" \
  -d '{
    "tool": "tavily/search",
    "input": { "query": "best MCP servers 2026" }
  }'

# Check your key & balance
curl https://toolroute.ai/api/v1/key \
  -H "Authorization: Bearer tr_your_api_key"

Don't see your framework?

The REST API works everywhere. If your framework can make an HTTP POST, it can use ToolRoute. No SDK, no adapter, no lock-in.

Get Started FreeBrowse All Tools