Your AI agent is great at reasoning — but it's starved for real-world niche data. Market intelligence, keyword demand, competition scores... this stuff lives behind expensive subscription APIs that agents can't sign up for autonomously.
What if your agent could just pay for data on the fly? No API keys. No monthly subscriptions. Just an HTTP request, a few cents in USDC, and structured niche research data back in under a second. That's what the x402 protocol enables — and in this tutorial, I'll show you how to wire it up.
The Problem
If you're building AI agents that do market research, content planning, or niche analysis, you've probably hit these walls:
- Niche research data is locked behind expensive subscriptions. Tools like Jungle Scout or Helium 10 charge $30-$100/month — overkill if your agent only needs a few queries.
- Agents can't manage API keys autonomously. Traditional APIs require signup, email verification, and key management. Your agent can't do that.
- Generic data APIs don't cover vertical niches. You need specific niche intelligence (demand scores, competition levels, revenue estimates), not just raw search volume.
The Solution: A Pay-Per-Query Niche Research API
The KDP Intelligence API serves Kindle Direct Publishing niche data — demand scores, competition analysis, revenue estimates, and more — gated by the x402 micropayment protocol.
How it works:
- Your agent hits the endpoint
- Gets back HTTP 402 with a
Payment-Requiredheader containing payment instructions - Signs a USDC authorization (0.03 USDC on Base L2)
- Resends the request with an
X-Paymentheader - Gets structured niche data back
No API key. No account. Payment is the authentication.
Step 1: Discover Available Niches (Free)
First, let's see what data is available. The listing endpoint is free:
curl -s https://kdp-intelligence-api.vercel.app/v1/niches?limit=5 | jq .
Response:
{
"niches": [
{
"keyword": "christian romance",
"demand_score": 90.0,
"competition_score": 55.0,
"bsr_range": "500-2,000",
"monthly_revenue_estimate": 2200.0,
"review_threshold": 45,
"pricing": 4.99,
"data_freshness": "2026-04-28T00:00:00+00:00",
"query_cost_usdc": 0.03,
"api_version": "0.1.0"
}
],
"total": 10,
"api_version": "0.1.0"
}
Your agent now knows what niches are available and what each query costs. Zero friction.
Step 2: Request Niche Detail (Triggers HTTP 402)
When your agent wants the full intelligence on a specific niche, it hits the detail endpoint:
curl -s -D- https://kdp-intelligence-api.vercel.app/v1/niche/gratitude-journal
The API returns HTTP 402 with an empty body ({}) and a base64-encoded Payment-Required header containing the payment instructions. Decode it:
curl -s -D- https://kdp-intelligence-api.vercel.app/v1/niche/gratitude-journal \
| grep -i payment-required | cut -d' ' -f2 | base64 -d | jq .
Decoded payment instructions:
{
"x402Version": 2,
"accepts": [
{
"scheme": "exact",
"network": "eip155:8453",
"amount": "30000",
"payTo": "0xcafe605dFeBa96ba84C2d520e3cF972CaC184E3a",
"asset": "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
"extra": {"name": "USD Coin", "version": "2"}
}
]
}
This is the magic of x402: the API tells the agent exactly how to pay — which network (Base), which token (USDC), how much (amount: "30000" = 0.03 USDC with 6 decimals), and where to send it. All machine-readable, no docs needed.
Step 3: Pay and Get Data
Your agent constructs an X-Payment header containing a signed USDC transfer authorization, then resends:
curl -s https://kdp-intelligence-api.vercel.app/v1/niche/gratitude-journal \
-H "X-Payment: <base64-encoded-x402-envelope>" | jq .
Response:
{
"keyword": "gratitude journal",
"demand_score": 82.5,
"competition_score": 41.0,
"bsr_range": "1,000-5,000",
"monthly_revenue_estimate": 890.0,
"review_threshold": 50,
"pricing": 7.99,
"data_freshness": "2026-04-28T20:00:00+00:00",
"query_cost_usdc": 0.03,
"api_version": "0.1.0"
}
For $0.03 your agent now knows: this niche has strong demand (82.5/100), moderate competition (41/100), titles earn ~$890/month, and you need about 50 reviews to compete.
Full Agent Integration (Python)
Here's a complete working example. Your agent discovers niches, picks one, pays, and gets data:
import base64, json, secrets, time
import httpx
from eth_account import Account
from eth_account.messages import encode_typed_data
BASE_URL = "https://kdp-intelligence-api.vercel.app"
PRIVATE_KEY = "0x..." # Your Base wallet private key
# USDC contract on Base mainnet
USDC_DOMAIN = {
"name": "USD Coin",
"version": "2",
"chainId": 8453,
"verifyingContract": "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
}
EIP712_TYPES = {
"EIP712Domain": [
{"name": "name", "type": "string"},
{"name": "version", "type": "string"},
{"name": "chainId", "type": "uint256"},
{"name": "verifyingContract", "type": "address"},
],
"TransferWithAuthorization": [
{"name": "from", "type": "address"},
{"name": "to", "type": "address"},
{"name": "value", "type": "uint256"},
{"name": "validAfter", "type": "uint256"},
{"name": "validBefore", "type": "uint256"},
{"name": "nonce", "type": "bytes32"},
],
}
def make_x402_payment(pay_to: str, amount: str, private_key: str) -> str:
acct = Account.from_key(private_key)
now = int(time.time())
nonce = "0x" + secrets.token_bytes(32).hex()
auth = {
"from": acct.address,
"to": pay_to,
"value": amount,
"validAfter": str(now - 10),
"validBefore": str(now + 300),
"nonce": nonce,
}
structured = {
"types": EIP712_TYPES,
"primaryType": "TransferWithAuthorization",
"domain": USDC_DOMAIN,
"message": {
**auth,
"value": int(auth["value"]),
"validAfter": int(auth["validAfter"]),
"validBefore": int(auth["validBefore"]),
"nonce": bytes.fromhex(nonce[2:]),
},
}
signable = encode_typed_data(full_message=structured)
signed = Account.sign_message(signable, private_key=private_key)
envelope = {
"x402Version": 2,
"payload": {
"authorization": auth,
"signature": signed.signature.hex(),
},
}
return base64.b64encode(json.dumps(envelope).encode()).decode()
# --- Agent workflow ---
# 1. Discover niches (free)
resp = httpx.get(f"{BASE_URL}/v1/niches?limit=10")
niches = resp.json()["niches"]
print(f"Found {len(niches)} niches")
# 2. Pick a niche and get payment details from the 402 header
keyword = niches[0]["keyword"]
resp = httpx.get(f"{BASE_URL}/v1/niche/{keyword}")
assert resp.status_code == 402
# Payment info is in the Payment-Required header, base64-encoded
payment_info = json.loads(
base64.b64decode(resp.headers["Payment-Required"])
)
pay_to = payment_info["accepts"][0]["payTo"]
amount = payment_info["accepts"][0]["amount"]
# 3. Pay and get intelligence
x_payment = make_x402_payment(pay_to, amount, PRIVATE_KEY)
resp = httpx.get(
f"{BASE_URL}/v1/niche/{keyword}",
headers={"X-Payment": x_payment},
)
data = resp.json()
print(f"Niche: {data['keyword']}")
print(f"Demand: {data['demand_score']}/100")
print(f"Competition: {data['competition_score']}/100")
print(f"Est. monthly revenue: ${data['monthly_revenue_estimate']}")
Install deps: pip install httpx eth-account
Even Easier: Use the x402 SDK
If you don't want to handle payment construction manually, the Coinbase x402 SDK handles the entire 402-pay-retry flow automatically:
Python:
from x402 import x402ClientSync
client = x402ClientSync(private_key="0x...")
resp = client.get("https://kdp-intelligence-api.vercel.app/v1/niche/gratitude-journal")
print(resp.json()) # 402 -> payment -> 200, all automatic
TypeScript:
import { createX402Client } from "x402";
const client = createX402Client({ privateKey: "0x..." });
const resp = await client.get(
"https://kdp-intelligence-api.vercel.app/v1/niche/gratitude-journal"
);
console.log(resp.data);
One line of setup. Your agent gets data. The protocol handles the rest.
What Makes This Different
| Traditional API | x402-Gated API |
|---|---|
| Sign up for account | No account needed |
| Manage API keys | No keys — payment is auth |
| Monthly subscription ($30-100) | Pay per query ($0.03) |
| Human-mediated onboarding | Fully autonomous agent access |
| Credit card required | USDC on Base (agent-native) |
The x402 protocol turns HTTP into a machine-native commerce layer. Your agent reads the 402 response headers, constructs a payment, and gets data — all without human intervention.
Try It Now
- Browse the API: Interactive docs (Swagger UI)
- Machine-readable spec: OpenAPI 3.1.0 JSON
- x402 protocol: github.com/coinbase/x402
- Get USDC on Base: Bridge from any chain or buy directly on Coinbase
Your agent can start buying niche intelligence today — one query at a time, for three cents each.
Built with x402 by Coinbase. Payments settle instantly on Base L2.