Build agents that pay for what they use

dao.pub is an API marketplace built for AI agents. No API keys. No subscriptions. Your agent discovers a service, calls it, and pays per-request in USDC — automatically.

Give your agent access

The fastest way to onboard an agent is to paste this into your conversation:

Setup dao.pub with https://dao.pub/setup.md

Your agent will fetch the setup file, install it as a skill, create a wallet, and be ready to call services. Works with Claude Code, Cursor, Windsurf, or any agent that can fetch URLs.

Copy as markdown

Every service page has a Copy as markdown button that copies the complete API reference — endpoints, methods, parameters, pricing, and usage instructions — as a single markdown document.

What gets copied:

• Service name, description, and base URL
• Every endpoint with method, path, price, and description
• Request parameters (path, query, body, headers) with types
• Usage instructions per endpoint where available

Example: go to dao.pub/market/services/exa and click Copy as markdown. Paste the result into your agent — it now knows every Exa endpoint, what params they take, and how to call them.

Copy as skill

The Copy as skill button generates a ready-to-save skill file that includes the API reference plus instructions for calling endpoints with x402_fetch.

Claude Code

# Copy the skill from any service page, then save it:
pbpaste > ~/.claude/skills/exa.md

# Or have your agent do it — paste the skill into a conversation:
# "Save this as a skill for Exa"

Other agents

Include the skill content in your system prompt, or save it wherever your agent loads context from. The format is standard markdown — works everywhere.

Service discovery (API)

Agents can discover services and endpoints programmatically — no docs page needed.

List all services

GET https://api.dao.pub/market/

→ {"status": "ok", "services": 19}

Get endpoints for a service

Hit any service root for a HATEOAS-style response with every callable endpoint:

GET https://api.dao.pub/market/exa

{
  "service": "exa",
  "_links": {
    "self": "https://api.dao.pub/market/exa",
    "docs": "https://dao.pub/market/services/exa"
  },
  "endpoints": [
    {
      "method": "POST",
      "href": "https://api.dao.pub/market/exa/search",
      "description": "Semantic web search.",
      "price": "10000"
    },
    {
      "method": "POST",
      "href": "https://api.dao.pub/market/exa/answer",
      "description": "Get a direct answer to a question.",
      "price": "10000"
    }
  ]
}

An agent can call the root, pick an endpoint, and call it — all from JSON. No web browsing required.

Quickstart (60 seconds)

Three steps to get your agent calling paid APIs.

curl -sL https://dao.pub/setup.md > ~/.claude/skills/dao-pub-market.md

curl -sS -X POST https://api.wallet.paysponge.com/api/agents/register \
  -H "Sponge-Version: 0.2.1" \
  -H "Content-Type: application/json" \
  -d '{"name": "my-agent", "agentFirst": true, "testnet": false}'

curl -sS -X POST https://api.wallet.paysponge.com/api/x402/fetch \
  -H "Authorization: Bearer $SPONGE_API_KEY" \
  -H "Sponge-Version: 0.2.1" \
  -H "Content-Type: application/json" \
  -d '{
    "url": "https://api.dao.pub/market/exa/search",
    "method": "POST",
    "body": {"query": "best coffee in NYC", "text": true},
    "preferred_chain": "base"
  }'

x402_fetch(
  url: "https://api.dao.pub/market/exa/search",
  method: "POST",
  body: {"query": "best coffee in NYC", "text": true}
)

Sponge wallet recommended

Sponge provides a managed wallet that handles x402 payments automatically. Your agent calls x402_fetch — Sponge handles the 402 → sign → pay → retry loop.

Why Sponge

• No private key management — Sponge holds the keys
• Single API call to pay for any service
• MCP tools for Claude Code, Cursor, etc.
• Works on Base and Solana

MCP tools

With the Sponge MCP server installed, your agent can call services directly:

x402_fetch(
  url: "https://api.dao.pub/market/{service}/{path}",
  method: "POST",
  body: { ... }
)

REST API

POST https://api.wallet.paysponge.com/api/x402/fetch
Authorization: Bearer {apiKey}
Sponge-Version: 0.2.1
Content-Type: application/json

{
  "url": "https://api.dao.pub/market/{service}/{path}",
  "method": "POST",
  "body": { ... },
  "preferred_chain": "base"
}

Direct wallet (x402) advanced

Any wallet with a private key and USDC can call x402 services directly. No Sponge needed.

How x402 works

1. Call the endpoint → receive 402 with a payment-required header (base64 JSON)
2. Decode the requirements: payTo address, amount, asset (USDC), network (Base)
3. Sign a USDC payment authorization (EIP-712)
4. Retry the request with the signed proof in an X-PAYMENT header

Inspect a 402 response

curl -sS -X POST https://api.dao.pub/market/exa/search \
  -H "Content-Type: application/json" \
  -d '{"query": "test"}' | jq '.accepts[0]'

{
  "scheme": "exact",
  "network": "eip155:8453",
  "amount": "10000",
  "asset": "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
  "payTo": "0x6302D9e6DBB22fEC3c350551568Bb39B4b35Ad57",
  "maxTimeoutSeconds": 300
}

Client library

import { withPayment } from "x402-client";

const response = await withPayment(
  fetch("https://api.dao.pub/market/exa/search", {
    method: "POST",
    headers: {"Content-Type": "application/json"},
    body: JSON.stringify({query: "coffee NYC", text: true})
  }),
  { privateKey: process.env.PRIVATE_KEY }
);

Pricing

Pay-per-call in USDC. Prices are in the smallest unit (6 decimals) — divide by 1,000,000 for dollars.

See individual service pages for per-endpoint pricing.

Built by dao.pub. Powered by sponge (not affiliated).