Build AI Agents in 5 Minutes

Get a free API key with one command. Access 39 production services — wallets, trading, code execution, storage, analytics, and more. No signup. No credit card. Just curl.

1 Get Your API Key

One POST request. No email, no registration form, no OAuth. You get 200 free credits instantly.

curl

curl -s -X POST https://agent-gateway-kappa.vercel.app/api/keys/create | python3 -m json.tool

Response

{
    "apiKey": "gw_a1b2c3d4e5f6...",
    "credits": 200,
    "rateLimit": "120 requests/minute",
    "message": "Your API key is ready. Use it in the Authorization header."
}

Tip

Save your key — it's shown only once. Each API call costs 1 credit. 200 credits is enough to test every service.

Set it as an environment variable so you can use it in the examples below:

bash

export GW_KEY="gw_your_key_here"

2 Make Your First API Call

Every service is accessible through the gateway at /v1/{service-id}/.... Your API key works across all 39 services.

Check trending tokens

curl

curl -s https://agent-gateway-kappa.vercel.app/v1/onchain-analytics/api/trending \
  -H "Authorization: Bearer $GW_KEY" | python3 -m json.tool

Get real-time crypto prices

curl

curl -s "https://agent-gateway-kappa.vercel.app/v1/crypto-feeds/api/prices" \
  -H "Authorization: Bearer $GW_KEY" | python3 -m json.tool

Execute code in a sandbox

curl

curl -s -X POST https://agent-gateway-kappa.vercel.app/v1/agent-coderunner/api/execute \
  -H "Authorization: Bearer $GW_KEY" \
  -H "Content-Type: application/json" \
  -d '{"language": "python", "code": "import math\nprint(f\"Pi = {math.pi}\")"}' | python3 -m json.tool

Roll provably fair dice

curl

curl -s -X POST https://agent-gateway-kappa.vercel.app/v1/fair-games/games/dice \
  -H "Authorization: Bearer $GW_KEY" \
  -H "Content-Type: application/json" \
  -d '{"sides": 20}' | python3 -m json.tool

Check your remaining credits

curl

curl -s https://agent-gateway-kappa.vercel.app/api/usage \
  -H "Authorization: Bearer $GW_KEY" | python3 -m json.tool

3 Explore Popular Services

The gateway proxies to 39 services across 9 categories. Here are the most popular ones:

Onchain Analytics

Token prices, volume, liquidity, trending across 8 chains

Crypto Price API

Real-time prices for 150+ coins with change percentages

Agent Wallet

Create multi-chain wallets, check balances, send transactions

Code Runner

Sandboxed Python, JavaScript, and Bash execution

Agent Memory

Key-value store + vector search for agent context

DeFi Trading

Hyperliquid DEX proxy — 229 perpetual futures markets

Web Scraper

Extract text, links, and metadata from any URL

LLM Router

Unified API for OpenAI, Anthropic, and Groq models

Webhook Inspector

Create endpoints, inspect payloads, replay requests

Poison Guard

Address poisoning detection for EVM wallets

Fair Games

Cryptographically provable fair dice, cards, roulette

Agent Registry

Discover and register AI agents by capability

Browse the full list with endpoints, Swagger docs, and quick-start examples in the API Catalog.

Service discovery

Your agent can discover services programmatically via GET /api/services or the machine-readable manifest at /.well-known/agent.json.

4 Build a Python Agent

Here's a complete Python script that creates an API key, fetches crypto prices, runs code in a sandbox, and stores results in agent memory — all through a single gateway.

python

import requests

GW = "https://agent-gateway-kappa.vercel.app"

# Step 1: Get an API key (or use an existing one)
key_resp = requests.post(f"{GW}/api/keys/create").json()
api_key = key_resp["apiKey"]
headers = {"Authorization": f"Bearer {api_key}"}
print(f"API Key: {api_key} ({key_resp['credits']} credits)")

# Step 2: Fetch trending tokens
trending = requests.get(
    f"{GW}/v1/onchain-analytics/api/trending",
    headers=headers
).json()
print(f"\nTrending tokens: {len(trending.get('tokens', []))} found")
for token in trending.get("tokens", [])[:5]:
    print(f"  {token.get('name', 'N/A')}: ${token.get('price', 'N/A')}")

# Step 3: Run analysis code in a sandbox
code = """
prices = [64250, 3420, 148, 0.58, 175]
names = ["BTC", "ETH", "SOL", "XRP", "BNB"]
total = sum(prices)
for name, price in zip(names, prices):
    pct = (price / total) * 100
    print(f"{name}: ${price:,.0f} ({pct:.1f}% of basket)")
print(f"\\nBasket total: ${total:,.0f}")
"""
run_resp = requests.post(
    f"{GW}/v1/agent-coderunner/api/execute",
    headers=headers,
    json={"language": "python", "code": code}
).json()
print(f"\nCode output:\n{run_resp.get('output', run_resp)}")

# Step 4: Store results in agent memory
requests.post(
    f"{GW}/v1/agent-memory/api/memory",
    headers=headers,
    json={
        "key": "last_analysis",
        "value": {
            "trending_count": len(trending.get("tokens", [])),
            "code_output": run_resp.get("output", ""),
            "timestamp": "2026-03-03"
        }
    }
)
print("\nResults saved to agent memory.")

# Step 5: Check remaining credits
usage = requests.get(f"{GW}/api/usage", headers=headers).json()
print(f"Credits remaining: {usage.get('credits', 'N/A')}")

5 Build a Node.js Agent

The same agent in Node.js — zero dependencies, just fetch.

javascript

const GW = "https://agent-gateway-kappa.vercel.app";

async function main() {
  // Get API key
  const { apiKey, credits } = await fetch(`${GW}/api/keys/create`, {
    method: "POST"
  }).then(r => r.json());
  const headers = { Authorization: `Bearer ${apiKey}` };
  console.log(`API Key: ${apiKey} (${credits} credits)`);

  // Fetch trending tokens
  const trending = await fetch(
    `${GW}/v1/onchain-analytics/api/trending`, { headers }
  ).then(r => r.json());
  console.log(`\nTrending tokens: ${trending.tokens?.length ?? 0}`);
  trending.tokens?.slice(0, 5).forEach(t =>
    console.log(`  ${t.name}: $${t.price}`)
  );

  // Run Python code in a sandbox
  const run = await fetch(`${GW}/v1/agent-coderunner/api/execute`, {
    method: "POST",
    headers: { ...headers, "Content-Type": "application/json" },
    body: JSON.stringify({
      language: "python",
      code: "print('Hello from sandboxed Python!')\nprint(2 ** 256)"
    })
  }).then(r => r.json());
  console.log(`\nCode output: ${run.output}`);

  // Scrape a webpage
  const scrape = await fetch(`${GW}/v1/agent-scraper/api/scrape`, {
    method: "POST",
    headers: { ...headers, "Content-Type": "application/json" },
    body: JSON.stringify({ url: "https://news.ycombinator.com", extract: "text" })
  }).then(r => r.json());
  console.log(`\nScraped ${scrape.title || "page"}: ${(scrape.text || "").slice(0, 100)}...`);

  // Check usage
  const usage = await fetch(`${GW}/api/usage`, { headers }).then(r => r.json());
  console.log(`\nCredits remaining: ${usage.credits}`);
}

main().catch(console.error);

Run it with node agent.mjs — no npm install needed.

What's Next

✓ Interactive API docs — try endpoints in your browser
✓ Full service catalog — browse all 39 services
✓ agent.json — machine-readable service manifest
✓ llms.txt — LLM-friendly service descriptions
✓ Service discovery API — list + search services
✓ Top up credits — pay with USDC on Base

Tutorials

✓ Build an AI Agent with Crypto Wallet Access — create wallets, check balances, get prices, execute swaps

Common patterns

Crypto research agent — combine onchain-analytics + agent-search + agent-memory to research tokens and remember findings
Trading bot — use crypto-price for signals + defi-trading for execution + agent-scheduler for recurring checks
Code assistant — use agent-coderunner to execute code + agent-files for file management + agent-llm for LLM calls
Monitoring agent — agent-monitor for uptime checks + webhook-inspector for callbacks + agent-scheduler for cron

Ready to Build?

Get your free API key and start building in under a minute.

terminal

curl -s -X POST https://agent-gateway-kappa.vercel.app/api/keys/create

Browse All 39 APIs