APIbase.pro — The API Hub for AI Agents

One MCP endpoint. 413 tools. 123 providers. Pay per call with x402 (USDC on Base) or MPP (USDC on Tempo).

Live Platform | Tool Catalog | MCP Endpoint | Frameworks | Dashboard

Product Demo

https://github.com/user-attachments/assets/9e598d61-b2d0-486c-bd34-f0cb0354d09c

12-slide walkthrough: connect → discover tools → 13-stage pipeline → dual-rail payments → analytics. Full interactive version →

What is APIbase?

Production MCP server that gives AI agents access to 413 real-world API tools through a single endpoint. Agents connect once to https://apibase.pro/mcp and can search flights, get stock quotes, translate text, check weather alerts, generate images, send emails, look up holidays, shorten URLs, detect fires by satellite, decode VINs, look up chemical compounds, find EV chargers, batch multiple calls, track usage analytics — and 250+ more tools across 30+ categories.

Built for AI agents, not humans. Auto-registration, zero setup, pay-per-call via x402 USDC micropayments on Base or MPP (Machine Payments Protocol) on Tempo.

Quick Start (30 seconds)

Claude Desktop / Cursor / Windsurf

{
  "mcpServers": {
    "apibase": {
      "url": "https://apibase.pro/mcp"
    }
  }
}

Multi-server setup (recommended)

Combine APIbase (real-world APIs) with Playwright (browser) and Context7 (docs):

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

Via npm (stdio bridge)

{
  "mcpServers": {
    "apibase": {
      "command": "npx",
      "args": ["-y", "apibase-mcp-client"]
    }
  }
}

REST API

# Register and get API key
curl -X POST https://apibase.pro/api/v1/agents/register \
  -H "Content-Type: application/json" \
  -d '{"agent_name": "my-agent", "agent_version": "1.0.0"}'

# Call any tool
curl -X POST https://apibase.pro/api/v1/tools/finnhub.quote/call \
  -H "Authorization: Bearer ak_live_..." \
  -H "Content-Type: application/json" \
  -d '{"symbol": "AAPL"}'

Tool Categories (413 tools, 123 providers)

Full tool catalog with schemas: https://apibase.pro/api/v1/tools

Platform Features

Usage Analytics (Free)

Track your API usage — total calls, cost, cache hit rate, latency, and per-tool breakdown.

# Usage summary
curl -X POST https://apibase.pro/api/v1/tools/account.usage/call \
  -H "Authorization: Bearer ak_live_..." \
  -d '{"period": "7d"}'

# Per-tool breakdown
curl -X POST https://apibase.pro/api/v1/tools/account.tools/call \
  -H "Authorization: Bearer ak_live_..." \
  -d '{"sort": "cost", "limit": 10}'

# Time series (hourly/daily buckets)
curl -X POST https://apibase.pro/api/v1/tools/account.timeseries/call \
  -H "Authorization: Bearer ak_live_..." \
  -d '{"period": "30d", "granularity": "day"}'

Tool Quality Index (Free)

Check tool reliability before calling — uptime, p50/p95 latency, error rate. Updated every 10 minutes.

# Quality metrics for a specific tool
curl -X POST https://apibase.pro/api/v1/tools/platform.tool_quality/call \
  -H "Authorization: Bearer ak_live_..." \
  -d '{"tool_id": "crypto.get_price"}'

# Rankings — find the most reliable tools
curl -X POST https://apibase.pro/api/v1/tools/platform.tool_rankings/call \
  -H "Authorization: Bearer ak_live_..." \
  -d '{"sort": "uptime", "limit": 20}'

Batch API (Free wrapper)

Execute up to 20 tool calls in parallel with a single request. Each sub-call runs the full pipeline independently. You pay only for individual tool calls.

# Via MCP tool
curl -X POST https://apibase.pro/api/v1/tools/platform.call_batch/call \
  -H "Authorization: Bearer ak_live_..." \
  -d '{"calls": [
    {"tool_id": "crypto.get_price", "params": {"coin": "bitcoin"}},
    {"tool_id": "finance.exchange_rates", "params": {"from": "USD", "to": "EUR"}},
    {"tool_id": "country.by_code", "params": {"code": "US"}}
  ]}'

# Via REST endpoint
curl -X POST https://apibase.pro/api/v1/tools/call_batch \
  -H "Authorization: Bearer ak_live_..." \
  -d '{"calls": [...], "max_parallel": 10}'

Predictive Pre-fetching

When an agent calls a tool, the platform can automatically pre-fetch related data into cache. For example, a flight search pre-fetches exchange rates for the destination currency — so when the agent asks for rates next, it's an instant cache hit.

• Fire-and-forget: does not slow down the original response
• Controlled by PREFETCH_ENABLED env var (disabled by default)
• Rules: flight search → exchange rates, real estate → walk score, geocode → country data

How Payment Works

APIbase supports dual payment rails — agents can pay using either protocol:

x402 (USDC on Base)

MPP (Machine Payments Protocol)

No subscriptions. No minimums. Agent pays only for successful calls. Failed provider calls are auto-refunded.

13-Stage Pipeline

Every tool call passes through:

AUTH → IDEMPOTENCY → CONTENT_NEG → SCHEMA_VALIDATION → TOOL_STATUS →
CACHE → RATE_LIMIT → ESCROW → PROVIDER_CALL →
ESCROW_FINALIZE → LEDGER_WRITE → CACHE_SET → RESPONSE

• Escrow-first: USDC locked before provider call, refunded on failure
• Idempotent: same request + same key = same result, no double charges
• Cache: per-tool TTL (5s for stock prices, 7 days for walkability scores)
• Fail-closed: Redis down = reject all, no silent degradation

Authentication

Auto-registration: agents get API keys instantly on first request. No forms, no approval.

MPP Payment Flow (important for agent developers)

MPP uses a challenge–credential–receipt cycle. You MUST follow the full flow:

1. Agent → POST /api/v1/tools/{tool}/call (with Authorization: Bearer <key>)
2. Server → 402 + WWW-Authenticate: Payment id="...", method="tempo", request="..."
3. Agent signs payment on Tempo → retries with Authorization: Payment <credential>
4. Server verifies on-chain → 200 + Payment-Receipt header + tool result

Critical: Each 402 challenge is unique (HMAC-bound to the request URL, amount, and timestamp). You cannot reuse a credential from one challenge on a different endpoint or after expiry. The mppx SDK handles this automatically.

Using mppx SDK (recommended):

import { Mppx, tempo } from 'mppx/client'

// mppx auto-handles the full 402 → pay → retry cycle
const mppx = Mppx.create({
  methods: [tempo({ account: myTempoWallet })],
})

// This single call handles: request → 402 → sign → pay → retry → 200
const response = await fetch('https://apibase.pro/api/v1/tools/nasa.apod/call', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'Authorization': 'Bearer ak_live_<your_key>',  // API key for agent identity
    'X-API-Key': 'ak_live_<your_key>',             // Preserved when mppx replaces Authorization
  },
  body: JSON.stringify({}),
})

Using Tempo CLI:

curl -fsSL https://tempo.xyz/install | bash
tempo wallet login
tempo request https://apibase.pro/api/v1/tools/nasa.apod/call -X POST --json '{}'

Using AgentCash (one command):

# Try any tool instantly
npx agentcash try https://apibase.pro

# Add all APIbase tools to your agent
npx agentcash add https://apibase.pro

Note: When mppx retries with Authorization: Payment, it replaces the original Bearer header. To preserve agent identity, also send your API key via X-API-Key header — the server accepts both.

Error Codes (Agent-Friendly)

Every error response includes machine-readable recovery hints:

{
  "error": "rate_limit_exceeded",
  "error_code": "RATE_LIMIT_EXCEEDED",
  "message": "Too many requests",
  "request_id": "abc123",
  "suggested_action": "retry_after_delay",
  "documentation_url": "https://apibase.pro/frameworks#rest",
  "retry_after": 15
}

MCP Discovery

GET  /.well-known/mcp.json              → MCP server metadata (transport, capabilities, tools count)
GET  /.well-known/mcp/server-card.json  → Full tool catalog with schemas (Smithery)
GET  /.well-known/ai-capabilities.json  → AI capabilities manifest (21 categories)
GET  /.well-known/agent.json            → A2A agent card (protocol, auth, payment)
GET  /.well-known/x402-payment.json     → Payment config (network, facilitators, dual-rail)
GET  /.well-known/openapi.json          → OpenAPI 3.1 spec (with x-payment-info)
GET  /ai.txt                            → Plain text AI agent discovery
GET  /llms.txt                          → Concise LLM context
GET  /api/v1/tools                      → Live tool catalog (all 413 tools, JSON schemas)
GET  /health/ready                      → System health check
POST /mcp  prompts/get discover_tools   → Browse tools by category or task (progressive disclosure)
GET  /frameworks                        → Integration guides for 9 frameworks

Progressive disclosure: Instead of loading all 413 tool schemas into context, agents can call the discover_tools prompt to find relevant tools first:

• discover_tools (no args) → 21 categories with tool counts
• discover_tools category="travel" → 17 travel tools
• discover_tools task="check earthquake near Tokyo" → matching tools ranked by relevance

Tool composition hints: Task-based search results include related tool suggestions:

- amadeus.flights.search: Search for real-time flight offers...
  → Related: amadeus.flight_price (Confirm exact pricing), finance.exchange_rates (Convert to local currency)

Integrations

Every framework connects to one endpoint: https://apibase.pro/mcp

Full framework guides with code examples →

Registry Listings

Architecture

• 16 Docker containers: API, Worker, Outbox, PostgreSQL, Redis, Nginx, Prometheus, Grafana, Loki, Promtail, Alertmanager, exporters
• Single Hetzner server with automated health checks, graceful shutdown, and 27 Prometheus alert rules
• PostgreSQL = source of truth for financial data (append-only ledger)
• Redis = cache, rate limiting, single-flight deduplication
• Fail-closed: any infrastructure failure = reject requests, never pass through

Self-Hosting

Prerequisites

• Docker 24.0+ with Compose v2.0+
• 8GB+ RAM (16 containers)
• Ports: 8880 (Nginx), 3000 (API), 5432 (Postgres), 6379 (Redis) — all internal

Quick Start

git clone https://github.com/whiteknightonhorse/APIbase.git
cd APIbase
cp .env.example .env    # edit: set POSTGRES_PASSWORD, X402_PAYMENT_ADDRESS, provider keys
docker compose build
docker compose -f docker-compose.yml -f docker-compose.prod.yml up -d

Verify

# Health check (Nginx on 8880)
curl http://localhost:8880/health/ready

# Check all 16 containers
docker compose ps

# View API logs
docker compose logs api --tail 20

See .env.example for all configuration options. Never commit .env to git.

License

MIT