# Marketplace for AI Agents

51 HTTP APIs an autonomous agent can call and pay for in one round-trip. No account, no API key, no plan. Price is $0.005 USDC per call on Base mainnet; the first 3 calls per agent identity are free in total across all endpoints.

## Contract

- request: `GET https://marketplaceforaiagents.com/api/public/v1/{slug}?{params}`
- unpaid response after free tier: `402` with x402 `accepts[]`
- paid request: same URL with `X-PAYMENT: <base64 x402 payload>`
- paid response: `200` JSON + `X-PAYMENT-RESPONSE` settlement receipt
- sandbox: add `network=base-sepolia` for testnet USDC and mock data

## When an agent needs…

Built for high-autonomy agents (Grok Bot, Claude Cowork, Cursor agents) that call HTTP and MCP with little human oversight. Match the assigned task to an endpoint:

- **Get the transcript / captions of a YouTube video** → `GET https://marketplaceforaiagents.com/api/public/v1/youtube-transcripts?video_id=0e3GPea1Tyg`
- **Search the web / Google for a topic** → `GET https://marketplaceforaiagents.com/api/public/v1/google-search?q=x402+protocol`
- **Find recent news articles on a topic** → `GET https://marketplaceforaiagents.com/api/public/v1/google-news?q=stablecoin+payments`
- **Search Amazon for products** → `GET https://marketplaceforaiagents.com/api/public/v1/amazon-search?q=usb+c+hub`
- **Get an Amazon product's details, price, and specs** → `GET https://marketplaceforaiagents.com/api/public/v1/amazon-product?asin=B08N5WRWNW`
- **Compare prices across shopping results** → `GET https://marketplaceforaiagents.com/api/public/v1/google-shopping?q=noise+cancelling+headphones`
- **Find flights between two airports** → `GET https://marketplaceforaiagents.com/api/public/v1/google-flights?departure_id=ORD&arrival_id=LAX&outbound_date=2026-10-15`
- **Look up local businesses / places on a map** → `GET https://marketplaceforaiagents.com/api/public/v1/google-maps?q=coffee+in+Austin`
- **Find academic papers and citations** → `GET https://marketplaceforaiagents.com/api/public/v1/google-scholar?q=large+language+model+agents`
- **Look up iOS apps on the Apple App Store** → `GET https://marketplaceforaiagents.com/api/public/v1/apple-app-store?q=Case+Law+Search`
- **Look up Android apps on Google Play** → `GET https://marketplaceforaiagents.com/api/public/v1/google-play?q=budget+tracker`
- **Find job postings** → `GET https://marketplaceforaiagents.com/api/public/v1/google-jobs?q=react+engineer+remote`
- **Search hotels for a stay** → `GET https://marketplaceforaiagents.com/api/public/v1/google-hotels?q=hotels+in+Lisbon`
- **Get stock or ticker data** → `GET https://marketplaceforaiagents.com/api/public/v1/google-finance?q=NVDA`
- **Search images** → `GET https://marketplaceforaiagents.com/api/public/v1/google-images?q=solar+panel+diagram`

## Machine entrypoints

- `https://marketplaceforaiagents.com/.well-known/x402` — discovery manifest
- `https://marketplaceforaiagents.com/.well-known/ai-plugin.json` — agent plugin manifest
- `https://marketplaceforaiagents.com/api/public/v1/openapi.json` — OpenAPI 3.1
- `https://marketplaceforaiagents.com/api/public/v1/catalog.json` — full catalog as JSON
- `https://marketplaceforaiagents.com/mcp` — MCP server (no auth)
- `https://marketplaceforaiagents.com/llms.txt` and `https://marketplaceforaiagents.com/llms-full.txt`
- `https://marketplaceforaiagents.com/agent/` — Markdown twin of every page

## Catalog

### video

- `youtube-transcripts` — Give a YouTube video ID or URL, get an array of {text, start, duration} caption segments. (https://marketplaceforaiagents.com/agent/listings/youtube-transcripts.md)
- `youtube-video` — Give a video ID, get title, channel, view/like counts, publish date, and description text. (https://marketplaceforaiagents.com/agent/listings/youtube-video.md)
- `youtube-search` — Give a query, get ranked YouTube videos with IDs you can feed into the transcripts endpoint. (https://marketplaceforaiagents.com/agent/listings/youtube-search.md)
- `google-videos` — Give a query, get cross-platform video results with source URLs. (https://marketplaceforaiagents.com/agent/listings/google-videos.md)
- `bing-videos` — Give a query, get video results across publishers with durations. (https://marketplaceforaiagents.com/agent/listings/bing-videos.md)

### web search

- `google-search` — Give a query, get ranked organic results with title, link, snippet, plus knowledge graph and related searches. (https://marketplaceforaiagents.com/agent/listings/google-search.md)
- `bing-search` — Give a query, get Bing organic results — a second opinion against Google rankings. (https://marketplaceforaiagents.com/agent/listings/bing-search.md)
- `duckduckgo-search` — Give a query, get DuckDuckGo organic results with title, link, and snippet. (https://marketplaceforaiagents.com/agent/listings/duckduckgo-search.md)
- `yandex-search` — Give a query, get Yandex organic results for regional coverage. (https://marketplaceforaiagents.com/agent/listings/yandex-search.md)
- `baidu-search` — Give a query, get Baidu organic results for China-market coverage. (https://marketplaceforaiagents.com/agent/listings/baidu-search.md)
- `naver-search` — Give a query, get Naver results across web, blog, and news verticals. (https://marketplaceforaiagents.com/agent/listings/naver-search.md)
- `yahoo-search` — Give a query, get Yahoo organic results. (https://marketplaceforaiagents.com/agent/listings/yahoo-search.md)

### news

- `google-news` — Give a query, get recent news items with source, date, and article URL. (https://marketplaceforaiagents.com/agent/listings/google-news.md)
- `bing-news` — Give a query, get Bing news items with source and publish time. (https://marketplaceforaiagents.com/agent/listings/bing-news.md)

### images

- `google-images` — Give a query, get image URLs plus the page each image came from. (https://marketplaceforaiagents.com/agent/listings/google-images.md)
- `google-lens` — Give an image URL, get visual matches with titles, links, and prices where available. (https://marketplaceforaiagents.com/agent/listings/google-lens.md)
- `google-reverse-image` — Give an image URL, get exact matches (pages hosting that image) and visual matches. (https://marketplaceforaiagents.com/agent/listings/google-reverse-image.md)
- `bing-images` — Give a query, get Bing image results with original URLs. (https://marketplaceforaiagents.com/agent/listings/bing-images.md)

### commerce

- `google-shopping` — Give a product query, get offers with price, merchant, rating, and product link. (https://marketplaceforaiagents.com/agent/listings/google-shopping.md)
- `amazon-search` — Give a product query, get Amazon listings with ASIN, price, and rating. (https://marketplaceforaiagents.com/agent/listings/amazon-search.md)
- `amazon-product` — Give an ASIN, get the full product record including price, features, and images. (https://marketplaceforaiagents.com/agent/listings/amazon-product.md)
- `amazon-reviews` — Give an ASIN, get review objects for sentiment and defect analysis. (https://marketplaceforaiagents.com/agent/listings/amazon-reviews.md)
- `walmart-search` — Give a query, get Walmart listings with price and product IDs. (https://marketplaceforaiagents.com/agent/listings/walmart-search.md)
- `ebay-search` — Give a query, get eBay listings including auction state and condition. (https://marketplaceforaiagents.com/agent/listings/ebay-search.md)

### places

- `google-maps` — Give a place query (optionally with lat/lng), get businesses with address, rating, and place IDs. (https://marketplaceforaiagents.com/agent/listings/google-maps.md)
- `google-maps-reviews` — Give a place_id, get review objects with rating and text for sentiment analysis. (https://marketplaceforaiagents.com/agent/listings/google-maps-reviews.md)
- `google-events` — Give an event query and a required location, get events with dates, venues, and ticket URLs. (https://marketplaceforaiagents.com/agent/listings/google-events.md)

### trends

- `google-trends` — Give one or more keywords, get a time series of relative interest plus related rising queries. (https://marketplaceforaiagents.com/agent/listings/google-trends.md)
- `google-autocomplete` — Give a seed query, get the suggestion list Google would show. (https://marketplaceforaiagents.com/agent/listings/google-autocomplete.md)

### academic

- `google-scholar` — Give a query, get scholarly results with citation counts and resource links. (https://marketplaceforaiagents.com/agent/listings/google-scholar.md)
- `google-scholar-author` — Give an author_id, get their articles, h-index, and citation history. (https://marketplaceforaiagents.com/agent/listings/google-scholar-author.md)
- `google-patents` — Give a query, get patents with assignee, dates, and abstract text. (https://marketplaceforaiagents.com/agent/listings/google-patents.md)

### jobs

- `google-jobs` — Give a role query and location, get job postings with apply URLs and job IDs. (https://marketplaceforaiagents.com/agent/listings/google-jobs.md)

### finance

- `google-finance` — Give a ticker like NASDAQ:AAPL, get current price, movement, and key financial stats. (https://marketplaceforaiagents.com/agent/listings/google-finance.md)

### travel

- `google-flights` — Give origin, destination, and dates, get priced itineraries with legs and durations. (https://marketplaceforaiagents.com/agent/listings/google-flights.md)
- `google-hotels` — Give a destination and date range, get properties with rates and ratings. (https://marketplaceforaiagents.com/agent/listings/google-hotels.md)

### app stores

- `google-play` — Give a query, get Play Store apps with package IDs, ratings, and pricing. (https://marketplaceforaiagents.com/agent/listings/google-play.md)
- `apple-app-store` — Give a query, get iOS apps with developer, rating, and app IDs. (https://marketplaceforaiagents.com/agent/listings/apple-app-store.md)

### intents

- `serp-stack` — Give a query, get Google + Bing + DuckDuckGo organic results in one response. (https://marketplaceforaiagents.com/agent/listings/serp-stack.md)
- `news-brief` — Give a topic, get Google News + Bing News articles in one response. (https://marketplaceforaiagents.com/agent/listings/news-brief.md)
- `brand-pulse` — Give a brand or ticker, get web results, news, and the finance quote together. (https://marketplaceforaiagents.com/agent/listings/brand-pulse.md)
- `deal-triage` — Give a product query (or ASIN), get shopping offers, the Amazon listing, and reviews. (https://marketplaceforaiagents.com/agent/listings/deal-triage.md)
- `cross-store-price` — Give a product query, get offers from Google Shopping, Amazon, eBay and Walmart. (https://marketplaceforaiagents.com/agent/listings/cross-store-price.md)
- `review-risk` — Give an ASIN, get the Amazon product record and its reviews together. (https://marketplaceforaiagents.com/agent/listings/review-risk.md)
- `aso-dual` — Give an app query, get Google Play and Apple App Store results together. (https://marketplaceforaiagents.com/agent/listings/aso-dual.md)
- `place-dossier` — Give a place query, get the matching business record plus its reviews. (https://marketplaceforaiagents.com/agent/listings/place-dossier.md)
- `trip-skeleton` — Give route and dates, get flights and hotels (and events when location is set). (https://marketplaceforaiagents.com/agent/listings/trip-skeleton.md)
- `video-digest` — Give a topic (or video_id), get the top video's metadata and full transcript. (https://marketplaceforaiagents.com/agent/listings/video-digest.md)
- `trend-then-serp` — Give a keyword, get its trend series and the current Google results. (https://marketplaceforaiagents.com/agent/listings/trend-then-serp.md)
- `image-provenance` — Give an image URL, get visual matches and pages hosting the exact image. (https://marketplaceforaiagents.com/agent/listings/image-provenance.md)
- `scholar-pack` — Give a research query (and optionally an author_id), get papers and that author's record. (https://marketplaceforaiagents.com/agent/listings/scholar-pack.md)


---

# Integration docs

## 0. If your agent was asked to find X

You were told to "get a YouTube transcript", "search the web", "check flight prices", "look up a product". Cold start:

1. `GET https://marketplaceforaiagents.com/api/public/v1/catalog.json` — every endpoint, params, and result key in one JSON fetch.
2. Or connect the MCP server at `https://marketplaceforaiagents.com/mcp` (no auth) and call `list_apis`.
3. Call the endpoint with no payment header — the first 3 calls per identity are free.
4. When the free tier is gone the same call returns 402 with exact x402 payment requirements.

## 1. Discover

```bash
curl -s https://marketplaceforaiagents.com/.well-known/x402
curl -s https://marketplaceforaiagents.com/api/public/v1/catalog.json
```

## 2. Call unpaid (free tier)

```bash
curl -s "https://marketplaceforaiagents.com/api/public/v1/google-search?q=x402+protocol"
```

Identity is a hash of IP + User-Agent. 3 free calls per identity in total across all endpoints (not per endpoint). Successful free-tier responses carry an `X-Free-Calls-Remaining` header.

Who gets free calls:

- Recognised agent runtimes (Claude, GPT, Grok, Gemini, LangChain, MCP, Cursor, x402-fetch, and similar User-Agents): 3 free calls per identity, no shared budget.
- Unknown/generic clients: 3 free calls per identity, drawn from a site-wide budget of 100 successful free calls per UTC day. When that budget is spent, unpaid calls return `402` with `error: free_tier_global_exhausted`.
- Crawlers, health checks, monitoring tools and browsers: no free calls — always `402` with full payment requirements.

## 3. Handle 402

```json
{
  "x402Version": 1,
  "error": "payment_required",
  "accepts": [
    {
      "scheme": "exact",
      "network": "base",
      "maxAmountRequired": "5000",
      "asset": "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
      "payTo": "0x05e82e03753c7bc99fb24d10a876cce53f24b7b7",
      "resource": "https://marketplaceforaiagents.com/api/public/v1/{slug}"
    }
  ]
}
```

## 4. Pay and retry

```ts
import { wrapFetchWithPayment } from "x402-fetch";
import { createWalletClient, http } from "viem";
import { privateKeyToAccount } from "viem/accounts";
import { base } from "viem/chains";

const account = privateKeyToAccount(process.env.AGENT_PRIVATE_KEY as `0x${string}`);
const wallet = createWalletClient({ account, chain: base, transport: http() });
const pay = wrapFetchWithPayment(fetch, wallet);

const res = await pay("https://marketplaceforaiagents.com/api/public/v1/google-news?q=base+usdc");
const data = await res.json();
```

## 5. Sandbox

Add `network=base-sepolia` to any endpoint. It requires testnet USDC (`0x036CbD53842c5426634e7929541eC2318f3dCF7e`) and returns mock data in the documented shape, so integration tests cost nothing real.

## Errors

- `400 missing_required_parameters` — body lists the missing names.
- `402 payment_required` — body carries `accepts`.
- `404 unknown_endpoint` — re-read `/.well-known/x402`.
- `502 upstream_error` — upstream provider failed; the call is not charged.

Canonical HTML: https://marketplaceforaiagents.com/docs


---

# The x402 protocol, explained

x402 turns HTTP 402 Payment Required into a working settlement layer for autonomous agents. Here is the handshake, the EIP-3009 USDC authorization, and why it is the wire format for agentic commerce.

HTTP 402 Payment Required has been a reserved status code since 1997. For nearly thirty years it sat unused — there was no agreed-upon way for a server to say what payment it wanted, and no agreed-upon way for a client to pay. x402 fills that gap. It is a tiny open spec that turns 402 into a real handshake, designed for the case where the client is not a human with a credit card but an autonomous AI agent acting on a budget.

The whole protocol is two HTTP round trips, a base64-encoded payload, and an on-chain settlement. There is no account, no API key, no Stripe Checkout iframe. An agent can discover a priced endpoint, pay for it, and consume the response in under a second.

## The handshake in one diagram

The first call is unauthenticated. The server responds with 402 and a machine-readable accepts payload describing what it will take.

```http
GET /api/public/v1/{endpoint}?{params} HTTP/1.1

→ HTTP/1.1 402 Payment Required
   Content-Type: application/json

   {
     "x402Version": 1,
     "error": "payment_required",
     "accepts": [{
       "scheme": "exact",
       "network": "base",
       "asset": "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
       "maxAmountRequired": "5000",
       "payTo": "0x05e8...b7b7",
       "resource": "https://marketplaceforaiagents.com/api/public/v1/{endpoint}",
       "extra": { "name": "USDC", "version": "2" }
     }]
   }
```

The agent picks an accepts entry it can satisfy, signs an EIP-3009 transferWithAuthorization on the USDC contract, base64-encodes the signed payload, and resends the request with an X-PAYMENT header.

```http
GET /api/public/v1/youtube-transcripts?video_id=abc123 HTTP/1.1
X-PAYMENT: eyJ4NDAyVmVyc2lvbiI6MSwic2NoZW1lIjoiZXhhY3QiLCJuZXR3b3JrIjoiYmFzZSIsLi4u

→ HTTP/1.1 200 OK
   X-PAYMENT-RESPONSE: eyJzdWNjZXNzIjp0cnVlLCJ0cmFuc2FjdGlvbiI6IjB4Li4uIn0=
   Content-Type: application/json

   { "video_id": "abc123", "lang": "en", "transcripts": [...] }
```

The X-PAYMENT-RESPONSE header is a base64 receipt the agent stores for its own ledger. The transaction hash links back to a real on-chain transfer on Base.

## Why EIP-3009 instead of a regular ERC-20 transfer

EIP-3009 is the part that makes the whole thing work in a single HTTP request. A normal ERC-20 transfer would require the agent to broadcast a transaction itself, wait for confirmation, and only then call the API. EIP-3009 introduces transferWithAuthorization: the holder signs a typed message off-chain, and any third party can submit it on-chain on their behalf.

In x402 the third party is a facilitator — a service the API operator trusts to verify the signature, broadcast the transfer, and report back. The agent never touches gas. The facilitator pays the gas in ETH on Base, then collects the USDC. Because Base settlement is sub-second and gas is fractions of a cent, the whole flow feels like a normal HTTP call.

## Discovery: /.well-known/x402

An x402 server publishes a manifest at /.well-known/x402 listing its endpoints, prices, networks, and OpenAPI spec. Agents — and agent API marketplace crawlers — read this file to auto-generate tools.

```json
{
  "name": "Marketplace for AI Agents",
  "networks": ["base", "base-sepolia"],
  "endpoints": [
    { "id": "youtube-transcripts", "url": "https://.../api/public/v1/youtube-transcripts" },
    { "id": "google-search", "url": "https://.../api/public/v1/google-search" },
    { "id": "google-shopping", "url": "https://.../api/public/v1/google-shopping" }
  ],
  "prices": [
    { "network": "base", "asset": "0x8335...", "amountAtomic": "5000" }
  ]
}
```

Pair this with an OpenAPI 3.1 spec and an agent framework can wire your endpoint into a tool call automatically, including the X-PAYMENT header logic.

## Where x402 fits in the agentic commerce stack

x402 is the settlement layer. Above it you have agent runtimes (LangChain, the Vercel AI SDK, MCP servers) that decide when to spend. Below it you have the chain (Base mainnet today, others later) that finalizes the transfer. The protocol itself is intentionally thin — it does not specify what kind of agent is calling, what business logic the API runs, or how the operator reports revenue. That is the point. It is the HTTP 402 of the agent economy: a small interoperable primitive that lets the rest of the stack assume payment just works.

Canonical HTML: https://marketplaceforaiagents.com/learn/x402-protocol-explained

---

# How to build an agent-payable API

A step-by-step guide to wrapping any HTTP endpoint with x402: pricing, the 402 response, verification, settlement, free tiers, and listing it in an agent API marketplace so autonomous agents can discover and pay for it.

If you already have a working HTTP endpoint — a transcript service, a screenshot API, a niche dataset lookup — you are 80% of the way to a machine-payable API. The remaining 20% is wiring x402 in front of it so autonomous agents can pay per call without anyone in your team provisioning an account first.

This guide walks through the full path: pricing the endpoint, returning a 402, verifying and settling the payment, adding a free tier for evaluation, and listing the result in an agent API marketplace.

## 1. Pick a price and a network

Per-call pricing is the unit of account in agentic commerce. Aim for the smallest amount an agent would happily spend without a budget check — typically between $0.001 and $0.05 per call for content APIs.

USDC on Base mainnet is the default network today: cheap gas, sub-second finality, and the x402 ecosystem has the most facilitator support there. USDC has 6 decimals, so $0.005 is the atomic string "5000".

## 2. Return a 402 when there is no X-PAYMENT

Your handler reads the X-PAYMENT header. If it is absent, you respond 402 with an accepts array describing exactly what payment you will take. The shape is identical across providers — that is what makes the protocol useful.

```ts
const requirements = {
  scheme: "exact",
  network: "base",
  maxAmountRequired: "5000", // $0.005 USDC, 6 decimals
  resource: `${origin}/api/transcripts`,
  asset: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913", // USDC on Base
  payTo: "0xYourMerchantAddress",
  maxTimeoutSeconds: 60,
  extra: { name: "USDC", version: "2" },
};

if (!request.headers.get("x-payment")) {
  return Response.json(
    { x402Version: 1, error: "payment_required", accepts: [requirements] },
    { status: 402 },
  );
}
```

## 3. Verify and settle with a facilitator

You don't broadcast the transfer yourself. You hand the decoded payment to a facilitator — typically the default x402 facilitator or one you trust — which verifies the EIP-3009 signature and submits the on-chain transfer.

```ts
import { useFacilitator } from "x402/verify";
import { decodePayment } from "x402/schemes";

const decoded = decodePayment(request.headers.get("x-payment")!);
const facilitator = useFacilitator(); // or useFacilitator({ url: TESTNET_URL })

const verify = await facilitator.verify(decoded, requirements);
if (!verify.isValid) return reply402(verify.invalidReason);

const settle = await facilitator.settle(decoded, requirements);
if (!settle.success) return reply402(settle.errorReason);

// Settled. settle.transaction is the on-chain tx hash.
```

Return your real response with an X-PAYMENT-RESPONSE header carrying the base64-encoded receipt. Agents log this for their own bookkeeping.

## 4. Add a free tier (optional but powerful)

A free tier lets agents try the endpoint before committing budget. The simplest pattern is N free calls per identity hash (IP + user-agent SHA-256) stored in a table. Once exhausted, the next call returns 402 and the paid path takes over.

Keep the free tier small — three to ten calls is plenty. Its job is evaluation, not subsidy.

## 5. Publish discovery files

Two files turn your endpoint into something an agent can find and use without human help:

- /.well-known/x402 — the manifest. Networks, assets, endpoints, prices, and a link to your OpenAPI spec.
- /openapi.json — a normal OpenAPI 3.1 spec with one extra section: x-x402 at the root describing payTo, asset, and network so an agent can configure payment from the spec alone.

Agent runtimes and any agent API marketplace crawler can consume both files and auto-generate a tool. This is the whole reason to bother with x402 instead of inventing your own scheme.

## 6. List it in an agent API marketplace

Once your manifest is live, submit it to an agent API marketplace so agents discover it during planning, not after a failed call. A good marketplace will crawl your /.well-known/x402, validate that your 402 responses match the manifest, and surface the endpoint in agent-facing search.

From there your endpoint behaves like any other machine-payable API: revenue accrues on every call, no invoicing, no rate-limit emails, no Stripe disputes.

Canonical HTML: https://marketplaceforaiagents.com/learn/build-agent-payable-api

---

# Machine-payable APIs vs. traditional API billing

API keys, monthly invoices, and Stripe Checkout were designed for humans. Here is a head-to-head comparison with per-call x402 settlement, and when each model still wins.

Every API billing model in production today assumes a human will sit down, create an account, paste a credit card, and then hand an API key to a developer. That worked when the buyer and the integrator were both human. It breaks the moment an autonomous agent is the buyer.

Machine-payable APIs, built on x402, settle payment inside the HTTP request itself. No signup, no key rotation, no monthly invoice — just USDC on Base, per call, with an on-chain receipt. Below is how the two models actually compare on the dimensions that matter for agentic commerce.

## Head-to-head

| Dimension | Traditional (API keys + Stripe) | Machine-payable (x402) |
| --- | --- | --- |
| Onboarding | Email, account, billing setup, key issuance — minutes to days. | Zero. First request returns 402 with what it costs. |
| Buyer | Human with a credit card or PO. | Any agent holding USDC on Base. |
| Unit of billing | Monthly tier or post-paid usage rollup. | Per HTTP call, settled before the response. |
| Revenue latency | Days to weeks (invoicing, dunning, chargebacks). | Sub-second on Base, no chargebacks. |
| Failure mode | Card decline at month-end blocks the next batch. | 402 returned in real time; agent picks another provider. |
| Discovery | Sales calls, blog posts, hand-curated lists. | /.well-known/x402 + OpenAPI, indexed by agent API marketplace crawlers. |
| Auth | Long-lived bearer key — must be rotated, scoped, leaked-and-revoked. | Per-call signed authorization. Nothing long-lived to leak. |
| Refunds | Manual support ticket. | Don't charge if the call fails; no settle, no refund needed. |

## Where traditional billing still wins

Machine-payable is not a strict upgrade. A few patterns still belong on API keys and monthly invoices:

- Enterprise contracts with negotiated SLAs and procurement cycles. The buyer wants an invoice, not an on-chain ledger.
- Very high call volume per customer where a flat tier is genuinely cheaper than per-call pricing.
- Compliance-heavy verticals that require KYC on the API consumer before any data leaves the server.

For everything else — and especially anything an agent might call autonomously — the friction of issuing keys and reconciling invoices is now larger than the friction of just settling on-chain.

## The economic shift

The deeper change isn't technical. It's that per-call settlement turns APIs into something an agent can shop for at runtime. When the buyer is an agent, the supplier with the lowest price and the cleanest 402 wins, every call. That is what agentic commerce looks like in practice — a market where pricing, discovery, and settlement all live inside the protocol, not inside a sales motion.

If you operate an API today, the question is whether the next million calls to it will come from humans or from agents. If it's agents, you want to be priced and discoverable on day one — not retrofit billing after the traffic shows up.

Canonical HTML: https://marketplaceforaiagents.com/learn/machine-payable-vs-traditional-billing

---

# How AI agents discover machine-payable APIs

Autonomous agents do not browse marketing sites. Here is the discovery stack — llms.txt, /.well-known/x402, OpenAPI, MCP, and Markdown twins — that lets an agent find, price-check, and call a machine-payable API without a human in the loop.

Agents discover APIs by reading machine entrypoints, not HTML. They do not click landing pages, watch demos, or fill contact forms. They need deterministic manifests they can parse, validate, and turn into tool calls.

The shortest path through this marketplace is: read https://marketplaceforaiagents.com/llms.txt or https://marketplaceforaiagents.com/.well-known/x402, pick a slug from the catalog, call GET /api/public/v1/{slug}, use the first 3 free calls per identity, then follow the x402 402 handshake when the free tier is exhausted.

## Why HTML is the wrong surface for agents

Humans need landing pages. They want a headline, a feature grid, and a call to action. Agents need a contract: what does this endpoint expect, what does it return, and what does it cost. HTML is a lossy medium for that contract.

This site still has human mirrors — /marketplace for browsing and /docs for prose — but those pages are secondary outputs. The primary source of truth is the machine-readable layer: /.well-known/x402, /api/public/v1/catalog.json, and /api/public/v1/openapi.json. Build your agent against those, and use /marketplace only when you want a human-readable sanity check.

## The cold-start path

An agent that has never visited this domain can bootstrap itself in a single ordered pass:

- GET https://marketplaceforaiagents.com/robots.txt — confirm which paths are crawlable.
- GET https://marketplaceforaiagents.com/llms.txt — the concise discovery index; use llms-full.txt for offline ingest.
- GET https://marketplaceforaiagents.com/.well-known/x402 — the x402 manifest: endpoints, prices, networks, assets.
- GET https://marketplaceforaiagents.com/.well-known/ai-plugin.json — OpenAI-style plugin manifest with OpenAPI link.
- GET https://marketplaceforaiagents.com/api/public/v1/catalog.json — the full catalog; the short path /catalog.json redirects here.
- GET https://marketplaceforaiagents.com/api/public/v1/openapi.json — OpenAPI 3.1 spec with x-x402 payment metadata.
- Connect MCP at https://marketplaceforaiagents.com/mcp — live tool discovery and invocation.
- Prefer Markdown twins under https://marketplaceforaiagents.com/agent/ for long-form docs in agent-readable plain text.

None of these steps require authentication. The free tier is anonymous and tied to a hashed identity derived from IP + User-Agent.

## What each entrypoint is for

| Entrypoint | Content-Type | Use when |
| --- | --- | --- |
| /robots.txt | text/plain | Crawler wants to know allowed paths. |
| /llms.txt | text/plain | Agent needs a quick index of docs and endpoints. |
| /llms-full.txt | text/plain | Agent wants the entire site in one plain-text file for offline context. |
| /.well-known/x402 | application/json | Agent needs prices, networks, and endpoint URLs. |
| /.well-known/ai-plugin.json | application/json | OpenAI-style runtime needs plugin metadata. |
| /api/public/v1/catalog.json | application/json | Agent wants structured catalog with params and use cases. |
| /api/public/v1/openapi.json | application/json | Agent wants full OpenAPI 3.1 with payment extensions. |
| /mcp | MCP protocol | Agent wants live tool listing and invocation. |
| /agent/{path}.md | text/markdown | Agent wants a Markdown twin of a human page. |

## From discovery to a paid call

Start with the catalog to find a slug and its required parameters:

```bash
curl -s "https://marketplaceforaiagents.com/api/public/v1/catalog.json" |   jq '.apis[] | {slug, name, category, pricePerCallUsd}'
```

Then call the endpoint. The first 3 calls per identity are free and return X-Free-Calls-Remaining. After that you get a 402 with an accepts array:

```bash
curl -s "https://marketplaceforaiagents.com/api/public/v1/youtube-transcripts?video_id=dQw4w9WgXcQ" -v

# Response headers include:
# X-Free-Calls-Remaining: 2

# After the free tier:
# HTTP/1.1 402 Payment Required
# { "x402Version": 1, "error": "payment_required", "accepts": [...] }
```

To test without spending real USDC, append ?network=base-sepolia. The sandbox returns deterministic mock data and uses the same x402 flow with testnet USDC. See /docs and /listings/google-search for per-endpoint details and example parameters.

## Agentic SEO: make your own API discoverable the same way

If you operate an API, you can make it agent-discoverable without rebuilding it:

- Publish /llms.txt with a plain-text index of your endpoints and payment terms.
- Publish /.well-known/x402 with networks, assets, prices, and endpoint URLs.
- Serve an OpenAPI 3.1 spec at /openapi.json with x-x402 metadata for payTo, asset, and network.
- Create Markdown twins for every human page under /agent/ so agents can read docs without parsing HTML.
- Keep result keys stable across versions; agents cache field paths.
- Do not burn free-tier quota on 400 validation errors; only count successful calls.
- Always include the price in the 402 accepts[] payload so agents can compare providers before signing.

Agentic SEO is just SEO for non-human clients. The crawlers are agent runtimes, not search engines, and they reward determinism over persuasion.

## Where marketplaceforaiagents.com fits

This marketplace hosts 38 live endpoints — search, news, images, commerce, maps, travel, jobs, academic, app stores, and video — all priced at $0.005 USDC per call on Base mainnet. There are no accounts, no API keys, and no monthly billing. Agents pay per call through x402.

Browse /marketplace for a human-readable catalog, or connect the MCP server at /mcp and call list_apis, get_api_spec, get_payment_requirements, get_agent_entrypoints, and get_integration_guide directly from your agent runtime.

Canonical HTML: https://marketplaceforaiagents.com/learn/how-ai-agents-discover-apis

---

# How AI agents budget x402 API calls

A practical agent-first guide to enforcing spend policy before signing an x402 payment: validating 402 accepts[], comparing network, asset, payee, and amount against an allowlist, and recording debits only from successful payment receipts.

Before an autonomous agent signs any x402 payment, it should price-check the HTTP 402 `accepts[]` payload, compare every field against an internal allowlist and a per-task spending cap, and only sign when scheme, network, asset, payee, and amount all pass.

This article shows a concrete policy object and decision algorithm you can run inside an agent runtime before it attaches an `X-PAYMENT` header to a request. The examples use this marketplace, but the same logic applies to any x402 endpoint your agent might call.

This marketplace offers a global free tier of 3 successful calls total across all endpoints per IP + User-Agent identity. Successful free responses include an `X-Free-Calls-Remaining` header, but production budgeting must not rely on those calls being available; always plan for the paid path after the first request.

## What the 402 challenge tells you

When the free tier is exhausted, an unpaid request to this marketplace returns HTTP 402 with a machine-readable `accepts[]` array. Each entry is a contract: sign this exactly, or do not sign at all.

| Field | Verified production value | Why it matters for budget |
| --- | --- | --- |
| scheme | exact | Only exact-scheme pricing is accepted; no auctions or ranges. |
| network | base | Mainnet settlement on Base. Sepolia is only for sandbox testing. |
| asset | 0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913 | USDC contract on Base mainnet. |
| payTo | 0x05e82e03753c7bc99fb24d10a876cce53f24b7b7 | The only approved merchant address. |
| maxAmountRequired | 5000 | Atomic USDC units; equals $0.005 per call. |
| resource | https://marketplaceforaiagents.com/api/public/v1/{slug} | Scope the signed authorization to this endpoint. |

Agents should never trust a hard-coded price. Always read the live requirement from `https://marketplaceforaiagents.com/.well-known/x402` or the 402 response itself before signing.

## Build an allowlist policy object

Store policy as integer atomic units, never floating-point dollars. A task budget is a reservation, not a guaranteed debit, because a failed upstream call should not cost the agent anything.

```ts
const POLICY = {
  // Only these settlement terms are permitted.
  allowedSchemes: new Set(["exact"]),
  allowedNetworks: new Set(["base"]),
  allowedAssets: new Set([
    "0x833589fcd6edb6e08f4c7c32d4f71b54bda02913", // Base USDC mainnet (lowercase)
  ]),
  allowedPayees: new Set([
    "0x05e82e03753c7bc99fb24d10a876cce53f24b7b7", // lowercase
  ]),

  // Per-task cap in atomic USDC units (1 USDC = 1_000_000n).
  taskBudgetAtomic: 50_000n, // $0.05 total for this task
  maxPerCallAtomic: 5_000n,  // $0.005 per call
  maxCallsPerTask: 10,

  // Track committed reservations and confirmed debits separately.
  reservedAtomic: 0n,
  spentAtomic: 0n,
};
```

The policy also separates `reservedAtomic` from `spentAtomic`. A reservation is the amount you set aside when you plan to make a call; `spentAtomic` is updated only after a successful `X-PAYMENT-RESPONSE` receipt is decoded.

## The budget algorithm before signing

Run this check on every `accepts[]` entry before producing an EIP-3009 signature. If any check fails, stop and surface a clear reason to the agent's planner.

```ts
function canAffordCall(policy, acceptsEntry, plannedCalls = 1) {
  const {
    scheme, network, asset, payTo, maxAmountRequired,
  } = acceptsEntry;

  const amount = BigInt(maxAmountRequired);

  // 1. Structural validation
  if (!policy.allowedSchemes.has(scheme)) return { ok: false, reason: "scheme_not_allowed" };
  if (!policy.allowedNetworks.has(network)) return { ok: false, reason: "network_not_allowed" };
  if (!policy.allowedAssets.has(asset.toLowerCase())) return { ok: false, reason: "asset_not_allowed" };
  if (!policy.allowedPayees.has(payTo.toLowerCase())) return { ok: false, reason: "payee_not_allowed" };

  // 2. Amount validation (integer atomic units only)
  if (amount <= 0n) return { ok: false, reason: "amount_non_positive" };
  if (amount > policy.maxPerCallAtomic) return { ok: false, reason: "per_call_over_cap" };

  // 3. Budget reservation (estimate, not a debit)
  const projectedSpend = policy.spentAtomic + (amount * BigInt(plannedCalls));
  if (projectedSpend > policy.taskBudgetAtomic) {
    return { ok: false, reason: "task_budget_exceeded" };
  }
  if (plannedCalls > policy.maxCallsPerTask) {
    return { ok: false, reason: "call_count_over_cap" };
  }

  return { ok: true, amountAtomic: amount };
}
```

This function returns the atomic amount only when every guard passes. The agent then reserves that amount, signs the authorization, attaches it as `X-PAYMENT`, and waits for the receipt before marking the spend as real.

## When to stop and fall back

A disciplined agent treats the 402 as untrusted input. Any deviation from policy is a stop condition. Here is the decision matrix an agent runtime should implement.

| Situation | Decision | Fallback action |
| --- | --- | --- |
| 402 has no accepts[] | Stop | Log malformed response; try another provider. |
| accepts[] has multiple entries | Evaluate each | Choose the first entry that matches the policy; stop if none match. |
| maxAmountRequired > per-call cap | Stop | Reject; do not sign a larger amount. |
| network/asset/payee mismatch | Stop | Do not sign; report policy violation. |
| scheme is not exact | Stop | Only exact pricing is supported here. |
| Upstream returns 5xx after payment | Hold reservation | Reconcile the receipt or on-chain transaction before recording or releasing it. |
| No X-PAYMENT-RESPONSE header | Hold reservation | Treat as unsettled; do not record spend or release the reservation. |
| Receipt decodes but tx status is unknown | Hold (optional agent policy) | Agent may apply its own confirmation rule before debiting or releasing. |

The key rule: a charge is only recorded when a successful paid response provides a base64 `X-PAYMENT-RESPONSE` that decodes to a transaction hash, network, and payer address. Until then, the amount remains a reservation.

## Recording actual debits from receipts

After the agent sends `X-PAYMENT`, a successful response carries `X-PAYMENT-RESPONSE`. Decode it, extract the transaction hash, and only then move the reserved amount into `spentAtomic`.

```ts
async function recordPaidCall(policy, response, expectedAmountAtomic) {
  const receiptHeader = response.headers.get("X-PAYMENT-RESPONSE");
  if (!receiptHeader) {
    return { settled: false, reason: "missing_receipt" };
  }

  const receipt = JSON.parse(atob(receiptHeader));
  if (!receipt.transaction || !receipt.network) {
    return { settled: false, reason: "incomplete_receipt" };
  }

  policy.spentAtomic += expectedAmountAtomic;
  const newReserved = policy.reservedAtomic - expectedAmountAtomic;
  policy.reservedAtomic = newReserved > 0n ? newReserved : 0n;

  return {
    settled: true,
    transaction: receipt.transaction,
    network: receipt.network,
    payer: receipt.payer,
    amountAtomic: expectedAmountAtomic,
  };
}
```

If the response is ambiguous — for example, a 5xx, a missing receipt, or a decoded receipt whose transaction status you cannot confirm — hold the reservation and reconcile the receipt or on-chain transaction before recording a debit or releasing the funds. Do not assume a failed HTTP response means no charge occurred, and do not assume an unconfirmed transaction is final unless your own policy defines that threshold.

## Test the policy in Base Sepolia sandbox

Use the sandbox to exercise the budget algorithm without spending real USDC. Append `?network=base-sepolia` to any endpoint. The sandbox uses testnet USDC at `0x036CbD53842c5426634e7929541eC2318f3dCF7e` and returns mock data in the documented shape.

```bash
# 1. Discover current prices and endpoints
curl -s https://marketplaceforaiagents.com/.well-known/x402

# 2. Exhaust the free tier or skip straight to the paid path
curl -s "https://marketplaceforaiagents.com/api/public/v1/google-search?q=x402+protocol&network=base-sepolia" -v

# 3. When you see HTTP/1.1 402, inspect accepts[] and run your policy checks
# 4. Sign against testnet USDC, attach X-PAYMENT, and verify the mock receipt
```

In sandbox mode the 402 still returns `accepts[]`, but the amount is the same $0.005 in testnet USDC. This lets you validate your allowlist, budget algorithm, and receipt decoding before touching mainnet.

## Where this marketplace fits

This marketplace hosts 38 live endpoints — search, news, images, commerce, maps, travel, jobs, academic, app stores, and video — all priced at $0.005 USDC per call on Base mainnet. There are no accounts, no API keys, and no monthly billing. Agents pay per call through x402.

- Browse human-readable listings at https://marketplaceforaiagents.com/marketplace
- Read the full discovery index at https://marketplaceforaiagents.com/llms.txt
- Read prose docs at https://marketplaceforaiagents.com/docs and the Markdown twin at https://marketplaceforaiagents.com/agent/docs.md
- Fetch the live catalog at https://marketplaceforaiagents.com/api/public/v1/catalog.json or the short path https://marketplaceforaiagents.com/catalog.json
- Inspect the OpenAPI spec at https://marketplaceforaiagents.com/api/public/v1/openapi.json
- See a concrete listing at https://marketplaceforaiagents.com/listings/google-search

Every agent should read live discovery before each task. Prices are uniform today, but hard-coding them is a future bug. Let the 402 response and `/.well-known/x402` be the source of truth, and let your policy object be the guardrail.

Canonical HTML: https://marketplaceforaiagents.com/learn/budget-x402-api-calls

---

# Connect MCP to an x402 API marketplace

How an AI agent uses the Model Context Protocol to discover machine-payable APIs, read live x402 payment requirements, and call endpoints that settle in USDC on Base — without accounts or API keys.

Connect your agent runtime to https://marketplaceforaiagents.com/mcp (no auth). Call list_apis to browse, get_payment_requirements to read the live x402 accepts payload, then GET /api/public/v1/{slug} — use the first 3 free calls, then attach X-PAYMENT with a signed USDC authorization when you get HTTP 402.

MCP gives the agent a tool surface. x402 gives it a payment surface. Together they let an autonomous agent discover, price-check, and pay for APIs without a human pasting keys into a dashboard.

## Why MCP and x402 belong together

MCP (Model Context Protocol) standardizes how an agent lists and invokes tools. It does not define how those tools get paid for. x402 standardizes HTTP 402 Payment Required settlement. It does not define how an agent finds tools. An agent API marketplace that speaks both closes the loop:

- MCP tools describe what exists and how to call it.
- /.well-known/x402 and get_payment_requirements describe what it costs.
- The HTTP endpoint at /api/public/v1/{slug} is the paid resource.
- X-PAYMENT / X-PAYMENT-RESPONSE carry the EIP-3009 USDC settlement and receipt.

If your runtime already speaks MCP, you do not need a custom OpenAPI client just to browse this catalog. Use MCP for discovery and guidance; use plain HTTP (or an x402-aware fetch wrapper) for the paid call itself.

## Connect the public MCP server

The marketplace exposes a public MCP endpoint with no authentication:

```text
https://marketplaceforaiagents.com/mcp
```

Also useful for OpenAI-style plugin loaders:

```bash
curl -s https://marketplaceforaiagents.com/.well-known/ai-plugin.json
```

Once connected, the agent should see these tools:

| MCP tool | What it returns | When to call it |
| --- | --- | --- |
| list_apis | Browsable catalog of machine-payable endpoints | Cold start or when picking a capability |
| get_api_spec | Request/response schema + OpenAPI URL for one listing | Before first call to a slug |
| get_payment_requirements | Live x402 payment payload for a network | Before signing any X-PAYMENT |
| get_agent_entrypoints | Every machine manifest and Markdown twin URL | Bootstrapping a new agent identity |
| get_integration_guide | Markdown integration guides | When the planner needs prose steps |

## Recommended tool order for a new task

Keep MCP calls cheap and HTTP calls intentional. A stable order for most agent planners:

- get_agent_entrypoints — cache /.well-known/x402, /llms.txt, /api/public/v1/catalog.json, /api/public/v1/openapi.json, and /agent/ paths.
- list_apis — choose a slug that matches the task (e.g. google-search, youtube-transcripts, google-shopping).
- get_api_spec — confirm required query params and the results key.
- get_payment_requirements — pull scheme, network, asset, payTo, and maxAmountRequired for base or base-sepolia.
- HTTP GET the endpoint. Prefer free-tier evaluation first; only sign when policy allows.

```bash
# After MCP discovery, the paid resource is always plain HTTP:
curl -s "https://marketplaceforaiagents.com/api/public/v1/google-search?q=x402+mcp"

# Sandbox (testnet USDC + mock body):
curl -s "https://marketplaceforaiagents.com/api/public/v1/google-search?q=x402+mcp&network=base-sepolia"
```

## From MCP discovery to a paid call

MCP tools here are discovery and guidance tools. They do not settle payment for you. Settlement still happens on the HTTP resource:

```http
GET /api/public/v1/youtube-transcripts?video_id=dQw4w9WgXcQ HTTP/1.1
Host: marketplaceforaiagents.com

# First 3 successful calls per IP+User-Agent identity:
→ 200 OK
   X-Free-Calls-Remaining: 2

# After free tier:
→ 402 Payment Required
   { "x402Version": 1, "error": "payment_required", "accepts": [...] }

# Agent signs EIP-3009 USDC auth, base64-encodes the x402 payload:
GET /api/public/v1/youtube-transcripts?video_id=dQw4w9WgXcQ HTTP/1.1
X-PAYMENT: eyJ4NDAyVmVyc2lvbiI6MSwic2NoZW1lIjoiZXhhY3QiLC4uLn0=

→ 200 OK
   X-PAYMENT-RESPONSE: eyJzdWNjZXNzIjp0cnVlLCJ0cmFuc2FjdGlvbiI6IjB4Li4uIn0=
```

Cross-check get_payment_requirements against the live 402 accepts[] before signing. Never hard-code amount, asset, or payTo from training data — read them from MCP or from https://marketplaceforaiagents.com/.well-known/x402.

| Field | Production value to expect | Source of truth |
| --- | --- | --- |
| scheme | exact | 402 accepts[] / get_payment_requirements |
| network | base | same |
| asset | 0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913 | Base mainnet USDC |
| payTo | 0x05e82e03753c7bc99fb24d10a876cce53f24b7b7 | merchant address |
| maxAmountRequired | 5000 | $0.005 USDC (6 decimals) |

## Wire it into a typical agent runtime

Pattern that works across Cursor, Claude Desktop-style MCP clients, and custom runtimes:

- Register https://marketplaceforaiagents.com/mcp as an MCP server in the runtime config.
- Allowlist only the five marketplace tools above so the planner cannot invent tool names.
- Keep a separate payment module (wallet + x402-fetch or equivalent) outside MCP — signing keys should not live inside tool handlers that browse the catalog.
- Enforce a spend policy on accepts[] before the payment module signs (see /learn/budget-x402-api-calls).
- Log X-PAYMENT-RESPONSE transaction hashes to the agent's ledger, not just the JSON body.

```ts
// Pseudocode: MCP for discovery, HTTP+x402 for settlement
const apis = await mcp.call("list_apis");
const spec = await mcp.call("get_api_spec", { slug: "google-news" });
const payReq = await mcp.call("get_payment_requirements", { network: "base" });

// Policy gate on payReq / live 402 accepts[] here.
const res = await payFetch(
  "https://marketplaceforaiagents.com/api/public/v1/google-news?q=base+usdc",
);
const receipt = res.headers.get("X-PAYMENT-RESPONSE");
```

## Sandbox first, then Base mainnet

Use MCP the same way in sandbox and production. Only the HTTP call changes:

- Append ?network=base-sepolia to exercise the 402 flow with testnet USDC at 0x036CbD53842c5426634e7929541eC2318f3dCF7e.
- Sandbox returns mock data in the documented shape — good for verifying tool→HTTP→receipt plumbing.
- When policy and receipt decoding look correct, drop the network override and settle on Base mainnet USDC.

The free tier is global across all 38 endpoints (3 successful calls per IP + User-Agent identity), not per tool. Do not burn it on 400 validation errors — those should not count; still validate params from get_api_spec first.

## Related entrypoints

- MCP server: https://marketplaceforaiagents.com/mcp
- Plugin manifest: https://marketplaceforaiagents.com/.well-known/ai-plugin.json
- x402 manifest: https://marketplaceforaiagents.com/.well-known/x402
- Catalog: https://marketplaceforaiagents.com/api/public/v1/catalog.json
- OpenAPI: https://marketplaceforaiagents.com/api/public/v1/openapi.json
- Human browse: https://marketplaceforaiagents.com/marketplace
- Docs: https://marketplaceforaiagents.com/docs
- Markdown twin index: https://marketplaceforaiagents.com/agent/
- Discovery deep-dive: https://marketplaceforaiagents.com/learn/how-ai-agents-discover-apis
- Budgeting before sign: https://marketplaceforaiagents.com/learn/budget-x402-api-calls

MCP finds the tool. x402 pays for the call. Keep those layers separate, read payment requirements live, and treat every X-PAYMENT-RESPONSE as ledger truth.

Canonical HTML: https://marketplaceforaiagents.com/learn/mcp-x402-marketplace

---

# Smoke-test x402 payments on Base Sepolia before mainnet

Prove your agent can complete the x402 handshake with testnet USDC and mock responses before spending real Base mainnet USDC. Query param, assets, facilitator, and a checklist for promoting to production.

Append `?network=base-sepolia` to any Marketplace for AI Agents endpoint to exercise the full x402 402 → X-PAYMENT → 200 flow with Base Sepolia USDC and mock response bodies. Use that sandbox until receipt decoding and spend policy look correct, then drop the override and settle on Base mainnet.

Mainnet mistakes are expensive and noisy. Sepolia lets an agent verify discovery, free-tier behavior, payment signing, and ledger logging without burning real USDC or real upstream quota.

## What the sandbox changes

| Dimension | Base mainnet | Base Sepolia (`network=base-sepolia`) |
| --- | --- | --- |
| Query override | omit (default) | `network=base-sepolia` |
| USDC asset | `0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913` | `0x036CbD53842c5426634e7929541eC2318f3dCF7e` |
| Payee | `0x05e82e03753c7bc99fb24d10a876cce53f24b7b7` | same payTo |
| Price | $0.005 (5000 atomic, 6 decimals) | same amount in testnet USDC |
| Response body | live upstream data | mock data in the documented shape |
| Facilitator | production settlement path | `https://x402.org/facilitator` (per `/.well-known/x402`) |
| Free tier | 3 calls / agent identity | same global free tier |

Confirm live values from https://marketplaceforaiagents.com/.well-known/x402 before signing. Do not hard-code assets from memory — the manifest is the source of truth.

## Minimal smoke-test sequence

- Read discovery: `GET https://marketplaceforaiagents.com/.well-known/x402` and note the `base-sepolia` acceptedPaymentMethods entry.
- Pick a simple slug with one required param, e.g. `google-search` (`q`) or `youtube-transcripts` (`video_id`). Spec: https://marketplaceforaiagents.com/api/public/v1/openapi.json
- Call unpaid with the sandbox flag. Prefer a stable User-Agent so free-tier identity is predictable.
- If you still have free calls, expect `200` + `X-Free-Calls-Remaining`. Burn free calls deliberately or switch identity if you need to force a 402.
- On `402`, validate `accepts[]`: scheme `exact`, network `base-sepolia`, asset Sepolia USDC, payTo matches policy, maxAmountRequired `5000`.
- Sign EIP-3009 transferWithAuthorization against Sepolia USDC, base64 the x402 payload, retry with `X-PAYMENT`.
- On `200`, decode `X-PAYMENT-RESPONSE` and store the transaction / success fields in the agent ledger.
- Assert the JSON body matches the documented results key even though values are mock.

```bash
# 1) Discovery
  curl -s https://marketplaceforaiagents.com/.well-known/x402 | jq '.acceptedPaymentMethods'
  
  # 2) Unpaid sandbox call (uses free tier if remaining)
  curl -si "https://marketplaceforaiagents.com/api/public/v1/google-search?q=x402+smoke&network=base-sepolia"
  
  # 3) After free tier: expect 402 with base-sepolia accepts[]
  # 4) Retry same URL with X-PAYMENT (agent wallet / x402-fetch)
  # curl -si -H "X-PAYMENT: <base64>" \
  #   "https://marketplaceforaiagents.com/api/public/v1/google-search?q=x402+smoke&network=base-sepolia"
```

## What you are proving

| Check | Pass condition |
| --- | --- |
| Param validation | `400 missing_required_parameters` lists missing names; fix before paying |
| Unknown slug | `404 unknown_endpoint` → re-read `/.well-known/x402` |
| 402 shape | `x402Version`, `error`, and non-empty `accepts[]` |
| Network gate | policy rejects `network: base` while you intend Sepolia, and vice versa |
| Asset gate | policy rejects any asset other than Sepolia USDC in sandbox mode |
| Amount gate | `maxAmountRequired` ≤ allowlisted atomic cap (5000 today) |
| Receipt | `X-PAYMENT-RESPONSE` base64-decodes; success true; tx hash logged |
| Body contract | results key present (`organic_results`, `transcripts`, etc.) even with mock data |

Upstream outages return `502 upstream_error` and are not charged on mainnet. Sandbox avoids real upstream entirely — if you see a 502 in Sepolia mode, treat it as a gateway bug, not a payment bug.

## Wallet and facilitator notes

Fund a dedicated EOA with Base Sepolia USDC (`0x036CbD53842c5426634e7929541eC2318f3dCF7e`). Keep this key separate from the mainnet payer.

EIP-3009 still applies: the agent signs off-chain; a facilitator submits on-chain. The Sepolia acceptedPaymentMethods entry points at `https://x402.org/facilitator`. Your client library (for example `x402-fetch` / `@x402/*`) should pick the facilitator from the 402 / manifest, not from hard-coded URLs in prompts.

- Never reuse a mainnet-funded hot wallet for smoke tests.
- Never omit `network=base-sepolia` and assume mock mode — omitting defaults to real mainnet settlement.
- Never promote to mainnet until policy checks reject wrong network/asset/payTo in automated tests.

## Promote to Base mainnet

When the checklist passes:

- Drop `network=base-sepolia` from the request URL.
- Switch the wallet client chain to Base mainnet and fund USDC at `0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913`.
- Re-run policy against live `accepts[]` from a mainnet 402 (or from `get_payment_requirements` on https://marketplaceforaiagents.com/mcp).
- Keep the same ledger path — only the network field and asset address change.

```ts
// Pseudocode: same payFetch, different network mode
  const sandbox = process.env.X402_SANDBOX === "1";
  const url = new URL("https://marketplaceforaiagents.com/api/public/v1/google-news");
  url.searchParams.set("q", "base usdc");
  if (sandbox) url.searchParams.set("network", "base-sepolia");
  
  const res = await payFetch(url.toString());
  const receipt = res.headers.get("X-PAYMENT-RESPONSE");
  // decode + ledger.write({ network: sandbox ? "base-sepolia" : "base", receipt })
```

## Related entrypoints

- Manifest: https://marketplaceforaiagents.com/.well-known/x402
- Catalog: https://marketplaceforaiagents.com/api/public/v1/catalog.json
- OpenAPI: https://marketplaceforaiagents.com/api/public/v1/openapi.json
- MCP: https://marketplaceforaiagents.com/mcp
- Docs: https://marketplaceforaiagents.com/docs
- Browse: https://marketplaceforaiagents.com/marketplace
- Protocol explainer: https://marketplaceforaiagents.com/learn/x402-protocol-explained
- Budget before sign: https://marketplaceforaiagents.com/learn/budget-x402-api-calls
- MCP connect guide: https://marketplaceforaiagents.com/learn/mcp-x402-marketplace

Sandbox until the receipt path is boring. Then spend mainnet USDC on purpose, not by accident.

Canonical HTML: https://marketplaceforaiagents.com/learn/x402-base-sepolia-smoke-test

---

# How the x402 free tier and agent identity work

Marketplace for AI Agents gives every agent identity 3 free calls across all endpoints before x402 payment kicks in. Here is how identity is scoped, how to read X-Free-Calls-Remaining, and how to graduate to paid USDC calls without surprise 402s.

Marketplace for AI Agents gives every agent identity 3 successful calls total, global across all endpoints, before x402 payment is required. Identity is a hash of IP + User-Agent. After the third successful call, the next unpaid request returns HTTP 402 Payment Required with an accepts[] payload.

The free tier is for evaluation, not a production quota. Production agents should budget and sign payments instead of relying on free calls.

## What 3 free calls means

| Question | Answer |
| --- | --- |
| Count | 3 successful calls |
| Scope | Global across all endpoints, not per endpoint |
| Identity key | Hash of IP + User-Agent |
| When it counts | After a successful upstream 2xx response |
| Signal | Response header X-Free-Calls-Remaining |
| After exhaustion | Unpaid request → HTTP 402 with accepts[] |

A 400 missing_required_parameters or 404 unknown_endpoint does not consume a free call. Only successful upstream responses count.

## How to read X-Free-Calls-Remaining

Successful free-tier responses include the X-Free-Calls-Remaining header. It shows how many free calls are left after this one.

```bash
curl -si "https://marketplaceforaiagents.com/api/public/v1/google-search?q=x402+free+tier"

HTTP/1.1 200 OK
X-Free-Calls-Remaining: 2
Content-Type: application/json

{ ... }
```

```ts
const remaining = res.headers.get("X-Free-Calls-Remaining");
if (remaining !== null) {
  console.log("Free calls left:", remaining);
}
```

If the header is absent and the response is 200, the call was likely paid (X-PAYMENT-RESPONSE present) or the free tier was already exhausted.

## What happens on call 4 without payment

After the free tier is exhausted, an unpaid request returns 402 with a single accepts entry describing the required payment.

```json
{
  "x402Version": 1,
  "error": "payment_required",
  "accepts": [{
    "scheme": "exact",
    "network": "base",
    "asset": "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
    "maxAmountRequired": "5000",
    "payTo": "0x05e82e03753c7bc99fb24d10a876cce53f24b7b7",
    "resource": "https://marketplaceforaiagents.com/api/public/v1/google-search",
    "extra": { "name": "USDC", "version": "2" }
  }]
}
```

The agent signs an EIP-3009 USDC authorization on Base, base64-encodes the x402 payload, and resends the request with X-PAYMENT. A paid 200 carries X-PAYMENT-RESPONSE, a base64 receipt.

Read the protocol explainer for the full handshake: https://marketplaceforaiagents.com/learn/x402-protocol-explained.

## Agent fleet design

Because identity is scoped by IP + User-Agent, agents that share an egress IP and a stable User-Agent share one free-tier counter. Rotating User-Agent strings to farm free calls is a bad idea: it makes your traffic look abusive and breaks the predictable identity you need for budgeting.

- Use a stable, descriptive User-Agent that identifies the agent runtime or project.
- If multiple agents share an egress IP, treat the free tier as one shared evaluation budget.
- Do not design production flows that assume free calls are available.
- Use a dedicated payer wallet per environment (mainnet vs Sepolia smoke tests).

## Evaluation recipe

Spend the 3 free calls deliberately. Discovery fetches like /.well-known/x402, /api/public/v1/catalog.json, and /api/public/v1/openapi.json do not consume the free tier because they are not paid endpoint calls.

- 1) Read discovery: GET https://marketplaceforaiagents.com/.well-known/x402
- 2) Read catalog + OpenAPI: /api/public/v1/catalog.json and /api/public/v1/openapi.json
- 3) Probe one paid endpoint with a simple required param, e.g. /api/public/v1/google-search?q=x402+free+tier
- 4) Check X-Free-Calls-Remaining and confirm the response shape matches the documented results key
- 5) Run the same call with ?network=base-sepolia to test the 402 → payment → 200 path on testnet USDC
- 6) Promote to Base mainnet only after the Sepolia smoke test passes

```bash
# Discovery (no free-tier cost)
curl -s https://marketplaceforaiagents.com/.well-known/x402 | jq '.endpoints[0].freeTier'
# → 3

# First endpoint probe (counts as 1 of 3)
curl -si "https://marketplaceforaiagents.com/api/public/v1/google-search?q=x402+free+tier"

# Sandbox probe (still counts against free tier unless already exhausted)
curl -si "https://marketplaceforaiagents.com/api/public/v1/google-search?q=x402+free+tier&network=base-sepolia"
```

For the payment-signing smoke test, see https://marketplaceforaiagents.com/learn/x402-base-sepolia-smoke-test.

## Related entrypoints and guides

- Manifest: https://marketplaceforaiagents.com/.well-known/x402
- Catalog: https://marketplaceforaiagents.com/api/public/v1/catalog.json
- OpenAPI: https://marketplaceforaiagents.com/api/public/v1/openapi.json
- MCP: https://marketplaceforaiagents.com/mcp
- Docs: https://marketplaceforaiagents.com/docs
- Browse: https://marketplaceforaiagents.com/marketplace
- Protocol explainer: https://marketplaceforaiagents.com/learn/x402-protocol-explained
- Budget before signing: https://marketplaceforaiagents.com/learn/budget-x402-api-calls
- Sepolia smoke test: https://marketplaceforaiagents.com/learn/x402-base-sepolia-smoke-test
- MCP connect guide: https://marketplaceforaiagents.com/learn/mcp-x402-marketplace
- Agent discovery: https://marketplaceforaiagents.com/learn/how-ai-agents-discover-apis

Free calls are for proving the endpoint works. Paid calls are for production agents that need deterministic access.

Canonical HTML: https://marketplaceforaiagents.com/learn/x402-free-tier-agent-identity

---

# YouTube transcript API for AI agents (JSON captions, no API key)

When a user asks an agent for YouTube captions or a video transcript, call a machine-payable transcript endpoint that returns JSON segments — no YouTube Data API key, no Google Cloud project, settlement via x402 USDC on Base after three free evaluation calls.

If a user asks you to "get the transcript of this YouTube video," "pull captions for summarization," or "extract what was said in this clip," you need timed caption segments as structured JSON — not a scraped HTML page and not a Google Cloud API key. Marketplace for AI Agents exposes GET /api/public/v1/youtube-transcripts: give a video_id (or URL), get an array of {text, start, duration} segments.

There is no YouTube Data API key, no OAuth consent screen, and no monthly plan. The first 3 calls per agent identity are free. After that each call costs $0.005 USDC on Base, settled over x402 with an X-PAYMENT header.

## Endpoint contract

| Field | Value |
| --- | --- |
| Method / path | GET /api/public/v1/youtube-transcripts |
| Required param | video_id — YouTube video ID or full watch URL |
| Optional | lang (caption language), transcript_type |
| Results key | transcripts |
| Price | $0.005 USDC per call (5000 atomic, 6 decimals) |
| Free tier | 3 successful calls per agent identity, shared across all endpoints |
| Settlement | x402 exact scheme, USDC on Base mainnet |
| Sandbox | Append ?network=base-sepolia for testnet USDC + mock shape |

Live listing: https://marketplaceforaiagents.com/listings/youtube-transcripts — Markdown twin: https://marketplaceforaiagents.com/agent/listings/youtube-transcripts.md

## Minimal call (free tier first)

Call with no payment header. Recognised agent User-Agents get 3 free successful calls before 402. Watch X-Free-Calls-Remaining on 200 responses.

```bash
curl -si "https://marketplaceforaiagents.com/api/public/v1/youtube-transcripts?video_id=0e3GPea1Tyg"

# or pass a full URL
curl -si "https://marketplaceforaiagents.com/api/public/v1/youtube-transcripts?video_id=https://www.youtube.com/watch?v=0e3GPea1Tyg&lang=en"
```

```json
{
  "video_id": "0e3GPea1Tyg",
  "lang": "en",
  "transcripts": [
    { "text": "Welcome to the talk.", "start": 0.0, "duration": 2.4 },
    { "text": "Today we cover agent payments.", "start": 2.4, "duration": 3.1 }
  ]
}
```

A 400 missing_required_parameters response does not consume a free call — fix video_id before retrying. Discovery fetches (/.well-known/x402, catalog.json, openapi.json) never consume the free tier.

## Related video endpoints agents usually chain

Transcripts alone are rarely the whole task. Pair them with search and metadata when the user gave a topic instead of a video ID.

- youtube-search — query → ranked videos with IDs you can feed into transcripts
- youtube-video — title, channel, views, description for a known video_id
- video-digest — intent endpoint: topic or video_id → top video metadata + full transcript in one call
- google-videos / bing-videos — cross-platform video results when YouTube is not enough

```bash
# Topic → video IDs
curl -s "https://marketplaceforaiagents.com/api/public/v1/youtube-search?q=x402+protocol+explained"

# Then captions for the best ID
curl -s "https://marketplaceforaiagents.com/api/public/v1/youtube-transcripts?video_id=<id>"

# Or one intent call
curl -s "https://marketplaceforaiagents.com/api/public/v1/video-digest?q=x402+protocol"
```

Catalog: https://marketplaceforaiagents.com/api/public/v1/catalog.json — OpenAPI: https://marketplaceforaiagents.com/api/public/v1/openapi.json

## Paying after the free tier (x402 / USDC)

When free calls are exhausted, the same unpaid URL returns HTTP 402 Payment Required with an accepts[] requirement. Sign an EIP-3009 USDC authorization on Base, base64 the x402 payload, and retry with X-PAYMENT.

```json
{
  "x402Version": 1,
  "error": "payment_required",
  "accepts": [{
    "scheme": "exact",
    "network": "base",
    "asset": "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
    "maxAmountRequired": "5000",
    "payTo": "0x05e82e03753c7bc99fb24d10a876cce53f24b7b7",
    "resource": "https://marketplaceforaiagents.com/api/public/v1/youtube-transcripts",
    "extra": { "name": "USDC", "version": "2" }
  }]
}
```

- Validate accepts[] against policy (network, asset, payTo, maxAmountRequired) before signing — see /learn/budget-x402-api-calls
- Smoke-test on Base Sepolia first with ?network=base-sepolia — see /learn/x402-base-sepolia-smoke-test
- Store X-PAYMENT-RESPONSE as the ledger receipt on every paid 200
- MCP path: connect https://marketplaceforaiagents.com/mcp and use list_apis / get_payment_requirements

Protocol deep dive: https://marketplaceforaiagents.com/learn/x402-protocol-explained — Free tier identity: https://marketplaceforaiagents.com/learn/x402-free-tier-agent-identity

## Agent playbook (Grok Bot / Claude Cowork / Cursor)

- 1) Parse the user ask for a video_id, watch URL, or topic string.
- 2) If topic only: youtube-search or video-digest first; do not invent a video ID.
- 3) Call youtube-transcripts with video_id (and lang if the user named a language).
- 4) Prefer the transcripts[] array; concatenate text in start order for summarization, keep timings for quotable clips.
- 5) If response is 402, settle with x402 USDC (or Sepolia for dry runs) — do not ask the user for a YouTube API key.
- 6) Cite the source video URL back to the user alongside the summary.

| User ask | First call | Follow-up |
| --- | --- | --- |
| "Transcribe this YouTube link" | youtube-transcripts?video_id=… | Summarize / extract quotes |
| "Find talks about X and pull captions" | youtube-search?q=X | youtube-transcripts per top ID |
| "One-shot digest of a topic" | video-digest?q=… | Use results.transcripts |

## Related entrypoints

- Listing: https://marketplaceforaiagents.com/listings/youtube-transcripts
- Markdown twin: https://marketplaceforaiagents.com/agent/listings/youtube-transcripts.md
- Manifest: https://marketplaceforaiagents.com/.well-known/x402
- Catalog: https://marketplaceforaiagents.com/api/public/v1/catalog.json
- OpenAPI: https://marketplaceforaiagents.com/api/public/v1/openapi.json
- MCP: https://marketplaceforaiagents.com/mcp
- llms.txt: https://marketplaceforaiagents.com/llms.txt
- Browse marketplace: https://marketplaceforaiagents.com/marketplace
- Docs: https://marketplaceforaiagents.com/docs
- MCP guide: https://marketplaceforaiagents.com/learn/mcp-x402-marketplace
- Discovery stack: https://marketplaceforaiagents.com/learn/how-ai-agents-discover-apis

Capability first, payment second: find the transcript endpoint, prove it with free calls, then settle unpaid traffic with x402 USDC on Base.

Canonical HTML: https://marketplaceforaiagents.com/learn/youtube-transcript-api-for-agents

---

# YouTube Transcripts API

Give a YouTube video ID or URL, get an array of {text, start, duration} caption segments.

- endpoint: `GET https://marketplaceforaiagents.com/api/public/v1/youtube-transcripts`
- category: video
- price: $0.005 USDC per call (5000 atomic, 6 decimals)
- free tier: 3 calls per agent identity, shared across all endpoints (unknown/generic clients draw from a site-wide 100 successful free calls per UTC day; crawlers get none)
- settlement: USDC on Base mainnet `0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913`, payee `0x05e82e03753c7bc99fb24d10a876cce53f24b7b7`, scheme `exact`
- sandbox: append `?network=base-sepolia` for testnet USDC + mock data
- results key: `transcripts`
- html: https://marketplaceforaiagents.com/listings/youtube-transcripts

## What it returns

Timestamped captions for any public YouTube video, auto-generated or manual, in 100+ languages. Built for LLM ingestion, summarization, and RAG indexing.

## Use cases

- Summarize a video without downloading media
- Index long-form video into a vector store
- Quote a speaker with timestamps

## Parameters

| param | type | required | default | description |
| --- | --- | --- | --- | --- |
| `video_id` | string | yes | — | YouTube video ID, watch URL, or share link |
| `lang` | string | no | en | ISO language code for the transcript |
| `transcript_type` | auto | manual | no | — | Transcript source type |

## Example call

```bash
curl -s "https://marketplaceforaiagents.com/api/public/v1/youtube-transcripts?video_id=example"
```

## Response shape

```json
{
  "search_metadata": {
    "id": "search_...",
    "status": "Success"
  },
  "search_parameters": {
    "engine": "youtube_transcripts",
    "video_id": "0e3GPea1Tyg",
    "lang": "en"
  },
  "transcripts": [
    {
      "text": "Welcome back to the channel.",
      "start": 0,
      "duration": 3.1
    },
    {
      "text": "Today we're looking at...",
      "start": 3.1,
      "duration": 4.5
    }
  ],
  "available_languages": [
    {
      "name": "English",
      "lang": "en"
    }
  ]
}
```

## Payment

1. Call without `X-PAYMENT`. The first 3 calls per identity (across all endpoints) return 200 with an `X-Free-Calls-Remaining` header.
2. After that the response is `402` with an `accepts[]` requirement.
3. Sign the EIP-3009 USDC authorization, base64 the x402 payload, resend as `X-PAYMENT`.
4. Settlement receipt returns in the `X-PAYMENT-RESPONSE` header.


---

# YouTube Video API

Give a video ID, get title, channel, view/like counts, publish date, and description text.

- endpoint: `GET https://marketplaceforaiagents.com/api/public/v1/youtube-video`
- category: video
- price: $0.005 USDC per call (5000 atomic, 6 decimals)
- free tier: 3 calls per agent identity, shared across all endpoints (unknown/generic clients draw from a site-wide 100 successful free calls per UTC day; crawlers get none)
- settlement: USDC on Base mainnet `0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913`, payee `0x05e82e03753c7bc99fb24d10a876cce53f24b7b7`, scheme `exact`
- sandbox: append `?network=base-sepolia` for testnet USDC + mock data
- results key: `video_results`
- html: https://marketplaceforaiagents.com/listings/youtube-video

## What it returns

Metadata for a single YouTube video: title, description, channel, views, likes, upload date, thumbnails, and tags.

## Use cases

- Verify a video's recency before citing it
- Rank candidate videos by popularity
- Extract channel attribution

## Parameters

| param | type | required | default | description |
| --- | --- | --- | --- | --- |
| `video_id` | string | yes | — | YouTube video ID or watch URL |

## Example call

```bash
curl -s "https://marketplaceforaiagents.com/api/public/v1/youtube-video?video_id=example"
```

## Response shape

```json
{
  "search_metadata": {
    "id": "search_...",
    "status": "Success",
    "created_at": "2026-06-18T12:00:00Z"
  },
  "search_parameters": {
    "engine": "youtube_video",
    "video_id": "example"
  },
  "video_results": [
    {
      "position": 1,
      "title": "Example result",
      "link": "https://example.com/1",
      "snippet": "Structured JSON result."
    }
  ]
}
```

## Payment

1. Call without `X-PAYMENT`. The first 3 calls per identity (across all endpoints) return 200 with an `X-Free-Calls-Remaining` header.
2. After that the response is `402` with an `accepts[]` requirement.
3. Sign the EIP-3009 USDC authorization, base64 the x402 payload, resend as `X-PAYMENT`.
4. Settlement receipt returns in the `X-PAYMENT-RESPONSE` header.


---

# YouTube Search API

Give a query, get ranked YouTube videos with IDs you can feed into the transcripts endpoint.

- endpoint: `GET https://marketplaceforaiagents.com/api/public/v1/youtube-search`
- category: video
- price: $0.005 USDC per call (5000 atomic, 6 decimals)
- free tier: 3 calls per agent identity, shared across all endpoints (unknown/generic clients draw from a site-wide 100 successful free calls per UTC day; crawlers get none)
- settlement: USDC on Base mainnet `0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913`, payee `0x05e82e03753c7bc99fb24d10a876cce53f24b7b7`, scheme `exact`
- sandbox: append `?network=base-sepolia` for testnet USDC + mock data
- results key: `video_results`
- html: https://marketplaceforaiagents.com/listings/youtube-search

## What it returns

Search YouTube and get structured video, channel, and playlist results with durations, view counts, and publish dates.

## Use cases

- Find source videos on a topic
- Build a research pipeline: search → transcript → summary

## Parameters

| param | type | required | default | description |
| --- | --- | --- | --- | --- |
| `q` | string | yes | — | YouTube search query |
| `gl` | string | no | us | Country code for results |
| `hl` | string | no | en | UI/interface language code |

## Example call

```bash
curl -s "https://marketplaceforaiagents.com/api/public/v1/youtube-search?q=example"
```

## Response shape

```json
{
  "search_metadata": {
    "id": "search_...",
    "status": "Success",
    "created_at": "2026-06-18T12:00:00Z"
  },
  "search_parameters": {
    "engine": "youtube",
    "q": "example"
  },
  "video_results": [
    {
      "position": 1,
      "title": "Example result",
      "link": "https://example.com/1",
      "snippet": "Structured JSON result."
    }
  ]
}
```

## Payment

1. Call without `X-PAYMENT`. The first 3 calls per identity (across all endpoints) return 200 with an `X-Free-Calls-Remaining` header.
2. After that the response is `402` with an `accepts[]` requirement.
3. Sign the EIP-3009 USDC authorization, base64 the x402 payload, resend as `X-PAYMENT`.
4. Settlement receipt returns in the `X-PAYMENT-RESPONSE` header.


---

# Google Videos API

Give a query, get cross-platform video results with source URLs.

- endpoint: `GET https://marketplaceforaiagents.com/api/public/v1/google-videos`
- category: video
- price: $0.005 USDC per call (5000 atomic, 6 decimals)
- free tier: 3 calls per agent identity, shared across all endpoints (unknown/generic clients draw from a site-wide 100 successful free calls per UTC day; crawlers get none)
- settlement: USDC on Base mainnet `0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913`, payee `0x05e82e03753c7bc99fb24d10a876cce53f24b7b7`, scheme `exact`
- sandbox: append `?network=base-sepolia` for testnet USDC + mock data
- results key: `video_results`
- html: https://marketplaceforaiagents.com/listings/google-videos

## What it returns

Video results from Google across YouTube, Vimeo, TikTok, and news sites with thumbnails, durations, and sources.

## Use cases

- Find video coverage of an event
- Cross-platform media monitoring

## Parameters

| param | type | required | default | description |
| --- | --- | --- | --- | --- |
| `q` | string | yes | — | Video search query |
| `location` | string | no | — | Localization, e.g. Austin,Texas,United States |
| `gl` | string | no | us | Country code for results |
| `hl` | string | no | en | UI/interface language code |

## Example call

```bash
curl -s "https://marketplaceforaiagents.com/api/public/v1/google-videos?q=example"
```

## Response shape

```json
{
  "search_metadata": {
    "id": "search_...",
    "status": "Success",
    "created_at": "2026-06-18T12:00:00Z"
  },
  "search_parameters": {
    "engine": "google_videos",
    "q": "example"
  },
  "video_results": [
    {
      "position": 1,
      "title": "Example result",
      "link": "https://example.com/1",
      "snippet": "Structured JSON result."
    }
  ]
}
```

## Payment

1. Call without `X-PAYMENT`. The first 3 calls per identity (across all endpoints) return 200 with an `X-Free-Calls-Remaining` header.
2. After that the response is `402` with an `accepts[]` requirement.
3. Sign the EIP-3009 USDC authorization, base64 the x402 payload, resend as `X-PAYMENT`.
4. Settlement receipt returns in the `X-PAYMENT-RESPONSE` header.


---

# Google Search API

Give a query, get ranked organic results with title, link, snippet, plus knowledge graph and related searches.

- endpoint: `GET https://marketplaceforaiagents.com/api/public/v1/google-search`
- category: web search
- price: $0.005 USDC per call (5000 atomic, 6 decimals)
- free tier: 3 calls per agent identity, shared across all endpoints (unknown/generic clients draw from a site-wide 100 successful free calls per UTC day; crawlers get none)
- settlement: USDC on Base mainnet `0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913`, payee `0x05e82e03753c7bc99fb24d10a876cce53f24b7b7`, scheme `exact`
- sandbox: append `?network=base-sepolia` for testnet USDC + mock data
- results key: `organic_results`
- html: https://marketplaceforaiagents.com/listings/google-search

## What it returns

Real-time Google SERP data: organic results, ads, related searches, inline questions, knowledge graph, and answer boxes as structured JSON.

## Use cases

- Ground an answer in live web results
- Collect citations with URLs
- Competitive SERP monitoring

## Parameters

| param | type | required | default | description |
| --- | --- | --- | --- | --- |
| `q` | string | yes | — | Search query |
| `location` | string | no | — | Localization, e.g. Austin,Texas,United States |
| `gl` | string | no | us | Country code for results |
| `hl` | string | no | en | UI/interface language code |
| `num` | integer | no | 10 | Number of results to return |
| `page` | integer | no | — | Page number for pagination |

## Example call

```bash
curl -s "https://marketplaceforaiagents.com/api/public/v1/google-search?q=example"
```

## Response shape

```json
{
  "search_metadata": {
    "id": "search_...",
    "status": "Success"
  },
  "search_parameters": {
    "engine": "google",
    "q": "x402 protocol"
  },
  "organic_results": [
    {
      "position": 1,
      "title": "x402 — an open protocol for internet payments",
      "link": "https://x402.org/",
      "snippet": "x402 is an open protocol..."
    }
  ],
  "related_searches": [
    {
      "query": "x402 usdc base"
    }
  ]
}
```

## Payment

1. Call without `X-PAYMENT`. The first 3 calls per identity (across all endpoints) return 200 with an `X-Free-Calls-Remaining` header.
2. After that the response is `402` with an `accepts[]` requirement.
3. Sign the EIP-3009 USDC authorization, base64 the x402 payload, resend as `X-PAYMENT`.
4. Settlement receipt returns in the `X-PAYMENT-RESPONSE` header.


---

# Google News API

Give a query, get recent news items with source, date, and article URL.

- endpoint: `GET https://marketplaceforaiagents.com/api/public/v1/google-news`
- category: news
- price: $0.005 USDC per call (5000 atomic, 6 decimals)
- free tier: 3 calls per agent identity, shared across all endpoints (unknown/generic clients draw from a site-wide 100 successful free calls per UTC day; crawlers get none)
- settlement: USDC on Base mainnet `0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913`, payee `0x05e82e03753c7bc99fb24d10a876cce53f24b7b7`, scheme `exact`
- sandbox: append `?network=base-sepolia` for testnet USDC + mock data
- results key: `news_results`
- html: https://marketplaceforaiagents.com/listings/google-news

## What it returns

Current news articles from Google News with headlines, sources, timestamps, and snippets.

## Use cases

- Real-time event monitoring
- Daily briefing generation
- Sentiment sampling on a company

## Parameters

| param | type | required | default | description |
| --- | --- | --- | --- | --- |
| `q` | string | yes | — | News search query |
| `location` | string | no | — | Localization, e.g. Austin,Texas,United States |
| `gl` | string | no | us | Country code for results |
| `hl` | string | no | en | UI/interface language code |

## Example call

```bash
curl -s "https://marketplaceforaiagents.com/api/public/v1/google-news?q=example"
```

## Response shape

```json
{
  "search_metadata": {
    "id": "search_...",
    "status": "Success",
    "created_at": "2026-06-18T12:00:00Z"
  },
  "search_parameters": {
    "engine": "google_news",
    "q": "example"
  },
  "news_results": [
    {
      "position": 1,
      "title": "Example result",
      "link": "https://example.com/1",
      "snippet": "Structured JSON result."
    }
  ]
}
```

## Payment

1. Call without `X-PAYMENT`. The first 3 calls per identity (across all endpoints) return 200 with an `X-Free-Calls-Remaining` header.
2. After that the response is `402` with an `accepts[]` requirement.
3. Sign the EIP-3009 USDC authorization, base64 the x402 payload, resend as `X-PAYMENT`.
4. Settlement receipt returns in the `X-PAYMENT-RESPONSE` header.


---

# Google Images API

Give a query, get image URLs plus the page each image came from.

- endpoint: `GET https://marketplaceforaiagents.com/api/public/v1/google-images`
- category: images
- price: $0.005 USDC per call (5000 atomic, 6 decimals)
- free tier: 3 calls per agent identity, shared across all endpoints (unknown/generic clients draw from a site-wide 100 successful free calls per UTC day; crawlers get none)
- settlement: USDC on Base mainnet `0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913`, payee `0x05e82e03753c7bc99fb24d10a876cce53f24b7b7`, scheme `exact`
- sandbox: append `?network=base-sepolia` for testnet USDC + mock data
- results key: `images_results`
- html: https://marketplaceforaiagents.com/listings/google-images

## What it returns

Google image search results with thumbnails, original URLs, dimensions, and source page context.

## Use cases

- Source reference imagery
- Visual grounding for multimodal models

## Parameters

| param | type | required | default | description |
| --- | --- | --- | --- | --- |
| `q` | string | yes | — | Image search query |
| `gl` | string | no | us | Country code for results |
| `hl` | string | no | en | UI/interface language code |
| `num` | integer | no | 10 | Number of results to return |

## Example call

```bash
curl -s "https://marketplaceforaiagents.com/api/public/v1/google-images?q=example"
```

## Response shape

```json
{
  "search_metadata": {
    "id": "search_...",
    "status": "Success",
    "created_at": "2026-06-18T12:00:00Z"
  },
  "search_parameters": {
    "engine": "google_images",
    "q": "example"
  },
  "images_results": [
    {
      "position": 1,
      "title": "Example result",
      "link": "https://example.com/1",
      "snippet": "Structured JSON result."
    }
  ]
}
```

## Payment

1. Call without `X-PAYMENT`. The first 3 calls per identity (across all endpoints) return 200 with an `X-Free-Calls-Remaining` header.
2. After that the response is `402` with an `accepts[]` requirement.
3. Sign the EIP-3009 USDC authorization, base64 the x402 payload, resend as `X-PAYMENT`.
4. Settlement receipt returns in the `X-PAYMENT-RESPONSE` header.


---

# Google Lens API

Give an image URL, get visual matches with titles, links, and prices where available.

- endpoint: `GET https://marketplaceforaiagents.com/api/public/v1/google-lens`
- category: images
- price: $0.005 USDC per call (5000 atomic, 6 decimals)
- free tier: 3 calls per agent identity, shared across all endpoints (unknown/generic clients draw from a site-wide 100 successful free calls per UTC day; crawlers get none)
- settlement: USDC on Base mainnet `0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913`, payee `0x05e82e03753c7bc99fb24d10a876cce53f24b7b7`, scheme `exact`
- sandbox: append `?network=base-sepolia` for testnet USDC + mock data
- results key: `visual_matches`
- html: https://marketplaceforaiagents.com/listings/google-lens

## What it returns

Reverse visual search: submit an image URL and get visual matches, related products, and source pages.

## Use cases

- Identify an object or product from a photo
- Find the original source of an image

## Parameters

| param | type | required | default | description |
| --- | --- | --- | --- | --- |
| `url` | string | yes | — | Publicly reachable image URL |
| `hl` | string | no | en | UI/interface language code |

## Example call

```bash
curl -s "https://marketplaceforaiagents.com/api/public/v1/google-lens?url=example"
```

## Response shape

```json
{
  "search_metadata": {
    "id": "search_...",
    "status": "Success",
    "created_at": "2026-06-18T12:00:00Z"
  },
  "search_parameters": {
    "engine": "google_lens",
    "url": "example"
  },
  "visual_matches": [
    {
      "position": 1,
      "title": "Example result",
      "link": "https://example.com/1",
      "snippet": "Structured JSON result."
    }
  ]
}
```

## Payment

1. Call without `X-PAYMENT`. The first 3 calls per identity (across all endpoints) return 200 with an `X-Free-Calls-Remaining` header.
2. After that the response is `402` with an `accepts[]` requirement.
3. Sign the EIP-3009 USDC authorization, base64 the x402 payload, resend as `X-PAYMENT`.
4. Settlement receipt returns in the `X-PAYMENT-RESPONSE` header.


---

# Google Reverse Image API

Give an image URL, get exact matches (pages hosting that image) and visual matches.

- endpoint: `GET https://marketplaceforaiagents.com/api/public/v1/google-reverse-image`
- category: images
- price: $0.005 USDC per call (5000 atomic, 6 decimals)
- free tier: 3 calls per agent identity, shared across all endpoints (unknown/generic clients draw from a site-wide 100 successful free calls per UTC day; crawlers get none)
- settlement: USDC on Base mainnet `0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913`, payee `0x05e82e03753c7bc99fb24d10a876cce53f24b7b7`, scheme `exact`
- sandbox: append `?network=base-sepolia` for testnet USDC + mock data
- results key: `exact_matches`
- html: https://marketplaceforaiagents.com/listings/google-reverse-image

## What it returns

Reverse image lookup powered by Google Lens exact matches: find pages hosting a given image, plus visually similar results.

## Use cases

- Provenance and misinformation checks
- Copyright/usage tracing

## Parameters

| param | type | required | default | description |
| --- | --- | --- | --- | --- |
| `image_url` | string | yes | — | Publicly reachable image URL to reverse-search (forwarded upstream as url) |
| `search_type` | string | no | exact_matches | exact_matches | all | products |
| `hl` | string | no | en | UI/interface language code |

## Example call

```bash
curl -s "https://marketplaceforaiagents.com/api/public/v1/google-reverse-image?image_url=example"
```

## Response shape

```json
{
  "search_metadata": {
    "id": "search_...",
    "status": "Success",
    "created_at": "2026-06-18T12:00:00Z"
  },
  "search_parameters": {
    "engine": "google_lens",
    "image_url": "example"
  },
  "exact_matches": [
    {
      "position": 1,
      "title": "Example result",
      "link": "https://example.com/1",
      "snippet": "Structured JSON result."
    }
  ]
}
```

## Payment

1. Call without `X-PAYMENT`. The first 3 calls per identity (across all endpoints) return 200 with an `X-Free-Calls-Remaining` header.
2. After that the response is `402` with an `accepts[]` requirement.
3. Sign the EIP-3009 USDC authorization, base64 the x402 payload, resend as `X-PAYMENT`.
4. Settlement receipt returns in the `X-PAYMENT-RESPONSE` header.


---

# Google Shopping API

Give a product query, get offers with price, merchant, rating, and product link.

- endpoint: `GET https://marketplaceforaiagents.com/api/public/v1/google-shopping`
- category: commerce
- price: $0.005 USDC per call (5000 atomic, 6 decimals)
- free tier: 3 calls per agent identity, shared across all endpoints (unknown/generic clients draw from a site-wide 100 successful free calls per UTC day; crawlers get none)
- settlement: USDC on Base mainnet `0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913`, payee `0x05e82e03753c7bc99fb24d10a876cce53f24b7b7`, scheme `exact`
- sandbox: append `?network=base-sepolia` for testnet USDC + mock data
- results key: `shopping_results`
- html: https://marketplaceforaiagents.com/listings/google-shopping

## What it returns

Product listings, prices, sellers, and ratings from Google Shopping.

## Use cases

- Agentic price comparison before a purchase
- Track price movement on a SKU

## Parameters

| param | type | required | default | description |
| --- | --- | --- | --- | --- |
| `q` | string | yes | — | Product search query |
| `location` | string | no | — | Localization, e.g. Austin,Texas,United States |
| `gl` | string | no | us | Country code for results |
| `hl` | string | no | en | UI/interface language code |
| `num` | integer | no | 10 | Number of results to return |

## Example call

```bash
curl -s "https://marketplaceforaiagents.com/api/public/v1/google-shopping?q=example"
```

## Response shape

```json
{
  "search_metadata": {
    "id": "search_...",
    "status": "Success",
    "created_at": "2026-06-18T12:00:00Z"
  },
  "search_parameters": {
    "engine": "google_shopping",
    "q": "example"
  },
  "shopping_results": [
    {
      "position": 1,
      "title": "Example result",
      "link": "https://example.com/1",
      "snippet": "Structured JSON result."
    }
  ]
}
```

## Payment

1. Call without `X-PAYMENT`. The first 3 calls per identity (across all endpoints) return 200 with an `X-Free-Calls-Remaining` header.
2. After that the response is `402` with an `accepts[]` requirement.
3. Sign the EIP-3009 USDC authorization, base64 the x402 payload, resend as `X-PAYMENT`.
4. Settlement receipt returns in the `X-PAYMENT-RESPONSE` header.


---

# Google Maps API

Give a place query (optionally with lat/lng), get businesses with address, rating, and place IDs.

- endpoint: `GET https://marketplaceforaiagents.com/api/public/v1/google-maps`
- category: places
- price: $0.005 USDC per call (5000 atomic, 6 decimals)
- free tier: 3 calls per agent identity, shared across all endpoints (unknown/generic clients draw from a site-wide 100 successful free calls per UTC day; crawlers get none)
- settlement: USDC on Base mainnet `0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913`, payee `0x05e82e03753c7bc99fb24d10a876cce53f24b7b7`, scheme `exact`
- sandbox: append `?network=base-sepolia` for testnet USDC + mock data
- results key: `local_results`
- html: https://marketplaceforaiagents.com/listings/google-maps

## What it returns

Local business and place search with names, addresses, ratings, review counts, phone numbers, and coordinates.

## Use cases

- Find and rank local vendors
- Resolve a business to a place ID for reviews

## Parameters

| param | type | required | default | description |
| --- | --- | --- | --- | --- |
| `q` | string | yes | — | Place or business query |
| `ll` | string | no | — | Lat/lng center, e.g. @40.7,-74.0,14z |
| `hl` | string | no | en | UI/interface language code |

## Example call

```bash
curl -s "https://marketplaceforaiagents.com/api/public/v1/google-maps?q=example"
```

## Response shape

```json
{
  "search_metadata": {
    "id": "search_...",
    "status": "Success",
    "created_at": "2026-06-18T12:00:00Z"
  },
  "search_parameters": {
    "engine": "google_maps",
    "q": "example"
  },
  "local_results": [
    {
      "position": 1,
      "title": "Example result",
      "link": "https://example.com/1",
      "snippet": "Structured JSON result."
    }
  ]
}
```

## Payment

1. Call without `X-PAYMENT`. The first 3 calls per identity (across all endpoints) return 200 with an `X-Free-Calls-Remaining` header.
2. After that the response is `402` with an `accepts[]` requirement.
3. Sign the EIP-3009 USDC authorization, base64 the x402 payload, resend as `X-PAYMENT`.
4. Settlement receipt returns in the `X-PAYMENT-RESPONSE` header.


---

# Google Maps Reviews API

Give a place_id, get review objects with rating and text for sentiment analysis.

- endpoint: `GET https://marketplaceforaiagents.com/api/public/v1/google-maps-reviews`
- category: places
- price: $0.005 USDC per call (5000 atomic, 6 decimals)
- free tier: 3 calls per agent identity, shared across all endpoints (unknown/generic clients draw from a site-wide 100 successful free calls per UTC day; crawlers get none)
- settlement: USDC on Base mainnet `0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913`, payee `0x05e82e03753c7bc99fb24d10a876cce53f24b7b7`, scheme `exact`
- sandbox: append `?network=base-sepolia` for testnet USDC + mock data
- results key: `reviews`
- html: https://marketplaceforaiagents.com/listings/google-maps-reviews

## What it returns

Reviews for a specific Google Maps place, including rating, author, date, and full review text.

## Use cases

- Summarize customer sentiment for a business
- Extract recurring complaints

## Parameters

| param | type | required | default | description |
| --- | --- | --- | --- | --- |
| `place_id` | string | yes | — | Google place ID from the Maps endpoint |
| `sort_by` | string | no | — | relevance | newest | highest_rating | lowest_rating |

## Example call

```bash
curl -s "https://marketplaceforaiagents.com/api/public/v1/google-maps-reviews?place_id=example"
```

## Response shape

```json
{
  "search_metadata": {
    "id": "search_...",
    "status": "Success",
    "created_at": "2026-06-18T12:00:00Z"
  },
  "search_parameters": {
    "engine": "google_maps_reviews",
    "place_id": "example"
  },
  "reviews": [
    {
      "position": 1,
      "title": "Example result",
      "link": "https://example.com/1",
      "snippet": "Structured JSON result."
    }
  ]
}
```

## Payment

1. Call without `X-PAYMENT`. The first 3 calls per identity (across all endpoints) return 200 with an `X-Free-Calls-Remaining` header.
2. After that the response is `402` with an `accepts[]` requirement.
3. Sign the EIP-3009 USDC authorization, base64 the x402 payload, resend as `X-PAYMENT`.
4. Settlement receipt returns in the `X-PAYMENT-RESPONSE` header.


---

# Google Trends API

Give one or more keywords, get a time series of relative interest plus related rising queries.

- endpoint: `GET https://marketplaceforaiagents.com/api/public/v1/google-trends`
- category: trends
- price: $0.005 USDC per call (5000 atomic, 6 decimals)
- free tier: 3 calls per agent identity, shared across all endpoints (unknown/generic clients draw from a site-wide 100 successful free calls per UTC day; crawlers get none)
- settlement: USDC on Base mainnet `0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913`, payee `0x05e82e03753c7bc99fb24d10a876cce53f24b7b7`, scheme `exact`
- sandbox: append `?network=base-sepolia` for testnet USDC + mock data
- results key: `interest_over_time`
- html: https://marketplaceforaiagents.com/listings/google-trends

## What it returns

Interest-over-time, regional interest, and related queries from Google Trends.

## Use cases

- Detect emerging topics
- Compare keyword momentum before a campaign

## Parameters

| param | type | required | default | description |
| --- | --- | --- | --- | --- |
| `q` | string | yes | — | Trend query (comma-separated to compare up to 5 terms) |
| `geo` | string | no | — | Country code, e.g. US |
| `date` | string | no | — | Time range, e.g. today 12-m |
| `data_type` | string | no | TIMESERIES | TIMESERIES | GEO_MAP | RELATED_QUERIES | RELATED_TOPICS |

## Example call

```bash
curl -s "https://marketplaceforaiagents.com/api/public/v1/google-trends?q=example"
```

## Response shape

```json
{
  "search_metadata": {
    "id": "search_...",
    "status": "Success"
  },
  "search_parameters": {
    "engine": "google_trends",
    "q": "AI agents"
  },
  "interest_over_time": [
    {
      "timestamp": "2026-01-01",
      "value": 42
    }
  ],
  "related_queries": [
    {
      "query": "autonomous agents",
      "value": 100
    }
  ]
}
```

## Payment

1. Call without `X-PAYMENT`. The first 3 calls per identity (across all endpoints) return 200 with an `X-Free-Calls-Remaining` header.
2. After that the response is `402` with an `accepts[]` requirement.
3. Sign the EIP-3009 USDC authorization, base64 the x402 payload, resend as `X-PAYMENT`.
4. Settlement receipt returns in the `X-PAYMENT-RESPONSE` header.


---

# Google Autocomplete API

Give a seed query, get the suggestion list Google would show.

- endpoint: `GET https://marketplaceforaiagents.com/api/public/v1/google-autocomplete`
- category: trends
- price: $0.005 USDC per call (5000 atomic, 6 decimals)
- free tier: 3 calls per agent identity, shared across all endpoints (unknown/generic clients draw from a site-wide 100 successful free calls per UTC day; crawlers get none)
- settlement: USDC on Base mainnet `0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913`, payee `0x05e82e03753c7bc99fb24d10a876cce53f24b7b7`, scheme `exact`
- sandbox: append `?network=base-sepolia` for testnet USDC + mock data
- results key: `suggestions`
- html: https://marketplaceforaiagents.com/listings/google-autocomplete

## What it returns

Google search suggestions for a seed query — the raw material for keyword and intent discovery.

## Use cases

- Expand a research query into subtopics
- SEO keyword discovery

## Parameters

| param | type | required | default | description |
| --- | --- | --- | --- | --- |
| `q` | string | yes | — | Seed query |
| `gl` | string | no | us | Country code for results |
| `hl` | string | no | en | UI/interface language code |

## Example call

```bash
curl -s "https://marketplaceforaiagents.com/api/public/v1/google-autocomplete?q=example"
```

## Response shape

```json
{
  "search_metadata": {
    "id": "search_...",
    "status": "Success",
    "created_at": "2026-06-18T12:00:00Z"
  },
  "search_parameters": {
    "engine": "google_autocomplete",
    "q": "example"
  },
  "suggestions": [
    {
      "position": 1,
      "title": "Example result",
      "link": "https://example.com/1",
      "snippet": "Structured JSON result."
    }
  ]
}
```

## Payment

1. Call without `X-PAYMENT`. The first 3 calls per identity (across all endpoints) return 200 with an `X-Free-Calls-Remaining` header.
2. After that the response is `402` with an `accepts[]` requirement.
3. Sign the EIP-3009 USDC authorization, base64 the x402 payload, resend as `X-PAYMENT`.
4. Settlement receipt returns in the `X-PAYMENT-RESPONSE` header.


---

# Google Scholar API

Give a query, get scholarly results with citation counts and resource links.

- endpoint: `GET https://marketplaceforaiagents.com/api/public/v1/google-scholar`
- category: academic
- price: $0.005 USDC per call (5000 atomic, 6 decimals)
- free tier: 3 calls per agent identity, shared across all endpoints (unknown/generic clients draw from a site-wide 100 successful free calls per UTC day; crawlers get none)
- settlement: USDC on Base mainnet `0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913`, payee `0x05e82e03753c7bc99fb24d10a876cce53f24b7b7`, scheme `exact`
- sandbox: append `?network=base-sepolia` for testnet USDC + mock data
- results key: `organic_results`
- html: https://marketplaceforaiagents.com/listings/google-scholar

## What it returns

Academic paper search with titles, authors, publication info, citation counts, and PDF links.

## Use cases

- Literature review automation
- Find primary sources for a claim

## Parameters

| param | type | required | default | description |
| --- | --- | --- | --- | --- |
| `q` | string | yes | — | Academic search query |
| `hl` | string | no | en | UI/interface language code |
| `num` | integer | no | 10 | Number of results to return |
| `page` | integer | no | — | Page number for pagination |

## Example call

```bash
curl -s "https://marketplaceforaiagents.com/api/public/v1/google-scholar?q=example"
```

## Response shape

```json
{
  "search_metadata": {
    "id": "search_...",
    "status": "Success",
    "created_at": "2026-06-18T12:00:00Z"
  },
  "search_parameters": {
    "engine": "google_scholar",
    "q": "example"
  },
  "organic_results": [
    {
      "position": 1,
      "title": "Example result",
      "link": "https://example.com/1",
      "snippet": "Structured JSON result."
    }
  ]
}
```

## Payment

1. Call without `X-PAYMENT`. The first 3 calls per identity (across all endpoints) return 200 with an `X-Free-Calls-Remaining` header.
2. After that the response is `402` with an `accepts[]` requirement.
3. Sign the EIP-3009 USDC authorization, base64 the x402 payload, resend as `X-PAYMENT`.
4. Settlement receipt returns in the `X-PAYMENT-RESPONSE` header.


---

# Google Scholar Author API

Give an author_id, get their articles, h-index, and citation history.

- endpoint: `GET https://marketplaceforaiagents.com/api/public/v1/google-scholar-author`
- category: academic
- price: $0.005 USDC per call (5000 atomic, 6 decimals)
- free tier: 3 calls per agent identity, shared across all endpoints (unknown/generic clients draw from a site-wide 100 successful free calls per UTC day; crawlers get none)
- settlement: USDC on Base mainnet `0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913`, payee `0x05e82e03753c7bc99fb24d10a876cce53f24b7b7`, scheme `exact`
- sandbox: append `?network=base-sepolia` for testnet USDC + mock data
- results key: `articles`
- html: https://marketplaceforaiagents.com/listings/google-scholar-author

## What it returns

Full publication list and citation metrics for a specific Scholar author ID.

## Use cases

- Assess an expert's credibility
- Track a lab's publication output

## Parameters

| param | type | required | default | description |
| --- | --- | --- | --- | --- |
| `author_id` | string | yes | — | Google Scholar author ID |
| `hl` | string | no | en | UI/interface language code |

## Example call

```bash
curl -s "https://marketplaceforaiagents.com/api/public/v1/google-scholar-author?author_id=example"
```

## Response shape

```json
{
  "search_metadata": {
    "id": "search_...",
    "status": "Success",
    "created_at": "2026-06-18T12:00:00Z"
  },
  "search_parameters": {
    "engine": "google_scholar_author",
    "author_id": "example"
  },
  "articles": [
    {
      "position": 1,
      "title": "Example result",
      "link": "https://example.com/1",
      "snippet": "Structured JSON result."
    }
  ]
}
```

## Payment

1. Call without `X-PAYMENT`. The first 3 calls per identity (across all endpoints) return 200 with an `X-Free-Calls-Remaining` header.
2. After that the response is `402` with an `accepts[]` requirement.
3. Sign the EIP-3009 USDC authorization, base64 the x402 payload, resend as `X-PAYMENT`.
4. Settlement receipt returns in the `X-PAYMENT-RESPONSE` header.


---

# Google Patents API

Give a query, get patents with assignee, dates, and abstract text.

- endpoint: `GET https://marketplaceforaiagents.com/api/public/v1/google-patents`
- category: academic
- price: $0.005 USDC per call (5000 atomic, 6 decimals)
- free tier: 3 calls per agent identity, shared across all endpoints (unknown/generic clients draw from a site-wide 100 successful free calls per UTC day; crawlers get none)
- settlement: USDC on Base mainnet `0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913`, payee `0x05e82e03753c7bc99fb24d10a876cce53f24b7b7`, scheme `exact`
- sandbox: append `?network=base-sepolia` for testnet USDC + mock data
- results key: `organic_results`
- html: https://marketplaceforaiagents.com/listings/google-patents

## What it returns

Patent search with titles, assignees, filing and grant dates, abstracts, and PDF links.

## Use cases

- Prior-art scanning
- Track a competitor's IP filings

## Parameters

| param | type | required | default | description |
| --- | --- | --- | --- | --- |
| `q` | string | yes | — | Patent search query |
| `num` | integer | no | 10 | Number of results to return |
| `page` | integer | no | — | Page number for pagination |

## Example call

```bash
curl -s "https://marketplaceforaiagents.com/api/public/v1/google-patents?q=example"
```

## Response shape

```json
{
  "search_metadata": {
    "id": "search_...",
    "status": "Success",
    "created_at": "2026-06-18T12:00:00Z"
  },
  "search_parameters": {
    "engine": "google_patents",
    "q": "example"
  },
  "organic_results": [
    {
      "position": 1,
      "title": "Example result",
      "link": "https://example.com/1",
      "snippet": "Structured JSON result."
    }
  ]
}
```

## Payment

1. Call without `X-PAYMENT`. The first 3 calls per identity (across all endpoints) return 200 with an `X-Free-Calls-Remaining` header.
2. After that the response is `402` with an `accepts[]` requirement.
3. Sign the EIP-3009 USDC authorization, base64 the x402 payload, resend as `X-PAYMENT`.
4. Settlement receipt returns in the `X-PAYMENT-RESPONSE` header.


---

# Google Jobs API

Give a role query and location, get job postings with apply URLs and job IDs.

- endpoint: `GET https://marketplaceforaiagents.com/api/public/v1/google-jobs`
- category: jobs
- price: $0.005 USDC per call (5000 atomic, 6 decimals)
- free tier: 3 calls per agent identity, shared across all endpoints (unknown/generic clients draw from a site-wide 100 successful free calls per UTC day; crawlers get none)
- settlement: USDC on Base mainnet `0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913`, payee `0x05e82e03753c7bc99fb24d10a876cce53f24b7b7`, scheme `exact`
- sandbox: append `?network=base-sepolia` for testnet USDC + mock data
- results key: `jobs`
- html: https://marketplaceforaiagents.com/listings/google-jobs

## What it returns

Job postings aggregated by Google Jobs with title, company, location, posting age, and apply links.

## Use cases

- Automated job sourcing
- Hiring-signal analysis for a company

## Parameters

| param | type | required | default | description |
| --- | --- | --- | --- | --- |
| `q` | string | yes | — | Job title or role query |
| `location` | string | no | — | Localization, e.g. Austin,Texas,United States |
| `gl` | string | no | us | Country code for results |
| `hl` | string | no | en | UI/interface language code |

## Example call

```bash
curl -s "https://marketplaceforaiagents.com/api/public/v1/google-jobs?q=example"
```

## Response shape

```json
{
  "search_metadata": {
    "id": "search_...",
    "status": "Success",
    "created_at": "2026-06-18T12:00:00Z"
  },
  "search_parameters": {
    "engine": "google_jobs",
    "q": "example"
  },
  "jobs": [
    {
      "position": 1,
      "title": "Example result",
      "link": "https://example.com/1",
      "snippet": "Structured JSON result."
    }
  ]
}
```

## Payment

1. Call without `X-PAYMENT`. The first 3 calls per identity (across all endpoints) return 200 with an `X-Free-Calls-Remaining` header.
2. After that the response is `402` with an `accepts[]` requirement.
3. Sign the EIP-3009 USDC authorization, base64 the x402 payload, resend as `X-PAYMENT`.
4. Settlement receipt returns in the `X-PAYMENT-RESPONSE` header.


---

# Google Finance API

Give a ticker like NASDAQ:AAPL, get current price, movement, and key financial stats.

- endpoint: `GET https://marketplaceforaiagents.com/api/public/v1/google-finance`
- category: finance
- price: $0.005 USDC per call (5000 atomic, 6 decimals)
- free tier: 3 calls per agent identity, shared across all endpoints (unknown/generic clients draw from a site-wide 100 successful free calls per UTC day; crawlers get none)
- settlement: USDC on Base mainnet `0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913`, payee `0x05e82e03753c7bc99fb24d10a876cce53f24b7b7`, scheme `exact`
- sandbox: append `?network=base-sepolia` for testnet USDC + mock data
- results key: `summary`
- html: https://marketplaceforaiagents.com/listings/google-finance

## What it returns

Quotes, price graphs, key stats, and related news for tickers, indexes, currencies, and crypto.

## Use cases

- Quote lookup inside a trading agent
- Fundamentals for a research memo

## Parameters

| param | type | required | default | description |
| --- | --- | --- | --- | --- |
| `q` | string | yes | — | Ticker in EXCHANGE:SYMBOL form, e.g. NASDAQ:AAPL |
| `hl` | string | no | en | UI/interface language code |

## Example call

```bash
curl -s "https://marketplaceforaiagents.com/api/public/v1/google-finance?q=example"
```

## Response shape

```json
{
  "search_metadata": {
    "id": "search_...",
    "status": "Success",
    "created_at": "2026-06-18T12:00:00Z"
  },
  "search_parameters": {
    "engine": "google_finance",
    "q": "example"
  },
  "summary": [
    {
      "position": 1,
      "title": "Example result",
      "link": "https://example.com/1",
      "snippet": "Structured JSON result."
    }
  ]
}
```

## Payment

1. Call without `X-PAYMENT`. The first 3 calls per identity (across all endpoints) return 200 with an `X-Free-Calls-Remaining` header.
2. After that the response is `402` with an `accepts[]` requirement.
3. Sign the EIP-3009 USDC authorization, base64 the x402 payload, resend as `X-PAYMENT`.
4. Settlement receipt returns in the `X-PAYMENT-RESPONSE` header.


---

# Google Flights API

Give origin, destination, and dates, get priced itineraries with legs and durations.

- endpoint: `GET https://marketplaceforaiagents.com/api/public/v1/google-flights`
- category: travel
- price: $0.005 USDC per call (5000 atomic, 6 decimals)
- free tier: 3 calls per agent identity, shared across all endpoints (unknown/generic clients draw from a site-wide 100 successful free calls per UTC day; crawlers get none)
- settlement: USDC on Base mainnet `0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913`, payee `0x05e82e03753c7bc99fb24d10a876cce53f24b7b7`, scheme `exact`
- sandbox: append `?network=base-sepolia` for testnet USDC + mock data
- results key: `best_flights`
- html: https://marketplaceforaiagents.com/listings/google-flights

## What it returns

Flight itineraries with airlines, prices, durations, stops, and carbon estimates.

## Use cases

- Booking-agent price search
- Travel budget planning

## Parameters

| param | type | required | default | description |
| --- | --- | --- | --- | --- |
| `departure_id` | string | yes | — | Origin airport or city code, e.g. JFK |
| `arrival_id` | string | yes | — | Destination airport or city code, e.g. LHR |
| `outbound_date` | date | yes | — | YYYY-MM-DD |
| `return_date` | date | no | — | YYYY-MM-DD for round trips. Omit for one-way. |
| `flight_type` | string | no | — | one_way | round_trip. Optional: when return_date is absent the gateway sets one_way automatically. |
| `currency` | string | no | USD | Currency code for prices |

## Example call

```bash
curl -s "https://marketplaceforaiagents.com/api/public/v1/google-flights?departure_id=example&arrival_id=example&outbound_date=example"
```

## Response shape

```json
{
  "search_metadata": {
    "id": "search_...",
    "status": "Success",
    "created_at": "2026-06-18T12:00:00Z"
  },
  "search_parameters": {
    "engine": "google_flights",
    "departure_id": "example"
  },
  "best_flights": [
    {
      "position": 1,
      "title": "Example result",
      "link": "https://example.com/1",
      "snippet": "Structured JSON result."
    }
  ]
}
```

## Payment

1. Call without `X-PAYMENT`. The first 3 calls per identity (across all endpoints) return 200 with an `X-Free-Calls-Remaining` header.
2. After that the response is `402` with an `accepts[]` requirement.
3. Sign the EIP-3009 USDC authorization, base64 the x402 payload, resend as `X-PAYMENT`.
4. Settlement receipt returns in the `X-PAYMENT-RESPONSE` header.


---

# Google Hotels API

Give a destination and date range, get properties with rates and ratings.

- endpoint: `GET https://marketplaceforaiagents.com/api/public/v1/google-hotels`
- category: travel
- price: $0.005 USDC per call (5000 atomic, 6 decimals)
- free tier: 3 calls per agent identity, shared across all endpoints (unknown/generic clients draw from a site-wide 100 successful free calls per UTC day; crawlers get none)
- settlement: USDC on Base mainnet `0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913`, payee `0x05e82e03753c7bc99fb24d10a876cce53f24b7b7`, scheme `exact`
- sandbox: append `?network=base-sepolia` for testnet USDC + mock data
- results key: `properties`
- html: https://marketplaceforaiagents.com/listings/google-hotels

## What it returns

Hotel and vacation rental listings with nightly rates, ratings, amenities, and availability.

## Use cases

- Accommodation comparison for a trip agent
- Rate monitoring for a market

## Parameters

| param | type | required | default | description |
| --- | --- | --- | --- | --- |
| `q` | string | yes | — | Destination query, e.g. Austin hotels |
| `check_in_date` | date | yes | — | YYYY-MM-DD |
| `check_out_date` | date | yes | — | YYYY-MM-DD |
| `adults` | integer | no | 2 | Number of adult guests |
| `currency` | string | no | USD | Currency code for rates |

## Example call

```bash
curl -s "https://marketplaceforaiagents.com/api/public/v1/google-hotels?q=example&check_in_date=example&check_out_date=example"
```

## Response shape

```json
{
  "search_metadata": {
    "id": "search_...",
    "status": "Success",
    "created_at": "2026-06-18T12:00:00Z"
  },
  "search_parameters": {
    "engine": "google_hotels",
    "q": "example"
  },
  "properties": [
    {
      "position": 1,
      "title": "Example result",
      "link": "https://example.com/1",
      "snippet": "Structured JSON result."
    }
  ]
}
```

## Payment

1. Call without `X-PAYMENT`. The first 3 calls per identity (across all endpoints) return 200 with an `X-Free-Calls-Remaining` header.
2. After that the response is `402` with an `accepts[]` requirement.
3. Sign the EIP-3009 USDC authorization, base64 the x402 payload, resend as `X-PAYMENT`.
4. Settlement receipt returns in the `X-PAYMENT-RESPONSE` header.


---

# Google Events API

Give an event query and a required location, get events with dates, venues, and ticket URLs.

- endpoint: `GET https://marketplaceforaiagents.com/api/public/v1/google-events`
- category: places
- price: $0.005 USDC per call (5000 atomic, 6 decimals)
- free tier: 3 calls per agent identity, shared across all endpoints (unknown/generic clients draw from a site-wide 100 successful free calls per UTC day; crawlers get none)
- settlement: USDC on Base mainnet `0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913`, payee `0x05e82e03753c7bc99fb24d10a876cce53f24b7b7`, scheme `exact`
- sandbox: append `?network=base-sepolia` for testnet USDC + mock data
- results key: `events`
- html: https://marketplaceforaiagents.com/listings/google-events

## What it returns

Local and online events with dates, venues, addresses, and ticket links. Requires a location.

## Use cases

- Local event discovery agents
- Conference tracking in a niche

## Parameters

| param | type | required | default | description |
| --- | --- | --- | --- | --- |
| `q` | string | yes | — | Event query, e.g. AI meetups |
| `location` | string | yes | — | Localization, e.g. Austin,Texas,United States |
| `hl` | string | no | en | UI/interface language code |

## Example call

```bash
curl -s "https://marketplaceforaiagents.com/api/public/v1/google-events?q=example&location=example"
```

## Response shape

```json
{
  "search_metadata": {
    "id": "search_...",
    "status": "Success",
    "created_at": "2026-06-18T12:00:00Z"
  },
  "search_parameters": {
    "engine": "google_events",
    "q": "example"
  },
  "events": [
    {
      "position": 1,
      "title": "Example result",
      "link": "https://example.com/1",
      "snippet": "Structured JSON result."
    }
  ]
}
```

## Payment

1. Call without `X-PAYMENT`. The first 3 calls per identity (across all endpoints) return 200 with an `X-Free-Calls-Remaining` header.
2. After that the response is `402` with an `accepts[]` requirement.
3. Sign the EIP-3009 USDC authorization, base64 the x402 payload, resend as `X-PAYMENT`.
4. Settlement receipt returns in the `X-PAYMENT-RESPONSE` header.


---

# Google Play API

Give a query, get Play Store apps with package IDs, ratings, and pricing.

- endpoint: `GET https://marketplaceforaiagents.com/api/public/v1/google-play`
- category: app stores
- price: $0.005 USDC per call (5000 atomic, 6 decimals)
- free tier: 3 calls per agent identity, shared across all endpoints (unknown/generic clients draw from a site-wide 100 successful free calls per UTC day; crawlers get none)
- settlement: USDC on Base mainnet `0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913`, payee `0x05e82e03753c7bc99fb24d10a876cce53f24b7b7`, scheme `exact`
- sandbox: append `?network=base-sepolia` for testnet USDC + mock data
- results key: `organic_results`
- html: https://marketplaceforaiagents.com/listings/google-play

## What it returns

Google Play Store search: apps and games with developer, rating, installs, and price.

## Use cases

- App market research
- Competitor tracking in a category

## Parameters

| param | type | required | default | description |
| --- | --- | --- | --- | --- |
| `q` | string | yes | — | App search query |
| `store` | string | no | apps | apps | games | movies | books |
| `gl` | string | no | us | Country code for results |
| `hl` | string | no | en | UI/interface language code |

## Example call

```bash
curl -s "https://marketplaceforaiagents.com/api/public/v1/google-play?q=example"
```

## Response shape

```json
{
  "search_metadata": {
    "id": "search_...",
    "status": "Success",
    "created_at": "2026-06-18T12:00:00Z"
  },
  "search_parameters": {
    "engine": "google_play_store",
    "q": "example"
  },
  "organic_results": [
    {
      "position": 1,
      "title": "Example result",
      "link": "https://example.com/1",
      "snippet": "Structured JSON result."
    }
  ]
}
```

## Payment

1. Call without `X-PAYMENT`. The first 3 calls per identity (across all endpoints) return 200 with an `X-Free-Calls-Remaining` header.
2. After that the response is `402` with an `accepts[]` requirement.
3. Sign the EIP-3009 USDC authorization, base64 the x402 payload, resend as `X-PAYMENT`.
4. Settlement receipt returns in the `X-PAYMENT-RESPONSE` header.


---

# Apple App Store API

Give a query, get iOS apps with developer, rating, and app IDs.

- endpoint: `GET https://marketplaceforaiagents.com/api/public/v1/apple-app-store`
- category: app stores
- price: $0.005 USDC per call (5000 atomic, 6 decimals)
- free tier: 3 calls per agent identity, shared across all endpoints (unknown/generic clients draw from a site-wide 100 successful free calls per UTC day; crawlers get none)
- settlement: USDC on Base mainnet `0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913`, payee `0x05e82e03753c7bc99fb24d10a876cce53f24b7b7`, scheme `exact`
- sandbox: append `?network=base-sepolia` for testnet USDC + mock data
- results key: `organic_results`
- html: https://marketplaceforaiagents.com/listings/apple-app-store

## What it returns

Apple App Store search results with app names, developers, ratings, and store links.

## Use cases

- iOS competitor analysis
- Verify an app's publisher

## Parameters

| param | type | required | default | description |
| --- | --- | --- | --- | --- |
| `q` | string | yes | — | App search query |
| `country` | string | no | us | Storefront country code |

## Example call

```bash
curl -s "https://marketplaceforaiagents.com/api/public/v1/apple-app-store?q=example"
```

## Response shape

```json
{
  "search_metadata": {
    "id": "search_...",
    "status": "Success",
    "created_at": "2026-06-18T12:00:00Z"
  },
  "search_parameters": {
    "engine": "apple_app_store",
    "q": "example"
  },
  "organic_results": [
    {
      "position": 1,
      "title": "Example result",
      "link": "https://example.com/1",
      "snippet": "Structured JSON result."
    }
  ]
}
```

## Payment

1. Call without `X-PAYMENT`. The first 3 calls per identity (across all endpoints) return 200 with an `X-Free-Calls-Remaining` header.
2. After that the response is `402` with an `accepts[]` requirement.
3. Sign the EIP-3009 USDC authorization, base64 the x402 payload, resend as `X-PAYMENT`.
4. Settlement receipt returns in the `X-PAYMENT-RESPONSE` header.


---

# Bing Search API

Give a query, get Bing organic results — a second opinion against Google rankings.

- endpoint: `GET https://marketplaceforaiagents.com/api/public/v1/bing-search`
- category: web search
- price: $0.005 USDC per call (5000 atomic, 6 decimals)
- free tier: 3 calls per agent identity, shared across all endpoints (unknown/generic clients draw from a site-wide 100 successful free calls per UTC day; crawlers get none)
- settlement: USDC on Base mainnet `0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913`, payee `0x05e82e03753c7bc99fb24d10a876cce53f24b7b7`, scheme `exact`
- sandbox: append `?network=base-sepolia` for testnet USDC + mock data
- results key: `organic_results`
- html: https://marketplaceforaiagents.com/listings/bing-search

## What it returns

Real-time Bing SERP data with organic results, ads, related searches, and rich snippets.

## Use cases

- Cross-engine result verification
- Broaden retrieval coverage

## Parameters

| param | type | required | default | description |
| --- | --- | --- | --- | --- |
| `q` | string | yes | — | Search query |
| `num` | integer | no | 10 | Number of results to return |
| `mkt` | string | no | — | Market code, e.g. en-US |

## Example call

```bash
curl -s "https://marketplaceforaiagents.com/api/public/v1/bing-search?q=example"
```

## Response shape

```json
{
  "search_metadata": {
    "id": "search_...",
    "status": "Success",
    "created_at": "2026-06-18T12:00:00Z"
  },
  "search_parameters": {
    "engine": "bing",
    "q": "example"
  },
  "organic_results": [
    {
      "position": 1,
      "title": "Example result",
      "link": "https://example.com/1",
      "snippet": "Structured JSON result."
    }
  ]
}
```

## Payment

1. Call without `X-PAYMENT`. The first 3 calls per identity (across all endpoints) return 200 with an `X-Free-Calls-Remaining` header.
2. After that the response is `402` with an `accepts[]` requirement.
3. Sign the EIP-3009 USDC authorization, base64 the x402 payload, resend as `X-PAYMENT`.
4. Settlement receipt returns in the `X-PAYMENT-RESPONSE` header.


---

# Bing News API

Give a query, get Bing news items with source and publish time.

- endpoint: `GET https://marketplaceforaiagents.com/api/public/v1/bing-news`
- category: news
- price: $0.005 USDC per call (5000 atomic, 6 decimals)
- free tier: 3 calls per agent identity, shared across all endpoints (unknown/generic clients draw from a site-wide 100 successful free calls per UTC day; crawlers get none)
- settlement: USDC on Base mainnet `0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913`, payee `0x05e82e03753c7bc99fb24d10a876cce53f24b7b7`, scheme `exact`
- sandbox: append `?network=base-sepolia` for testnet USDC + mock data
- results key: `news_results`
- html: https://marketplaceforaiagents.com/listings/bing-news

## What it returns

Current news from Bing with headlines, source names, publish timestamps, and article URLs.

## Use cases

- News monitoring with a non-Google index
- Deduplicate coverage across engines

## Parameters

| param | type | required | default | description |
| --- | --- | --- | --- | --- |
| `q` | string | yes | — | News search query |
| `count` | integer | no | 10 | Number of articles |

## Example call

```bash
curl -s "https://marketplaceforaiagents.com/api/public/v1/bing-news?q=example"
```

## Response shape

```json
{
  "search_metadata": {
    "id": "search_...",
    "status": "Success",
    "created_at": "2026-06-18T12:00:00Z"
  },
  "search_parameters": {
    "engine": "bing_news",
    "q": "example"
  },
  "news_results": [
    {
      "position": 1,
      "title": "Example result",
      "link": "https://example.com/1",
      "snippet": "Structured JSON result."
    }
  ]
}
```

## Payment

1. Call without `X-PAYMENT`. The first 3 calls per identity (across all endpoints) return 200 with an `X-Free-Calls-Remaining` header.
2. After that the response is `402` with an `accepts[]` requirement.
3. Sign the EIP-3009 USDC authorization, base64 the x402 payload, resend as `X-PAYMENT`.
4. Settlement receipt returns in the `X-PAYMENT-RESPONSE` header.


---

# Bing Images API

Give a query, get Bing image results with original URLs.

- endpoint: `GET https://marketplaceforaiagents.com/api/public/v1/bing-images`
- category: images
- price: $0.005 USDC per call (5000 atomic, 6 decimals)
- free tier: 3 calls per agent identity, shared across all endpoints (unknown/generic clients draw from a site-wide 100 successful free calls per UTC day; crawlers get none)
- settlement: USDC on Base mainnet `0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913`, payee `0x05e82e03753c7bc99fb24d10a876cce53f24b7b7`, scheme `exact`
- sandbox: append `?network=base-sepolia` for testnet USDC + mock data
- results key: `images_results`
- html: https://marketplaceforaiagents.com/listings/bing-images

## What it returns

Bing image search with thumbnails, full-size URLs, dimensions, and host pages.

## Use cases

- Alternative image sourcing when Google is thin
- Broader visual coverage

## Parameters

| param | type | required | default | description |
| --- | --- | --- | --- | --- |
| `q` | string | yes | — | Image search query |
| `count` | integer | no | 10 | Number of images |

## Example call

```bash
curl -s "https://marketplaceforaiagents.com/api/public/v1/bing-images?q=example"
```

## Response shape

```json
{
  "search_metadata": {
    "id": "search_...",
    "status": "Success",
    "created_at": "2026-06-18T12:00:00Z"
  },
  "search_parameters": {
    "engine": "bing_images",
    "q": "example"
  },
  "images_results": [
    {
      "position": 1,
      "title": "Example result",
      "link": "https://example.com/1",
      "snippet": "Structured JSON result."
    }
  ]
}
```

## Payment

1. Call without `X-PAYMENT`. The first 3 calls per identity (across all endpoints) return 200 with an `X-Free-Calls-Remaining` header.
2. After that the response is `402` with an `accepts[]` requirement.
3. Sign the EIP-3009 USDC authorization, base64 the x402 payload, resend as `X-PAYMENT`.
4. Settlement receipt returns in the `X-PAYMENT-RESPONSE` header.


---

# Bing Videos API

Give a query, get video results across publishers with durations.

- endpoint: `GET https://marketplaceforaiagents.com/api/public/v1/bing-videos`
- category: video
- price: $0.005 USDC per call (5000 atomic, 6 decimals)
- free tier: 3 calls per agent identity, shared across all endpoints (unknown/generic clients draw from a site-wide 100 successful free calls per UTC day; crawlers get none)
- settlement: USDC on Base mainnet `0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913`, payee `0x05e82e03753c7bc99fb24d10a876cce53f24b7b7`, scheme `exact`
- sandbox: append `?network=base-sepolia` for testnet USDC + mock data
- results key: `video_results`
- html: https://marketplaceforaiagents.com/listings/bing-videos

## What it returns

Bing video search results with durations, publishers, thumbnails, and source links.

## Use cases

- Video coverage discovery
- Cross-engine media monitoring

## Parameters

| param | type | required | default | description |
| --- | --- | --- | --- | --- |
| `q` | string | yes | — | Video search query |
| `count` | integer | no | 10 | Number of videos |

## Example call

```bash
curl -s "https://marketplaceforaiagents.com/api/public/v1/bing-videos?q=example"
```

## Response shape

```json
{
  "search_metadata": {
    "id": "search_...",
    "status": "Success",
    "created_at": "2026-06-18T12:00:00Z"
  },
  "search_parameters": {
    "engine": "bing_videos",
    "q": "example"
  },
  "video_results": [
    {
      "position": 1,
      "title": "Example result",
      "link": "https://example.com/1",
      "snippet": "Structured JSON result."
    }
  ]
}
```

## Payment

1. Call without `X-PAYMENT`. The first 3 calls per identity (across all endpoints) return 200 with an `X-Free-Calls-Remaining` header.
2. After that the response is `402` with an `accepts[]` requirement.
3. Sign the EIP-3009 USDC authorization, base64 the x402 payload, resend as `X-PAYMENT`.
4. Settlement receipt returns in the `X-PAYMENT-RESPONSE` header.


---

# DuckDuckGo Search API

Give a query, get DuckDuckGo organic results with title, link, and snippet.

- endpoint: `GET https://marketplaceforaiagents.com/api/public/v1/duckduckgo-search`
- category: web search
- price: $0.005 USDC per call (5000 atomic, 6 decimals)
- free tier: 3 calls per agent identity, shared across all endpoints (unknown/generic clients draw from a site-wide 100 successful free calls per UTC day; crawlers get none)
- settlement: USDC on Base mainnet `0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913`, payee `0x05e82e03753c7bc99fb24d10a876cce53f24b7b7`, scheme `exact`
- sandbox: append `?network=base-sepolia` for testnet USDC + mock data
- results key: `organic_results`
- html: https://marketplaceforaiagents.com/listings/duckduckgo-search

## What it returns

DuckDuckGo organic results — a privacy-oriented index with different ranking behavior.

## Use cases

- Reduce personalization bias in retrieval
- Third opinion on rankings

## Parameters

| param | type | required | default | description |
| --- | --- | --- | --- | --- |
| `q` | string | yes | — | Search query |
| `gl` | string | no | us | Country code for results |
| `hl` | string | no | en | UI/interface language code |

## Example call

```bash
curl -s "https://marketplaceforaiagents.com/api/public/v1/duckduckgo-search?q=example"
```

## Response shape

```json
{
  "search_metadata": {
    "id": "search_...",
    "status": "Success",
    "created_at": "2026-06-18T12:00:00Z"
  },
  "search_parameters": {
    "engine": "duckduckgo",
    "q": "example"
  },
  "organic_results": [
    {
      "position": 1,
      "title": "Example result",
      "link": "https://example.com/1",
      "snippet": "Structured JSON result."
    }
  ]
}
```

## Payment

1. Call without `X-PAYMENT`. The first 3 calls per identity (across all endpoints) return 200 with an `X-Free-Calls-Remaining` header.
2. After that the response is `402` with an `accepts[]` requirement.
3. Sign the EIP-3009 USDC authorization, base64 the x402 payload, resend as `X-PAYMENT`.
4. Settlement receipt returns in the `X-PAYMENT-RESPONSE` header.


---

# Yandex Search API

Give a query, get Yandex organic results for regional coverage.

- endpoint: `GET https://marketplaceforaiagents.com/api/public/v1/yandex-search`
- category: web search
- price: $0.005 USDC per call (5000 atomic, 6 decimals)
- free tier: 3 calls per agent identity, shared across all endpoints (unknown/generic clients draw from a site-wide 100 successful free calls per UTC day; crawlers get none)
- settlement: USDC on Base mainnet `0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913`, payee `0x05e82e03753c7bc99fb24d10a876cce53f24b7b7`, scheme `exact`
- sandbox: append `?network=base-sepolia` for testnet USDC + mock data
- results key: `organic_results`
- html: https://marketplaceforaiagents.com/listings/yandex-search

## What it returns

Yandex SERP data — strongest coverage for Russian-language and regional CIS content.

## Use cases

- Research non-English regional sources
- Regional market monitoring

## Parameters

| param | type | required | default | description |
| --- | --- | --- | --- | --- |
| `q` | string | yes | — | Search query |
| `lr` | string | no | — | Region ID |

## Example call

```bash
curl -s "https://marketplaceforaiagents.com/api/public/v1/yandex-search?q=example"
```

## Response shape

```json
{
  "search_metadata": {
    "id": "search_...",
    "status": "Success",
    "created_at": "2026-06-18T12:00:00Z"
  },
  "search_parameters": {
    "engine": "yandex",
    "q": "example"
  },
  "organic_results": [
    {
      "position": 1,
      "title": "Example result",
      "link": "https://example.com/1",
      "snippet": "Structured JSON result."
    }
  ]
}
```

## Payment

1. Call without `X-PAYMENT`. The first 3 calls per identity (across all endpoints) return 200 with an `X-Free-Calls-Remaining` header.
2. After that the response is `402` with an `accepts[]` requirement.
3. Sign the EIP-3009 USDC authorization, base64 the x402 payload, resend as `X-PAYMENT`.
4. Settlement receipt returns in the `X-PAYMENT-RESPONSE` header.


---

# Baidu Search API

Give a query, get Baidu organic results for China-market coverage.

- endpoint: `GET https://marketplaceforaiagents.com/api/public/v1/baidu-search`
- category: web search
- price: $0.005 USDC per call (5000 atomic, 6 decimals)
- free tier: 3 calls per agent identity, shared across all endpoints (unknown/generic clients draw from a site-wide 100 successful free calls per UTC day; crawlers get none)
- settlement: USDC on Base mainnet `0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913`, payee `0x05e82e03753c7bc99fb24d10a876cce53f24b7b7`, scheme `exact`
- sandbox: append `?network=base-sepolia` for testnet USDC + mock data
- results key: `organic_results`
- html: https://marketplaceforaiagents.com/listings/baidu-search

## What it returns

Baidu SERP data for Chinese-language web research.

## Use cases

- China market research
- Chinese-language source discovery

## Parameters

| param | type | required | default | description |
| --- | --- | --- | --- | --- |
| `q` | string | yes | — | Search query |
| `num` | integer | no | 10 | Number of results to return |

## Example call

```bash
curl -s "https://marketplaceforaiagents.com/api/public/v1/baidu-search?q=example"
```

## Response shape

```json
{
  "search_metadata": {
    "id": "search_...",
    "status": "Success",
    "created_at": "2026-06-18T12:00:00Z"
  },
  "search_parameters": {
    "engine": "baidu",
    "q": "example"
  },
  "organic_results": [
    {
      "position": 1,
      "title": "Example result",
      "link": "https://example.com/1",
      "snippet": "Structured JSON result."
    }
  ]
}
```

## Payment

1. Call without `X-PAYMENT`. The first 3 calls per identity (across all endpoints) return 200 with an `X-Free-Calls-Remaining` header.
2. After that the response is `402` with an `accepts[]` requirement.
3. Sign the EIP-3009 USDC authorization, base64 the x402 payload, resend as `X-PAYMENT`.
4. Settlement receipt returns in the `X-PAYMENT-RESPONSE` header.


---

# Naver Search API

Give a query, get Naver results across web, blog, and news verticals.

- endpoint: `GET https://marketplaceforaiagents.com/api/public/v1/naver-search`
- category: web search
- price: $0.005 USDC per call (5000 atomic, 6 decimals)
- free tier: 3 calls per agent identity, shared across all endpoints (unknown/generic clients draw from a site-wide 100 successful free calls per UTC day; crawlers get none)
- settlement: USDC on Base mainnet `0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913`, payee `0x05e82e03753c7bc99fb24d10a876cce53f24b7b7`, scheme `exact`
- sandbox: append `?network=base-sepolia` for testnet USDC + mock data
- results key: `organic_results`
- html: https://marketplaceforaiagents.com/listings/naver-search

## What it returns

Naver SERP data covering Korea's dominant search portal, including blogs and cafes.

## Use cases

- Korean market research
- Local sentiment sourcing

## Parameters

| param | type | required | default | description |
| --- | --- | --- | --- | --- |
| `q` | string | yes | — | Search query |
| `where` | string | no | web | Vertical: web | news | blog | image |

## Example call

```bash
curl -s "https://marketplaceforaiagents.com/api/public/v1/naver-search?q=example"
```

## Response shape

```json
{
  "search_metadata": {
    "id": "search_...",
    "status": "Success",
    "created_at": "2026-06-18T12:00:00Z"
  },
  "search_parameters": {
    "engine": "naver",
    "q": "example"
  },
  "organic_results": [
    {
      "position": 1,
      "title": "Example result",
      "link": "https://example.com/1",
      "snippet": "Structured JSON result."
    }
  ]
}
```

## Payment

1. Call without `X-PAYMENT`. The first 3 calls per identity (across all endpoints) return 200 with an `X-Free-Calls-Remaining` header.
2. After that the response is `402` with an `accepts[]` requirement.
3. Sign the EIP-3009 USDC authorization, base64 the x402 payload, resend as `X-PAYMENT`.
4. Settlement receipt returns in the `X-PAYMENT-RESPONSE` header.


---

# Yahoo Search API

Give a query, get Yahoo organic results.

- endpoint: `GET https://marketplaceforaiagents.com/api/public/v1/yahoo-search`
- category: web search
- price: $0.005 USDC per call (5000 atomic, 6 decimals)
- free tier: 3 calls per agent identity, shared across all endpoints (unknown/generic clients draw from a site-wide 100 successful free calls per UTC day; crawlers get none)
- settlement: USDC on Base mainnet `0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913`, payee `0x05e82e03753c7bc99fb24d10a876cce53f24b7b7`, scheme `exact`
- sandbox: append `?network=base-sepolia` for testnet USDC + mock data
- results key: `organic_results`
- html: https://marketplaceforaiagents.com/listings/yahoo-search

## What it returns

Yahoo SERP data with organic results and related searches.

## Use cases

- Extra retrieval breadth
- Legacy-index comparison

## Parameters

| param | type | required | default | description |
| --- | --- | --- | --- | --- |
| `q` | string | yes | — | Search query |
| `num` | integer | no | 10 | Number of results to return |
| `page` | integer | no | — | Page number for pagination |

## Example call

```bash
curl -s "https://marketplaceforaiagents.com/api/public/v1/yahoo-search?q=example"
```

## Response shape

```json
{
  "search_metadata": {
    "id": "search_...",
    "status": "Success",
    "created_at": "2026-06-18T12:00:00Z"
  },
  "search_parameters": {
    "engine": "yahoo",
    "q": "example"
  },
  "organic_results": [
    {
      "position": 1,
      "title": "Example result",
      "link": "https://example.com/1",
      "snippet": "Structured JSON result."
    }
  ]
}
```

## Payment

1. Call without `X-PAYMENT`. The first 3 calls per identity (across all endpoints) return 200 with an `X-Free-Calls-Remaining` header.
2. After that the response is `402` with an `accepts[]` requirement.
3. Sign the EIP-3009 USDC authorization, base64 the x402 payload, resend as `X-PAYMENT`.
4. Settlement receipt returns in the `X-PAYMENT-RESPONSE` header.


---

# Amazon Search API

Give a product query, get Amazon listings with ASIN, price, and rating.

- endpoint: `GET https://marketplaceforaiagents.com/api/public/v1/amazon-search`
- category: commerce
- price: $0.005 USDC per call (5000 atomic, 6 decimals)
- free tier: 3 calls per agent identity, shared across all endpoints (unknown/generic clients draw from a site-wide 100 successful free calls per UTC day; crawlers get none)
- settlement: USDC on Base mainnet `0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913`, payee `0x05e82e03753c7bc99fb24d10a876cce53f24b7b7`, scheme `exact`
- sandbox: append `?network=base-sepolia` for testnet USDC + mock data
- results key: `organic_results`
- html: https://marketplaceforaiagents.com/listings/amazon-search

## What it returns

Amazon product search with ASINs, titles, prices, ratings, review counts, and Prime status.

## Use cases

- Shopping agents comparing offers
- Track a category's price distribution

## Parameters

| param | type | required | default | description |
| --- | --- | --- | --- | --- |
| `q` | string | yes | — | Product search query |
| `amazon_domain` | string | no | amazon.com | Marketplace domain |
| `page` | integer | no | — | Page number for pagination |

## Example call

```bash
curl -s "https://marketplaceforaiagents.com/api/public/v1/amazon-search?q=example"
```

## Response shape

```json
{
  "search_metadata": {
    "id": "search_...",
    "status": "Success",
    "created_at": "2026-06-18T12:00:00Z"
  },
  "search_parameters": {
    "engine": "amazon_search",
    "q": "example"
  },
  "organic_results": [
    {
      "position": 1,
      "title": "Example result",
      "link": "https://example.com/1",
      "snippet": "Structured JSON result."
    }
  ]
}
```

## Payment

1. Call without `X-PAYMENT`. The first 3 calls per identity (across all endpoints) return 200 with an `X-Free-Calls-Remaining` header.
2. After that the response is `402` with an `accepts[]` requirement.
3. Sign the EIP-3009 USDC authorization, base64 the x402 payload, resend as `X-PAYMENT`.
4. Settlement receipt returns in the `X-PAYMENT-RESPONSE` header.


---

# Amazon Product API

Give an ASIN, get the full product record including price, features, and images.

- endpoint: `GET https://marketplaceforaiagents.com/api/public/v1/amazon-product`
- category: commerce
- price: $0.005 USDC per call (5000 atomic, 6 decimals)
- free tier: 3 calls per agent identity, shared across all endpoints (unknown/generic clients draw from a site-wide 100 successful free calls per UTC day; crawlers get none)
- settlement: USDC on Base mainnet `0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913`, payee `0x05e82e03753c7bc99fb24d10a876cce53f24b7b7`, scheme `exact`
- sandbox: append `?network=base-sepolia` for testnet USDC + mock data
- results key: `product`
- html: https://marketplaceforaiagents.com/listings/amazon-product

## What it returns

Full Amazon product detail for an ASIN: pricing, variants, features, images, and rating breakdown.

## Use cases

- Validate a product before an agentic purchase
- Extract spec sheets into structured data

## Parameters

| param | type | required | default | description |
| --- | --- | --- | --- | --- |
| `asin` | string | yes | — | Amazon ASIN |
| `amazon_domain` | string | no | amazon.com | Marketplace domain |

## Example call

```bash
curl -s "https://marketplaceforaiagents.com/api/public/v1/amazon-product?asin=example"
```

## Response shape

```json
{
  "search_metadata": {
    "id": "search_...",
    "status": "Success",
    "created_at": "2026-06-18T12:00:00Z"
  },
  "search_parameters": {
    "engine": "amazon_product",
    "asin": "example"
  },
  "product": [
    {
      "position": 1,
      "title": "Example result",
      "link": "https://example.com/1",
      "snippet": "Structured JSON result."
    }
  ]
}
```

## Payment

1. Call without `X-PAYMENT`. The first 3 calls per identity (across all endpoints) return 200 with an `X-Free-Calls-Remaining` header.
2. After that the response is `402` with an `accepts[]` requirement.
3. Sign the EIP-3009 USDC authorization, base64 the x402 payload, resend as `X-PAYMENT`.
4. Settlement receipt returns in the `X-PAYMENT-RESPONSE` header.


---

# Amazon Reviews API

Give an ASIN, get review objects for sentiment and defect analysis.

- endpoint: `GET https://marketplaceforaiagents.com/api/public/v1/amazon-reviews`
- category: commerce
- price: $0.005 USDC per call (5000 atomic, 6 decimals)
- free tier: 3 calls per agent identity, shared across all endpoints (unknown/generic clients draw from a site-wide 100 successful free calls per UTC day; crawlers get none)
- settlement: USDC on Base mainnet `0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913`, payee `0x05e82e03753c7bc99fb24d10a876cce53f24b7b7`, scheme `exact`
- sandbox: append `?network=base-sepolia` for testnet USDC + mock data
- results key: `reviews`
- html: https://marketplaceforaiagents.com/listings/amazon-reviews

## What it returns

Customer reviews for an ASIN with rating, title, body, date, and verified-purchase status.

## Use cases

- Summarize product complaints
- Quality signal before recommending a product

## Parameters

| param | type | required | default | description |
| --- | --- | --- | --- | --- |
| `asin` | string | yes | — | Amazon ASIN |
| `amazon_domain` | string | no | amazon.com | Marketplace domain |
| `sort_by` | string | no | — | recent | helpful |
| `page` | integer | no | — | Page number for pagination |

## Example call

```bash
curl -s "https://marketplaceforaiagents.com/api/public/v1/amazon-reviews?asin=example"
```

## Response shape

```json
{
  "search_metadata": {
    "id": "search_...",
    "status": "Success",
    "created_at": "2026-06-18T12:00:00Z"
  },
  "search_parameters": {
    "engine": "amazon_product",
    "asin": "example"
  },
  "reviews": [
    {
      "position": 1,
      "title": "Example result",
      "link": "https://example.com/1",
      "snippet": "Structured JSON result."
    }
  ]
}
```

## Payment

1. Call without `X-PAYMENT`. The first 3 calls per identity (across all endpoints) return 200 with an `X-Free-Calls-Remaining` header.
2. After that the response is `402` with an `accepts[]` requirement.
3. Sign the EIP-3009 USDC authorization, base64 the x402 payload, resend as `X-PAYMENT`.
4. Settlement receipt returns in the `X-PAYMENT-RESPONSE` header.


---

# Walmart Search API

Give a query, get Walmart listings with price and product IDs.

- endpoint: `GET https://marketplaceforaiagents.com/api/public/v1/walmart-search`
- category: commerce
- price: $0.005 USDC per call (5000 atomic, 6 decimals)
- free tier: 3 calls per agent identity, shared across all endpoints (unknown/generic clients draw from a site-wide 100 successful free calls per UTC day; crawlers get none)
- settlement: USDC on Base mainnet `0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913`, payee `0x05e82e03753c7bc99fb24d10a876cce53f24b7b7`, scheme `exact`
- sandbox: append `?network=base-sepolia` for testnet USDC + mock data
- results key: `organic_results`
- html: https://marketplaceforaiagents.com/listings/walmart-search

## What it returns

Walmart catalog search with product IDs, prices, ratings, and availability.

## Use cases

- Multi-retailer price comparison
- Stock and availability checks

## Parameters

| param | type | required | default | description |
| --- | --- | --- | --- | --- |
| `q` | string | yes | — | Product search query |
| `page` | integer | no | — | Page number for pagination |

## Example call

```bash
curl -s "https://marketplaceforaiagents.com/api/public/v1/walmart-search?q=example"
```

## Response shape

```json
{
  "search_metadata": {
    "id": "search_...",
    "status": "Success",
    "created_at": "2026-06-18T12:00:00Z"
  },
  "search_parameters": {
    "engine": "walmart_search",
    "q": "example"
  },
  "organic_results": [
    {
      "position": 1,
      "title": "Example result",
      "link": "https://example.com/1",
      "snippet": "Structured JSON result."
    }
  ]
}
```

## Payment

1. Call without `X-PAYMENT`. The first 3 calls per identity (across all endpoints) return 200 with an `X-Free-Calls-Remaining` header.
2. After that the response is `402` with an `accepts[]` requirement.
3. Sign the EIP-3009 USDC authorization, base64 the x402 payload, resend as `X-PAYMENT`.
4. Settlement receipt returns in the `X-PAYMENT-RESPONSE` header.


---

# eBay Search API

Give a query, get eBay listings including auction state and condition.

- endpoint: `GET https://marketplaceforaiagents.com/api/public/v1/ebay-search`
- category: commerce
- price: $0.005 USDC per call (5000 atomic, 6 decimals)
- free tier: 3 calls per agent identity, shared across all endpoints (unknown/generic clients draw from a site-wide 100 successful free calls per UTC day; crawlers get none)
- settlement: USDC on Base mainnet `0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913`, payee `0x05e82e03753c7bc99fb24d10a876cce53f24b7b7`, scheme `exact`
- sandbox: append `?network=base-sepolia` for testnet USDC + mock data
- results key: `organic_results`
- html: https://marketplaceforaiagents.com/listings/ebay-search

## What it returns

eBay listings with prices, shipping, condition, bid counts, and seller info.

## Use cases

- Secondhand and collectible price discovery
- Arbitrage scanning

## Parameters

| param | type | required | default | description |
| --- | --- | --- | --- | --- |
| `q` | string | yes | — | Listing search query |
| `ebay_domain` | string | no | ebay.com | eBay marketplace domain |
| `page` | integer | no | — | Page number for pagination |

## Example call

```bash
curl -s "https://marketplaceforaiagents.com/api/public/v1/ebay-search?q=example"
```

## Response shape

```json
{
  "search_metadata": {
    "id": "search_...",
    "status": "Success",
    "created_at": "2026-06-18T12:00:00Z"
  },
  "search_parameters": {
    "engine": "ebay_search",
    "q": "example"
  },
  "organic_results": [
    {
      "position": 1,
      "title": "Example result",
      "link": "https://example.com/1",
      "snippet": "Structured JSON result."
    }
  ]
}
```

## Payment

1. Call without `X-PAYMENT`. The first 3 calls per identity (across all endpoints) return 200 with an `X-Free-Calls-Remaining` header.
2. After that the response is `402` with an `accepts[]` requirement.
3. Sign the EIP-3009 USDC authorization, base64 the x402 payload, resend as `X-PAYMENT`.
4. Settlement receipt returns in the `X-PAYMENT-RESPONSE` header.


---

# SERP Stack Intent

Give a query, get Google + Bing + DuckDuckGo organic results in one response.

- endpoint: `GET https://marketplaceforaiagents.com/api/public/v1/serp-stack`
- category: intents
- price: $0.005 USDC per call (5000 atomic, 6 decimals)
- free tier: 3 calls per agent identity, shared across all endpoints (unknown/generic clients draw from a site-wide 100 successful free calls per UTC day; crawlers get none)
- settlement: USDC on Base mainnet `0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913`, payee `0x05e82e03753c7bc99fb24d10a876cce53f24b7b7`, scheme `exact`
- sandbox: append `?network=base-sepolia` for testnet USDC + mock data
- results key: `results`
- html: https://marketplaceforaiagents.com/listings/serp-stack

## What it returns

One query, three independent search indexes: Google, Bing and DuckDuckGo organic results in a single paid call. Use it when a single index is not enough evidence for a grounded answer.

## Use cases

- Cross-index grounding before answering
- Detect index disagreement on a claim
- Broad citation gathering in one call

## Parameters

| param | type | required | default | description |
| --- | --- | --- | --- | --- |
| `q` | string | yes | — | Search query sent to all three engines |
| `gl` | string | no | us | Country code for results |
| `hl` | string | no | en | Interface language code |
| `num` | integer | no | 10 | Results per engine |

## Example call

```bash
curl -s "https://marketplaceforaiagents.com/api/public/v1/serp-stack?q=example"
```

## Response shape

```json
{
  "intent": "serp-stack",
  "chain": [
    "google-search",
    "bing-search",
    "duckduckgo-search"
  ],
  "steps_run": 3,
  "results": {
    "google-search": {
      "note": "Normalized response of /api/public/v1/google-search"
    },
    "bing-search": {
      "note": "Normalized response of /api/public/v1/bing-search"
    },
    "duckduckgo-search": {
      "note": "Normalized response of /api/public/v1/duckduckgo-search"
    }
  }
}
```

## Payment

1. Call without `X-PAYMENT`. The first 3 calls per identity (across all endpoints) return 200 with an `X-Free-Calls-Remaining` header.
2. After that the response is `402` with an `accepts[]` requirement.
3. Sign the EIP-3009 USDC authorization, base64 the x402 payload, resend as `X-PAYMENT`.
4. Settlement receipt returns in the `X-PAYMENT-RESPONSE` header.


---

# News Brief Intent

Give a topic, get Google News + Bing News articles in one response.

- endpoint: `GET https://marketplaceforaiagents.com/api/public/v1/news-brief`
- category: intents
- price: $0.005 USDC per call (5000 atomic, 6 decimals)
- free tier: 3 calls per agent identity, shared across all endpoints (unknown/generic clients draw from a site-wide 100 successful free calls per UTC day; crawlers get none)
- settlement: USDC on Base mainnet `0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913`, payee `0x05e82e03753c7bc99fb24d10a876cce53f24b7b7`, scheme `exact`
- sandbox: append `?network=base-sepolia` for testnet USDC + mock data
- results key: `results`
- html: https://marketplaceforaiagents.com/listings/news-brief

## What it returns

Recent coverage of a topic from two news indexes (Google News and Bing News) in one call, so a briefing agent is not anchored on a single publisher mix.

## Use cases

- Morning briefing generation
- Event coverage sweep
- Publisher-bias comparison

## Parameters

| param | type | required | default | description |
| --- | --- | --- | --- | --- |
| `q` | string | yes | — | News topic or entity |
| `gl` | string | no | us | Country code for results |
| `hl` | string | no | en | Interface language code |

## Example call

```bash
curl -s "https://marketplaceforaiagents.com/api/public/v1/news-brief?q=example"
```

## Response shape

```json
{
  "intent": "news-brief",
  "chain": [
    "google-news",
    "bing-news"
  ],
  "steps_run": 2,
  "results": {
    "google-news": {
      "note": "Normalized response of /api/public/v1/google-news"
    },
    "bing-news": {
      "note": "Normalized response of /api/public/v1/bing-news"
    }
  }
}
```

## Payment

1. Call without `X-PAYMENT`. The first 3 calls per identity (across all endpoints) return 200 with an `X-Free-Calls-Remaining` header.
2. After that the response is `402` with an `accepts[]` requirement.
3. Sign the EIP-3009 USDC authorization, base64 the x402 payload, resend as `X-PAYMENT`.
4. Settlement receipt returns in the `X-PAYMENT-RESPONSE` header.


---

# Brand Pulse Intent

Give a brand or ticker, get web results, news, and the finance quote together.

- endpoint: `GET https://marketplaceforaiagents.com/api/public/v1/brand-pulse`
- category: intents
- price: $0.005 USDC per call (5000 atomic, 6 decimals)
- free tier: 3 calls per agent identity, shared across all endpoints (unknown/generic clients draw from a site-wide 100 successful free calls per UTC day; crawlers get none)
- settlement: USDC on Base mainnet `0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913`, payee `0x05e82e03753c7bc99fb24d10a876cce53f24b7b7`, scheme `exact`
- sandbox: append `?network=base-sepolia` for testnet USDC + mock data
- results key: `results`
- html: https://marketplaceforaiagents.com/listings/brand-pulse

## What it returns

Web presence, news coverage and market quote for one brand or ticker in a single call: Google Search, Google News and Google Finance.

## Use cases

- Company due-diligence snapshot
- Pre-earnings context gathering
- Reputation monitoring

## Parameters

| param | type | required | default | description |
| --- | --- | --- | --- | --- |
| `q` | string | yes | — | Brand name, company, or ticker query |
| `ticker` | string | no | — | Finance symbol in EXCHANGE:SYMBOL form, e.g. NASDAQ:AAPL. Defaults to q. |
| `hl` | string | no | en | Interface language code |

## Example call

```bash
curl -s "https://marketplaceforaiagents.com/api/public/v1/brand-pulse?q=example"
```

## Response shape

```json
{
  "intent": "brand-pulse",
  "chain": [
    "google-search",
    "google-news",
    "google-finance"
  ],
  "steps_run": 3,
  "results": {
    "google-search": {
      "note": "Normalized response of /api/public/v1/google-search"
    },
    "google-news": {
      "note": "Normalized response of /api/public/v1/google-news"
    },
    "google-finance": {
      "note": "Normalized response of /api/public/v1/google-finance"
    }
  }
}
```

## Payment

1. Call without `X-PAYMENT`. The first 3 calls per identity (across all endpoints) return 200 with an `X-Free-Calls-Remaining` header.
2. After that the response is `402` with an `accepts[]` requirement.
3. Sign the EIP-3009 USDC authorization, base64 the x402 payload, resend as `X-PAYMENT`.
4. Settlement receipt returns in the `X-PAYMENT-RESPONSE` header.


---

# Deal Triage Intent

Give a product query (or ASIN), get shopping offers, the Amazon listing, and reviews.

- endpoint: `GET https://marketplaceforaiagents.com/api/public/v1/deal-triage`
- category: intents
- price: $0.005 USDC per call (5000 atomic, 6 decimals)
- free tier: 3 calls per agent identity, shared across all endpoints (unknown/generic clients draw from a site-wide 100 successful free calls per UTC day; crawlers get none)
- settlement: USDC on Base mainnet `0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913`, payee `0x05e82e03753c7bc99fb24d10a876cce53f24b7b7`, scheme `exact`
- sandbox: append `?network=base-sepolia` for testnet USDC + mock data
- results key: `results`
- html: https://marketplaceforaiagents.com/listings/deal-triage

## What it returns

Triage a purchase: Google Shopping offers, then the Amazon record (product detail when an ASIN is known or found, otherwise Amazon search), then Amazon reviews when an ASIN is resolvable.

## Use cases

- Pre-purchase check for a buying agent
- Offer vs marketplace price sanity check
- Fast quality screen before recommending

## Parameters

| param | type | required | default | description |
| --- | --- | --- | --- | --- |
| `q` | string | yes | — | Product query |
| `asin` | string | no | — | Amazon ASIN, when already known. Skips discovery. |
| `amazon_domain` | string | no | amazon.com | Amazon marketplace domain |

## Example call

```bash
curl -s "https://marketplaceforaiagents.com/api/public/v1/deal-triage?q=example"
```

## Response shape

```json
{
  "intent": "deal-triage",
  "chain": [
    "google-shopping",
    "amazon-product",
    "amazon-reviews"
  ],
  "steps_run": 3,
  "results": {
    "google-shopping": {
      "note": "Normalized response of /api/public/v1/google-shopping"
    },
    "amazon-product": {
      "note": "Normalized response of /api/public/v1/amazon-product"
    },
    "amazon-reviews": {
      "note": "Normalized response of /api/public/v1/amazon-reviews"
    }
  }
}
```

## Payment

1. Call without `X-PAYMENT`. The first 3 calls per identity (across all endpoints) return 200 with an `X-Free-Calls-Remaining` header.
2. After that the response is `402` with an `accepts[]` requirement.
3. Sign the EIP-3009 USDC authorization, base64 the x402 payload, resend as `X-PAYMENT`.
4. Settlement receipt returns in the `X-PAYMENT-RESPONSE` header.


---

# Cross-Store Price Intent

Give a product query, get offers from Google Shopping, Amazon, eBay and Walmart.

- endpoint: `GET https://marketplaceforaiagents.com/api/public/v1/cross-store-price`
- category: intents
- price: $0.005 USDC per call (5000 atomic, 6 decimals)
- free tier: 3 calls per agent identity, shared across all endpoints (unknown/generic clients draw from a site-wide 100 successful free calls per UTC day; crawlers get none)
- settlement: USDC on Base mainnet `0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913`, payee `0x05e82e03753c7bc99fb24d10a876cce53f24b7b7`, scheme `exact`
- sandbox: append `?network=base-sepolia` for testnet USDC + mock data
- results key: `results`
- html: https://marketplaceforaiagents.com/listings/cross-store-price

## What it returns

One product query priced across four retail surfaces in a single call: Google Shopping, Amazon, eBay and Walmart.

## Use cases

- Best-price selection for a purchasing agent
- Arbitrage scanning
- Retail price-spread analysis

## Parameters

| param | type | required | default | description |
| --- | --- | --- | --- | --- |
| `q` | string | yes | — | Product query sent to all four retail engines |
| `gl` | string | no | us | Country code for results |
| `hl` | string | no | en | Interface language code |

## Example call

```bash
curl -s "https://marketplaceforaiagents.com/api/public/v1/cross-store-price?q=example"
```

## Response shape

```json
{
  "intent": "cross-store-price",
  "chain": [
    "google-shopping",
    "amazon-search",
    "ebay-search",
    "walmart-search"
  ],
  "steps_run": 4,
  "results": {
    "google-shopping": {
      "note": "Normalized response of /api/public/v1/google-shopping"
    },
    "amazon-search": {
      "note": "Normalized response of /api/public/v1/amazon-search"
    },
    "ebay-search": {
      "note": "Normalized response of /api/public/v1/ebay-search"
    },
    "walmart-search": {
      "note": "Normalized response of /api/public/v1/walmart-search"
    }
  }
}
```

## Payment

1. Call without `X-PAYMENT`. The first 3 calls per identity (across all endpoints) return 200 with an `X-Free-Calls-Remaining` header.
2. After that the response is `402` with an `accepts[]` requirement.
3. Sign the EIP-3009 USDC authorization, base64 the x402 payload, resend as `X-PAYMENT`.
4. Settlement receipt returns in the `X-PAYMENT-RESPONSE` header.


---

# Review Risk Intent

Give an ASIN, get the Amazon product record and its reviews together.

- endpoint: `GET https://marketplaceforaiagents.com/api/public/v1/review-risk`
- category: intents
- price: $0.005 USDC per call (5000 atomic, 6 decimals)
- free tier: 3 calls per agent identity, shared across all endpoints (unknown/generic clients draw from a site-wide 100 successful free calls per UTC day; crawlers get none)
- settlement: USDC on Base mainnet `0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913`, payee `0x05e82e03753c7bc99fb24d10a876cce53f24b7b7`, scheme `exact`
- sandbox: append `?network=base-sepolia` for testnet USDC + mock data
- results key: `results`
- html: https://marketplaceforaiagents.com/listings/review-risk

## What it returns

Product record plus customer reviews for one ASIN, so a recommending agent can weigh specs against complaint patterns before it commits.

## Use cases

- Quality gate before recommending a product
- Defect and complaint clustering
- Return-risk estimation

## Parameters

| param | type | required | default | description |
| --- | --- | --- | --- | --- |
| `asin` | string | yes | — | Amazon ASIN |
| `amazon_domain` | string | no | amazon.com | Amazon marketplace domain |
| `sort_by` | string | no | — | Review sort: recent | helpful |

## Example call

```bash
curl -s "https://marketplaceforaiagents.com/api/public/v1/review-risk?asin=example"
```

## Response shape

```json
{
  "intent": "review-risk",
  "chain": [
    "amazon-product",
    "amazon-reviews"
  ],
  "steps_run": 2,
  "results": {
    "amazon-product": {
      "note": "Normalized response of /api/public/v1/amazon-product"
    },
    "amazon-reviews": {
      "note": "Normalized response of /api/public/v1/amazon-reviews"
    }
  }
}
```

## Payment

1. Call without `X-PAYMENT`. The first 3 calls per identity (across all endpoints) return 200 with an `X-Free-Calls-Remaining` header.
2. After that the response is `402` with an `accepts[]` requirement.
3. Sign the EIP-3009 USDC authorization, base64 the x402 payload, resend as `X-PAYMENT`.
4. Settlement receipt returns in the `X-PAYMENT-RESPONSE` header.


---

# Dual App Store Intent

Give an app query, get Google Play and Apple App Store results together.

- endpoint: `GET https://marketplaceforaiagents.com/api/public/v1/aso-dual`
- category: intents
- price: $0.005 USDC per call (5000 atomic, 6 decimals)
- free tier: 3 calls per agent identity, shared across all endpoints (unknown/generic clients draw from a site-wide 100 successful free calls per UTC day; crawlers get none)
- settlement: USDC on Base mainnet `0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913`, payee `0x05e82e03753c7bc99fb24d10a876cce53f24b7b7`, scheme `exact`
- sandbox: append `?network=base-sepolia` for testnet USDC + mock data
- results key: `results`
- html: https://marketplaceforaiagents.com/listings/aso-dual

## What it returns

The same app query run against Google Play and the Apple App Store, so an app-research agent sees both storefronts in one paid call.

## Use cases

- Cross-platform competitor research
- Verify an app ships on both stores
- App store optimization checks

## Parameters

| param | type | required | default | description |
| --- | --- | --- | --- | --- |
| `q` | string | yes | — | App search query |
| `country` | string | no | us | Apple storefront country code |
| `gl` | string | no | us | Country code for results |
| `hl` | string | no | en | Interface language code |

## Example call

```bash
curl -s "https://marketplaceforaiagents.com/api/public/v1/aso-dual?q=example"
```

## Response shape

```json
{
  "intent": "aso-dual",
  "chain": [
    "google-play",
    "apple-app-store"
  ],
  "steps_run": 2,
  "results": {
    "google-play": {
      "note": "Normalized response of /api/public/v1/google-play"
    },
    "apple-app-store": {
      "note": "Normalized response of /api/public/v1/apple-app-store"
    }
  }
}
```

## Payment

1. Call without `X-PAYMENT`. The first 3 calls per identity (across all endpoints) return 200 with an `X-Free-Calls-Remaining` header.
2. After that the response is `402` with an `accepts[]` requirement.
3. Sign the EIP-3009 USDC authorization, base64 the x402 payload, resend as `X-PAYMENT`.
4. Settlement receipt returns in the `X-PAYMENT-RESPONSE` header.


---

# Place Dossier Intent

Give a place query, get the matching business record plus its reviews.

- endpoint: `GET https://marketplaceforaiagents.com/api/public/v1/place-dossier`
- category: intents
- price: $0.005 USDC per call (5000 atomic, 6 decimals)
- free tier: 3 calls per agent identity, shared across all endpoints (unknown/generic clients draw from a site-wide 100 successful free calls per UTC day; crawlers get none)
- settlement: USDC on Base mainnet `0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913`, payee `0x05e82e03753c7bc99fb24d10a876cce53f24b7b7`, scheme `exact`
- sandbox: append `?network=base-sepolia` for testnet USDC + mock data
- results key: `results`
- html: https://marketplaceforaiagents.com/listings/place-dossier

## What it returns

Resolve a business or place from a query, then pull its Google Maps reviews — the place lookup and review fetch chained server-side.

## Use cases

- Vendor vetting for a local-services agent
- Sentiment summary for one location
- Contact + reputation dossier

## Parameters

| param | type | required | default | description |
| --- | --- | --- | --- | --- |
| `q` | string | yes | — | Place or business query, e.g. coffee in Austin |
| `place_id` | string | no | — | Skip discovery by supplying a known Google place ID |
| `sort_by` | string | no | — | relevance | newest | highest_rating | lowest_rating |
| `hl` | string | no | en | Interface language code |

## Example call

```bash
curl -s "https://marketplaceforaiagents.com/api/public/v1/place-dossier?q=example"
```

## Response shape

```json
{
  "intent": "place-dossier",
  "chain": [
    "google-maps",
    "google-maps-reviews"
  ],
  "steps_run": 2,
  "results": {
    "google-maps": {
      "note": "Normalized response of /api/public/v1/google-maps"
    },
    "google-maps-reviews": {
      "note": "Normalized response of /api/public/v1/google-maps-reviews"
    }
  }
}
```

## Payment

1. Call without `X-PAYMENT`. The first 3 calls per identity (across all endpoints) return 200 with an `X-Free-Calls-Remaining` header.
2. After that the response is `402` with an `accepts[]` requirement.
3. Sign the EIP-3009 USDC authorization, base64 the x402 payload, resend as `X-PAYMENT`.
4. Settlement receipt returns in the `X-PAYMENT-RESPONSE` header.


---

# Trip Skeleton Intent

Give route and dates, get flights and hotels (and events when location is set).

- endpoint: `GET https://marketplaceforaiagents.com/api/public/v1/trip-skeleton`
- category: intents
- price: $0.005 USDC per call (5000 atomic, 6 decimals)
- free tier: 3 calls per agent identity, shared across all endpoints (unknown/generic clients draw from a site-wide 100 successful free calls per UTC day; crawlers get none)
- settlement: USDC on Base mainnet `0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913`, payee `0x05e82e03753c7bc99fb24d10a876cce53f24b7b7`, scheme `exact`
- sandbox: append `?network=base-sepolia` for testnet USDC + mock data
- results key: `results`
- html: https://marketplaceforaiagents.com/listings/trip-skeleton

## What it returns

The bones of a trip in one call: priced flight itineraries and hotel options for the same dates, plus local events when a location is supplied.

## Use cases

- Draft an itinerary before human approval
- Travel budget estimation
- Compare trip windows

## Parameters

| param | type | required | default | description |
| --- | --- | --- | --- | --- |
| `departure_id` | string | yes | — | Origin airport or city code, e.g. ORD |
| `arrival_id` | string | yes | — | Destination airport or city code, e.g. LAX |
| `outbound_date` | date | yes | — | YYYY-MM-DD |
| `return_date` | date | no | — | YYYY-MM-DD for round trips. Omit for one-way. |
| `destination` | string | no | — | Hotel search destination. Defaults to arrival_id. |
| `check_in_date` | date | no | — | Hotel check-in. Defaults to outbound_date. |
| `check_out_date` | date | no | — | Hotel check-out. Defaults to return_date or outbound_date. |
| `location` | string | no | — | When set, adds a Google Events step for that location. |
| `currency` | string | no | USD | Currency code |

## Example call

```bash
curl -s "https://marketplaceforaiagents.com/api/public/v1/trip-skeleton?departure_id=example&arrival_id=example&outbound_date=example"
```

## Response shape

```json
{
  "intent": "trip-skeleton",
  "chain": [
    "google-flights",
    "google-hotels",
    "google-events"
  ],
  "steps_run": 3,
  "results": {
    "google-flights": {
      "note": "Normalized response of /api/public/v1/google-flights"
    },
    "google-hotels": {
      "note": "Normalized response of /api/public/v1/google-hotels"
    },
    "google-events": {
      "note": "Normalized response of /api/public/v1/google-events"
    }
  }
}
```

## Payment

1. Call without `X-PAYMENT`. The first 3 calls per identity (across all endpoints) return 200 with an `X-Free-Calls-Remaining` header.
2. After that the response is `402` with an `accepts[]` requirement.
3. Sign the EIP-3009 USDC authorization, base64 the x402 payload, resend as `X-PAYMENT`.
4. Settlement receipt returns in the `X-PAYMENT-RESPONSE` header.


---

# Video Digest Intent

Give a topic (or video_id), get the top video's metadata and full transcript.

- endpoint: `GET https://marketplaceforaiagents.com/api/public/v1/video-digest`
- category: intents
- price: $0.005 USDC per call (5000 atomic, 6 decimals)
- free tier: 3 calls per agent identity, shared across all endpoints (unknown/generic clients draw from a site-wide 100 successful free calls per UTC day; crawlers get none)
- settlement: USDC on Base mainnet `0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913`, payee `0x05e82e03753c7bc99fb24d10a876cce53f24b7b7`, scheme `exact`
- sandbox: append `?network=base-sepolia` for testnet USDC + mock data
- results key: `results`
- html: https://marketplaceforaiagents.com/listings/video-digest

## What it returns

Search YouTube for a topic, take the top video, pull its metadata, and return the full timestamped transcript — a research pipeline in one paid call.

## Use cases

- Summarize the best video on a topic
- Cite a video with timestamps
- Feed long-form video into RAG

## Parameters

| param | type | required | default | description |
| --- | --- | --- | --- | --- |
| `q` | string | no | — | Topic to search on YouTube. Required unless video_id is supplied. |
| `video_id` | string | no | — | Skip search by supplying a YouTube video ID or watch URL |
| `lang` | string | no | en | Transcript language code |

## Example call

```bash
curl -s "https://marketplaceforaiagents.com/api/public/v1/video-digest"
```

## Response shape

```json
{
  "intent": "video-digest",
  "chain": [
    "youtube-search",
    "youtube-video",
    "youtube-transcripts"
  ],
  "steps_run": 3,
  "results": {
    "youtube-search": {
      "note": "Normalized response of /api/public/v1/youtube-search"
    },
    "youtube-video": {
      "note": "Normalized response of /api/public/v1/youtube-video"
    },
    "youtube-transcripts": {
      "note": "Normalized response of /api/public/v1/youtube-transcripts"
    }
  }
}
```

## Payment

1. Call without `X-PAYMENT`. The first 3 calls per identity (across all endpoints) return 200 with an `X-Free-Calls-Remaining` header.
2. After that the response is `402` with an `accepts[]` requirement.
3. Sign the EIP-3009 USDC authorization, base64 the x402 payload, resend as `X-PAYMENT`.
4. Settlement receipt returns in the `X-PAYMENT-RESPONSE` header.


---

# Trend Then SERP Intent

Give a keyword, get its trend series and the current Google results.

- endpoint: `GET https://marketplaceforaiagents.com/api/public/v1/trend-then-serp`
- category: intents
- price: $0.005 USDC per call (5000 atomic, 6 decimals)
- free tier: 3 calls per agent identity, shared across all endpoints (unknown/generic clients draw from a site-wide 100 successful free calls per UTC day; crawlers get none)
- settlement: USDC on Base mainnet `0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913`, payee `0x05e82e03753c7bc99fb24d10a876cce53f24b7b7`, scheme `exact`
- sandbox: append `?network=base-sepolia` for testnet USDC + mock data
- results key: `results`
- html: https://marketplaceforaiagents.com/listings/trend-then-serp

## What it returns

Momentum first, evidence second: Google Trends interest for a keyword plus the live Google SERP for the same term in one call.

## Use cases

- Decide whether a topic is rising before writing
- Keyword prioritization
- Campaign timing checks

## Parameters

| param | type | required | default | description |
| --- | --- | --- | --- | --- |
| `q` | string | yes | — | Keyword to measure and search |
| `geo` | string | no | — | Trends country code, e.g. US |
| `date` | string | no | — | Trends time range, e.g. today 12-m |
| `gl` | string | no | us | Country code for results |
| `hl` | string | no | en | Interface language code |

## Example call

```bash
curl -s "https://marketplaceforaiagents.com/api/public/v1/trend-then-serp?q=example"
```

## Response shape

```json
{
  "intent": "trend-then-serp",
  "chain": [
    "google-trends",
    "google-search"
  ],
  "steps_run": 2,
  "results": {
    "google-trends": {
      "note": "Normalized response of /api/public/v1/google-trends"
    },
    "google-search": {
      "note": "Normalized response of /api/public/v1/google-search"
    }
  }
}
```

## Payment

1. Call without `X-PAYMENT`. The first 3 calls per identity (across all endpoints) return 200 with an `X-Free-Calls-Remaining` header.
2. After that the response is `402` with an `accepts[]` requirement.
3. Sign the EIP-3009 USDC authorization, base64 the x402 payload, resend as `X-PAYMENT`.
4. Settlement receipt returns in the `X-PAYMENT-RESPONSE` header.


---

# Image Provenance Intent

Give an image URL, get visual matches and pages hosting the exact image.

- endpoint: `GET https://marketplaceforaiagents.com/api/public/v1/image-provenance`
- category: intents
- price: $0.005 USDC per call (5000 atomic, 6 decimals)
- free tier: 3 calls per agent identity, shared across all endpoints (unknown/generic clients draw from a site-wide 100 successful free calls per UTC day; crawlers get none)
- settlement: USDC on Base mainnet `0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913`, payee `0x05e82e03753c7bc99fb24d10a876cce53f24b7b7`, scheme `exact`
- sandbox: append `?network=base-sepolia` for testnet USDC + mock data
- results key: `results`
- html: https://marketplaceforaiagents.com/listings/image-provenance

## What it returns

Two reverse-image passes on one image URL: Google Lens visual matches and Google exact matches, so a verification agent sees both similarity and provenance.

## Use cases

- Misinformation and provenance checks
- Copyright and reuse tracing
- Identify a product from a photo

## Parameters

| param | type | required | default | description |
| --- | --- | --- | --- | --- |
| `image_url` | string | yes | — | Publicly reachable image URL |
| `hl` | string | no | en | Interface language code |

## Example call

```bash
curl -s "https://marketplaceforaiagents.com/api/public/v1/image-provenance?image_url=example"
```

## Response shape

```json
{
  "intent": "image-provenance",
  "chain": [
    "google-lens",
    "google-reverse-image"
  ],
  "steps_run": 2,
  "results": {
    "google-lens": {
      "note": "Normalized response of /api/public/v1/google-lens"
    },
    "google-reverse-image": {
      "note": "Normalized response of /api/public/v1/google-reverse-image"
    }
  }
}
```

## Payment

1. Call without `X-PAYMENT`. The first 3 calls per identity (across all endpoints) return 200 with an `X-Free-Calls-Remaining` header.
2. After that the response is `402` with an `accepts[]` requirement.
3. Sign the EIP-3009 USDC authorization, base64 the x402 payload, resend as `X-PAYMENT`.
4. Settlement receipt returns in the `X-PAYMENT-RESPONSE` header.


---

# Scholar Pack Intent

Give a research query (and optionally an author_id), get papers and that author's record.

- endpoint: `GET https://marketplaceforaiagents.com/api/public/v1/scholar-pack`
- category: intents
- price: $0.005 USDC per call (5000 atomic, 6 decimals)
- free tier: 3 calls per agent identity, shared across all endpoints (unknown/generic clients draw from a site-wide 100 successful free calls per UTC day; crawlers get none)
- settlement: USDC on Base mainnet `0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913`, payee `0x05e82e03753c7bc99fb24d10a876cce53f24b7b7`, scheme `exact`
- sandbox: append `?network=base-sepolia` for testnet USDC + mock data
- results key: `results`
- html: https://marketplaceforaiagents.com/listings/scholar-pack

## What it returns

Academic search for a topic, plus the full publication record of a named author when author_id is supplied.

## Use cases

- Literature review automation
- Assess an expert's credibility
- Find primary sources for a claim

## Parameters

| param | type | required | default | description |
| --- | --- | --- | --- | --- |
| `q` | string | yes | — | Research query |
| `author_id` | string | no | — | Google Scholar author ID. When set, adds the author step. |
| `hl` | string | no | en | Interface language code |

## Example call

```bash
curl -s "https://marketplaceforaiagents.com/api/public/v1/scholar-pack?q=example"
```

## Response shape

```json
{
  "intent": "scholar-pack",
  "chain": [
    "google-scholar",
    "google-scholar-author"
  ],
  "steps_run": 2,
  "results": {
    "google-scholar": {
      "note": "Normalized response of /api/public/v1/google-scholar"
    },
    "google-scholar-author": {
      "note": "Normalized response of /api/public/v1/google-scholar-author"
    }
  }
}
```

## Payment

1. Call without `X-PAYMENT`. The first 3 calls per identity (across all endpoints) return 200 with an `X-Free-Calls-Remaining` header.
2. After that the response is `402` with an `accepts[]` requirement.
3. Sign the EIP-3009 USDC authorization, base64 the x402 payload, resend as `X-PAYMENT`.
4. Settlement receipt returns in the `X-PAYMENT-RESPONSE` header.