Quickstart

First call in 30 seconds

No signup required. Copy a command, get a response. Read endpoints are free and open.

Choose your starting path

Don’t guess the auth model.

Rhumb has one free discovery path and four execution paths. Pick the one that matches how your agent should get authorized before you start wiring calls.

Browse

Free

Best when you want scores, comparisons, failure modes, and category discovery without any signup.

API key

Managed

Best when you want Rhumb-managed routing, failover, and billing behind one stable key.

x402

Zero signup

Best when the agent should pay per call with USDC and retry with tx-hash payment proof. If your wallet emits wrapped smart-wallet proofs, use wallet-prefund for the repeatable path today.

Wallet prefund

Reusable

Best when a wallet should authenticate once, top up balance, and execute repeat calls via X-Rhumb-Key.

BYOK

Provider creds

Best when you already have provider accounts and want Rhumb to route calls without taking margin on the credential itself.

Best first win

Rhumb is strongest today for research, extraction, generation, and narrow enrichment. If you want a clean first success, start there.

Don’t overread the promise

If you are wiring multi-system back-office workflows, use Rhumb as capability infrastructure first. Don’t assume the current product is already a general business-automation layer.

Mental model

Use one default path unless you have a reason not to

Default path: discover a Service, choose a Capability, estimate the call, then execute through Layer 2 with a governed API key or wallet-prefunded API key. Use x402 only when zero-signup per-call matters. Use Layer 1 only when you must pin the provider. Use Layer 3 only when a published recipe already exists.

Think in entities

Service = vendor. Capability = executable action. Recipe = compiled workflow.

Default layer

Start with Layer 2: capability routing. It is the cleanest real production surface today.

Default auth rail

Use a governed API key or wallet-prefunded API key for repeat calls. Use x402 only when zero-signup per-call payment is the point.

Canonical docs

Full map: /docs#resolve-mental-model

1

Try the API

All read endpoints are free, no key required. Pick your language:

curl

curl "https://api.rhumb.dev/v1/services/stripe/score"

JavaScript

const res = await fetch("https://api.rhumb.dev/v1/services/stripe/score");
const { data } = await res.json();
console.log(data.an_score); // 8.1

Python

import requests
data = requests.get("https://api.rhumb.dev/v1/services/stripe/score").json()["data"]
print(data["an_score"])  # 8.1
Response (abbreviated): 
{
  "data": {
    "slug": "stripe",
    "an_score": 8.1,
    "tier": "L4 Native",
    "execution_score": 8.4,
    "access_readiness_score": 7.3,
    "failure_count": 2,
    "review_count": 47
  }
}
2

Explore what's available

Search by need

curl "https://api.rhumb.dev/v1/search?q=send+email"

Browse by category

curl "https://api.rhumb.dev/v1/leaderboard/payments"

Service profile + alternatives

curl "https://api.rhumb.dev/v1/services/stripe"

Check failure modes

curl "https://api.rhumb.dev/v1/services/stripe/failures"
3

Execute capabilities

To actually do things through APIs (send emails, create records, charge cards), start with the default production path: discover a Service, choose a Capability, estimate the call, then execute through Layer 2 with X-Rhumb-Key. Use x402 only when zero-signup per-call payment is the point.

Recommended sequence

# 1) Discover the capability you need
curl "https://api.rhumb.dev/v1/capabilities?search=email"

# 2) Resolve the best provider
curl "https://api.rhumb.dev/v1/capabilities/email.send/resolve"

# 3) Estimate before paying
curl "https://api.rhumb.dev/v1/capabilities/email.send/execute/estimate"

# 4) Execute through Layer 2 with X-Rhumb-Key
curl -X POST "https://api.rhumb.dev/v1/capabilities/email.send/execute"   -H "X-Rhumb-Key: rhumb_live_..."   -H "Content-Type: application/json"   -d '{"body": {"to": "user@example.com", "subject": "Hello", "body": "Hi from Rhumb"}}'

API Key

Sign up, get a key, pass it as X-Rhumb-Key

Best for: default production path

x402 Payment

Zero-signup, per-call USDC payment when request-level payment authorization is the point.

Best for: zero-signup per-call auth

Wallet Prefund

Wallet-auth once, top up reusable balance, execute with X-Rhumb-Key.

Best for: repeat wallet traffic

Your Own Key

Pass your service API key directly. BYOK = full control.

Best for: teams, enterprise

Execute via API key

curl -X POST "https://api.rhumb.dev/v1/capabilities/email.send/execute" \
  -H "X-Rhumb-Key: rhumb_live_..." \
  -H "Content-Type: application/json" \
  -d '{"body": {"to": "user@example.com", "subject": "Hello", "body": "Hi from Rhumb"}}'

Execute via wallet-prefunded balance

# Step 1: Prove wallet control and create wallet session
curl -X POST "https://api.rhumb.dev/v1/auth/wallet/request-challenge"   -H "Content-Type: application/json"   -d '{"chain":"base","address":"0x...","purpose":"access"}'

curl -X POST "https://api.rhumb.dev/v1/auth/wallet/verify"   -H "Content-Type: application/json"   -d '{"challenge_id":"...","signature":"0x..."}'
# Returns wallet session + wallet-scoped API key

# Step 2: Top up reusable balance via x402 settlement
curl -X POST "https://api.rhumb.dev/v1/billing/x402/topup/request"   -H "Authorization: Bearer <wallet_session_token>"   -H "Content-Type: application/json"   -d '{"amount_usd": 1.00}'
# ...settle + verify through /billing/x402/topup/verify...

# Step 3: Execute repeat calls with X-Rhumb-Key (no per-call X-Payment)
curl -X POST "https://api.rhumb.dev/v1/capabilities/email.send/execute"   -H "X-Rhumb-Key: rhumb_live_..."   -H "Content-Type: application/json"   -d '{"body": {"to": "user@example.com", "subject": "Hello"}}'

Execute via x402 (zero signup)

# Step 1: Request execution without an API key
curl -X POST "https://api.rhumb.dev/v1/capabilities/email.send/execute" \
  -H "Content-Type: application/json" \
  -d '{"body": {"to": "user@example.com", "subject": "Hello"}}'
# Returns 402 with the exact asset, amount, address, and network to pay

# Step 2: Pay the exact requirement from your wallet
# Double-check asset + network + destination address before sending funds

# Step 3: Retry with payment proof from the same wallet
curl -X POST "https://api.rhumb.dev/v1/capabilities/email.send/execute" \
  -H 'X-Payment: {"tx_hash":"0x...","network":"<network-from-402>","wallet_address":"0x..."}' \
  -H "Content-Type: application/json" \
  -d '{"body": {"to": "user@example.com", "subject": "Hello"}}'

Honest note

The repeatable public x402 execute path today is tx-hash proof. Wallet-prefund top-up verification is the standard x402 authorization path; direct execute is not. Some smart-wallet or wrapped authorization payloads still hit a production compatibility boundary on the direct execute rail because the facilitator path is not wired. If your buyer emits wrapped proofs, switch to wallet-prefund or use the standard API-key rail.

4

Connect via MCP

If your agent supports MCP, connect directly:

Install

npx rhumb-mcp@latest

Claude Desktop config

{
  "mcpServers": {
    "rhumb": {
      "command": "npx",
      "args": ["rhumb-mcp@latest"],
      "env": {
        "RHUMB_API_KEY": "rhumb_live_..."
      }
    }
  }
}

21 tools available: find_services, get_score, get_alternatives, get_failure_modes, execute_capability, and more. Full MCP guide →

Keep going

API Reference All endpoints, parameters, responses Credential Security BYOK, API key, wallet-prefund, x402 — which rail fits your agent Tool Comparisons 9 head-to-head comparisons with live data