Connect from any AI framework

One MCP endpoint. 1393 tools. Works with every major AI framework.

https://apibase.pro/mcp

Claude Desktop / Claude Code Native MCP

Add to ~/Library/Application Support/Claude/claude_desktop_config.json (macOS) or %APPDATA%\Claude\claude_desktop_config.json (Windows):

{
  "mcpServers": {
    "apibase": {
      "url": "https://apibase.pro/mcp",
      "transport": "streamable-http"
    }
  }
}

No API key needed — auto-registration on first call. Optional: add "headers": {"Authorization": "Bearer ak_live_..."}

Cursor IDE GA Jan 2026

Add to .cursor/mcp.json in your project root:

{
  "mcpServers": {
    "apibase": {
      "url": "https://apibase.pro/mcp",
      "transport": "streamable-http"
    }
  }
}

Or install via Cursor Settings → MCP → Add Server → URL: https://apibase.pro/mcp

Windsurf (Codeium) Cascade Agent

Add to ~/.codeium/windsurf/mcp_config.json:

{
  "mcpServers": {
    "apibase": {
      "serverUrl": "https://apibase.pro/mcp",
      "transport": "streamable-http"
    }
  }
}

Or: Windsurf → Cascade → MCP Tools → Add Server

OpenAI Agents SDK Python + TS

Python (recommended: MCPServerManager)

from agents import Agent, Runner
from agents.mcp import MCPServerStreamableHTTP, MCPServerManager

# MCPServerManager handles lifecycle of all MCP connections
async with MCPServerManager(
    servers=[
        MCPServerStreamableHTTP(
            url="https://apibase.pro/mcp",
            headers={"Authorization": "Bearer ak_live_..."}
        )
    ]
) as manager:
    agent = Agent(
        name="my-agent",
        instructions="You have access to 1393 tools.",
        mcp_servers=manager.servers
    )
    result = await Runner.run(agent, "Search flights from NYC to London")
    print(result.final_output)

MCPServerManager is the recommended way to manage multiple MCP connections. See official docs.

TypeScript

import { MCPServerStreamableHTTP } from "@openai/agents/mcp";

const server = new MCPServerStreamableHTTP({
  url: "https://apibase.pro/mcp",
  headers: { Authorization: "Bearer ak_live_..." }
});
await server.connect();

LangChain / LangGraph MultiServerMCPClient

from langchain_mcp_adapters.client import MultiServerMCPClient

async with MultiServerMCPClient({
    "apibase": {
        "url": "https://apibase.pro/mcp",
        "transport": "streamable_http",
        "headers": {"Authorization": "Bearer ak_live_..."}
    }
}) as client:
    tools = client.get_tools()
    # Use with any LangChain agent
    from langgraph.prebuilt import create_react_agent
    agent = create_react_agent(model, tools)

Install: pip install langchain-mcp-adapters

Google ADK (Agent Development Kit) v1.0 Stable

from google.adk.tools.mcp_tool import McpToolset, StreamableHTTPConnectionParams

toolset = McpToolset(
    connection_params=StreamableHTTPConnectionParams(
        url="https://apibase.pro/mcp",
        headers={"Authorization": "Bearer ak_live_..."}
    )
)
tools, exit_stack = await toolset.create_tools()
# tools is a list of BaseTool — use with any ADK agent

Install: pip install google-adk

CrewAI URL-based config

from crewai import Agent, Task, Crew

agent = Agent(
    role="Research Assistant",
    goal="Find real-time data using 1393 tools",
    backstory="You have access to APIbase MCP server with tools for flights, weather, stocks, jobs, and more.",
    mcp_servers=["https://apibase.pro/mcp"],
    verbose=True
)

CrewAI auto-discovers tools via MCP. No manual tool registration needed.

Microsoft Copilot Studio Enterprise

In Copilot Studio → Actions → Add MCP Server:

Requires Microsoft 365 Copilot license. MCP support is GA as of 2026.

Sunpeak MCP Apps

Sunpeak is an open-source framework for building interactive MCP Apps that run inside ChatGPT and Claude. Connect APIbase as a backend to give your app access to 1393 tools — flights, finance, weather, government data, museums, and more.

import { createApp } from "sunpeak";

const app = createApp({
  mcpServers: [
    {
      name: "apibase",
      url: "https://apibase.pro/mcp",
      transport: "streamable-http"
    }
  ]
});

// Your app now has access to 1393 tools via MCP
// Use discover_tools prompt to find relevant tools by task
await app.run();

Install: pnpm add -g sunpeak  ·  Docs: sunpeak.ai  ·  No API key required (auto-registration)

REST / curl (any language) Universal

# Browse all tools
curl -s https://apibase.pro/api/v1/tools | jq '.data | length'

# Call a free tool (no payment needed)
curl -X POST https://apibase.pro/api/v1/tools/account.usage/call \
  -H "Authorization: Bearer ak_live_..." \
  -H "Content-Type: application/json" \
  -d '{"period": "7d"}'

# Paid tool → 402 with payment instructions
curl -X POST https://apibase.pro/api/v1/tools/crypto.trending/call \
  -H "Authorization: Bearer ak_live_..." \
  -H "Content-Type: application/json" \
  -d '{}'

Progressive disclosure

1393 tools is too many for any context window. Use discover_tools prompt to find relevant tools first:

# MCP: call the discover_tools prompt
{"method": "prompts/get", "params": {"name": "discover_tools", "arguments": {"task": "search flights from NYC to London"}}}

# REST: browse categories
curl -s https://apibase.pro/api/v1/tools | jq '.data[] | select(.category == "travel")'

Multi-server setup (recommended)

Most agents need 3 types of tools: browser (Playwright), docs (Context7), and real-world data (APIbase). Configure all three together:

Claude Desktop / Cursor / Windsurf

{
  "mcpServers": {
    "apibase": {
      "url": "https://apibase.pro/mcp",
      "transport": "streamable-http"
    },
    "playwright": {
      "command": "npx",
      "args": ["-y", "@playwright/mcp"]
    },
    "context7": {
      "command": "npx",
      "args": ["-y", "@upstash/context7-mcp"]
    }
  }
}

Playwright = browser automation (2.3M npm/week). Context7 = up-to-date library docs (875K npm/week). APIbase = 1393 tools (flights, stocks, weather, jobs, e-commerce). Each covers a different need — no overlap.

Why three servers?

The agent decides which server to call based on the task. No routing logic needed — the LLM reads tool descriptions and picks the right one.

OpenAI Agents SDK (multi-server via MCPServerManager)

from agents import Agent, Runner
from agents.mcp import MCPServerStreamableHTTP, MCPServerStdio, MCPServerManager

async with MCPServerManager(
    servers=[
        MCPServerStreamableHTTP(url="https://apibase.pro/mcp"),
        MCPServerStdio(command="npx", args=["-y", "@playwright/mcp"]),
        MCPServerStdio(command="npx", args=["-y", "@upstash/context7-mcp"]),
    ]
) as manager:
    agent = Agent(
        name="research-agent",
        instructions="You have browser, docs, and 1393 tools.",
        mcp_servers=manager.servers
    )
    result = await Runner.run(agent, "Get AAPL stock price")

Base MCP companion Pay from your Base account

Base launched their official Base MCP server in May 2026 with native x402 payment support. APIbase is x402-native on Base mainnet via a self-hosted facilitator — the two pair cleanly. Base MCP signs payments from your Base Account; APIbase serves the 1393 tools your agent actually uses.

Combined config (Claude Desktop / Cursor / Windsurf)

{
  "mcpServers": {
    "base-mcp": {
      "url": "https://mcp.base.org"
    },
    "apibase": {
      "url": "https://apibase.pro/mcp",
      "transport": "streamable-http"
    }
  }
}

What each one does

For Base App users this is the cleanest path: zero API key management (Base Account handles auth), zero per-provider signup (APIbase aggregates 401 providers), one approval flow (Base App pops up for each paid call). Compatible because both sides speak EIP-3009 transferWithAuthorization on Base mainnet.

Quick test from Claude Desktop

After adding both MCP servers to your config and authenticating Base MCP:

You: "What's the current price of AAPL?"
Agent: [calls APIbase finnhub.quote — gets 402 with x402 challenge]
Agent: [hands payment challenge to Base MCP — user approves in Base Account popup]
Agent: [retries with X-Payment header — APIbase settles on-chain via local facilitator]
Agent: "AAPL is trading at $187.42 (+0.34%) as of 14:23 ET."

First paid call may take 2–3s longer than free tools (Base mainnet finality). Cache hits on the same tool within TTL skip the on-chain settle entirely — 10% of full price billed via balance debit.

LangChain (multi-server)

async with MultiServerMCPClient({
    "apibase": {"url": "https://apibase.pro/mcp", "transport": "streamable_http"},
    "playwright": {"command": "npx", "args": ["-y", "@playwright/mcp"]},
    "context7": {"command": "npx", "args": ["-y", "@upstash/context7-mcp"]}
}) as client:
    tools = client.get_tools()  # all tools from all 3 servers
    agent = create_react_agent(model, tools)

Dual-rail payments: x402 (Base) + MPP (Tempo)

APIbase settles paid tool calls on two rails — pick either per request:

• x402 — Base mainnet: USDC via EIP-3009 transferWithAuthorization, signed by your Base Account / wallet, settled by our facilitator.
• MPP — Tempo (chain 4217): USDC on Tempo via the mppx SDK (npm i mppx) — lightweight agent micropayments (Bearer + X-API-Key). RPC https://rpc.tempo.xyz.

Free tools (price 0) need no payment. Paid tools enforce payment server-side and fail closed — no free bypass.