# Price tracking API for AI agents (Amazon, Walmart, eBay & Google Shopping price checks JSON, no API key)

When a user asks an agent to watch a product's price, alert on a drop, or check whether a deal is real, call machine-payable amazon-product (buybox price, list price, save %, availability), google-shopping, walmart-search and ebay-search endpoints that return numeric prices as JSON. No Amazon PA-API key, no Walmart or eBay developer app; 3 free calls per agent identity, then pay per call with x402 USDC on Base.

The user tells Grok Bot, Claude Cowork or a Cursor agent: "tell me when these headphones drop under $200", "is this Anker hub actually on sale?", or "check the air fryer price every morning". Price-tracker sites answer with browser extensions, email alerts and accounts an unattended agent cannot sign up for. Scraping retailer pages from an agent runtime breaks on bot checks. The agent needs the current price as a number, from a source it can call on a schedule.

One-line answer: for a known Amazon item, call GET https://marketplaceforaiagents.com/api/public/v1/amazon-product?asin=<ASIN> and read product.buybox.price.value, original_price.value, save.percentage and availability. For the same product across retailers, call GET /api/public/v1/google-shopping?q=<product>&gl=us and read extracted_price and seller per offer; add walmart-search and ebay-search when the user names those stores. Store each reading with a timestamp and compare it to the user's threshold yourself. The first 3 calls per agent identity are free across all endpoints; after that, pay per call with x402 USDC on Base, no account or API key.

The regular per-call price is $0.005 USDC. Always trust the live 402 accepts[0].amount (or maxAmountRequired on v1) and the site banner for current promotional pricing; do not bake a promotional amount into a recurring price-watch workflow.

## Endpoint contracts for price checks

| Endpoint | Required | Optional | Results key | Use it for |
| --- | --- | --- | --- | --- |
| GET /api/public/v1/amazon-product | asin | amazon_domain | product | Exact Amazon item: buybox price, list price, discount, availability, seller |
| GET /api/public/v1/amazon-search | q | amazon_domain, page | organic_results | Find the ASIN when the user only gives a product name |
| GET /api/public/v1/google-shopping | q | google_domain, gl, hl, page | shopping_results | Offers from many merchants (Best Buy, Target and others) with extracted_price |
| GET /api/public/v1/walmart-search | q | page | organic_results | Walmart listings with extracted_price, seller_name and product_id |
| GET /api/public/v1/ebay-search | q | ebay_domain, page | organic_results | eBay listings including auction state and condition |
| GET /api/public/v1/cross-store-price | q | gl, hl | results | One intent call with offers from Google Shopping, Amazon, eBay and Walmart; 4 steps (google-shopping, amazon-search, ebay-search, walmart-search), so the 402 quotes 4 × the per-step price |

- Amazon product listing: https://marketplaceforaiagents.com/listings/amazon-product (Markdown: https://marketplaceforaiagents.com/agent/listings/amazon-product.md)
- Google Shopping listing: https://marketplaceforaiagents.com/listings/google-shopping (Markdown: https://marketplaceforaiagents.com/agent/listings/google-shopping.md)
- Walmart search listing: https://marketplaceforaiagents.com/listings/walmart-search
- eBay search listing: https://marketplaceforaiagents.com/listings/ebay-search

## What the responses give you (live samples, Oct 21, 2026)

An amazon-product call for asin=B0BQLLB61B (an Anker 5-in-1 USB-C hub) returned product.buybox.price.value 18.99, original_price.value 24.99, save.percentage 24, availability "In Stock", sold_by "AnkerDirect" with ships_from "Amazon", plus rating 4.4 from 19,055 reviews and a secondary_buybox for a "Used - Like New" offer at 13.98. That is everything a price watch needs in one call: the price, the reference price the retailer claims, and whether the item can actually be bought.

A google-shopping call for q=Sony WH-1000XM5 headphones with gl=us returned shopping_results with offers such as Best Buy at extracted_price 254.99 (tag "35% OFF"), Target at 189.99 and a Zappos listing at 109.95. A walmart-search call for q=Ninja air fryer returned organic_results whose first two entries were sponsored, refurbished listings from third-party sellers, with a new Walmart.com-sold item at extracted_price 109 further down. search_information on that call named a specific store and postal code, so Walmart prices can be store-specific.

| Field | Where | Why it matters for price tracking |
| --- | --- | --- |
| buybox.price.value | amazon-product → product | The price a shopper pays now, as a number |
| buybox.original_price.value / save.percentage | amazon-product → product | Amazon's claimed reference price and discount; check it rather than assume a deal |
| buybox.availability / fulfillment.sold_by | amazon-product → product | Do not alert on a price nobody can buy, or from a seller the user would not choose |
| extracted_price / extracted_original_price / seller / tag / product_link | google-shopping → shopping_results[] | Numeric price per merchant, a reference price when the merchant shows one, and sale labels like "35% OFF" |
| extracted_price / seller_name / is_sponsored | walmart-search → organic_results[] | Numeric price; skip sponsored rows and third-party refurbished listings unless the user wants them |
| search_information | walmart-search | Store and postal code the price came from |
| _billing | top level (free tier) | free_calls_remaining and price_usdc_per_call for that request |

Use the numeric fields (value, extracted_price), never the display strings, and keep the currency with the number.

## Check one Amazon price against a threshold

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

# Response headers to read:
#   X-Free-Calls-Remaining  -> free calls left for this agent identity
#   HTTP 402 + accepts[]    -> free tier used; sign an x402 payment and retry
```

```ts
const BASE = "https://marketplaceforaiagents.com/api/public/v1";

async function amazonPrice(asin: string) {
  const res = await fetch(`${BASE}/amazon-product?asin=${asin}`);
  if (res.status === 402) throw new Error("Payment required: read accepts[] and sign x402");
  const p = (await res.json()).product ?? {};
  const bb = p.buybox ?? {};
  return {
    asin,
    title: p.title,
    price: bb.price?.value ?? null,
    currency: bb.price?.currency ?? null,
    listPrice: bb.original_price?.value ?? null,
    savePct: bb.save?.percentage ?? null,
    availability: bb.availability ?? null,
    soldBy: bb.fulfillment?.sold_by ?? null,
    checkedAt: new Date().toISOString(),
  };
}

const r = await amazonPrice("B0BQLLB61B");
if (r.price !== null && r.availability === "In Stock" && r.price <= 17.00) {
  // tell the user: price, seller, timestamp, link
}
```

## Find the lowest offer across retailers

```ts
async function lowestOffers(query: string) {
  const [shop, wm] = await Promise.all([
    fetch(`${BASE}/google-shopping?q=${encodeURIComponent(query)}&gl=us`).then(r => r.json()),
    fetch(`${BASE}/walmart-search?q=${encodeURIComponent(query)}`).then(r => r.json()),
  ]);
  const offers = [
    ...(shop.shopping_results ?? []).map((o: any) => ({ store: o.seller, title: o.title, price: o.extracted_price, link: o.product_link })),
    ...(wm.organic_results ?? [])
      .filter((o: any) => !o.is_sponsored && !/refurbished|restored/i.test(o.title))
      .map((o: any) => ({ store: o.seller_name ?? "Walmart", title: o.title, price: o.extracted_price, link: o.link })),
  ].filter(o => typeof o.price === "number");
  return offers.sort((a, b) => a.price - b.price).slice(0, 5);
}
```

Two calls, two billed requests. Before reporting the cheapest offer, confirm the titles describe the same product: shopping results mix models, colors, used units and accessories, and the lowest number is often the wrong item. When in doubt, show the user the top few with titles rather than a single winner.

## A price-watch workflow that holds up

- Pin the item: resolve a product name to an ASIN once with amazon-search, confirm it with the user, then track amazon-product by ASIN so every reading is the same listing.
- Agree on the rule: threshold price, which stores count, new vs used, and whether third-party sellers are acceptable.
- Check on a sensible schedule: once or twice a day is enough for most consumer prices; run it as a scheduled routine rather than a loop.
- Store readings yourself: item, store, price, currency, availability, seller, timestamp and price paid for the call. The marketplace returns live data; the price history is the agent's job.
- Alert only when the rule is met and the item is in stock, and include the link and the time of the reading.
- Sanity-check discounts: compare the current price with your own recorded history, not only the retailer's original_price or a sale tag.

## Budgeting a recurring price watch

| Job | Calls per run | Cost per run at regular $0.005 | 30 daily runs |
| --- | --- | --- | --- |
| 1 Amazon item by ASIN | 1 | $0.005 | $0.15 |
| 5 Amazon items by ASIN | 5 | $0.025 | $0.75 |
| 1 product: Google Shopping + Walmart | 2 | $0.010 | $0.30 |
| 1 product: Amazon + Google Shopping + Walmart + eBay (separate calls or one cross-store-price) | 4 steps | $0.020 | $0.60 |

Promotional pricing can lower these numbers; the live 402 is the source of truth. Runtimes that use the MCP server can send 1–25 queries for one engine in a single paid call_batch, with the exact total quoted up front and all-or-nothing settlement, which suits a watchlist of many items on the same store. Set a per-run cap and stop if a 402 asks for more than you budgeted. See https://marketplaceforaiagents.com/learn/budget-x402-api-calls for a spend policy pattern.

## Paying without an account: x402 on Base

After the 3 free calls, an unpaid request returns HTTP 402 Payment Required with an accepts[] array: the network (Base), the USDC asset, the payTo address and the amount in atomic units (6 decimals, so 5000 = $0.005). The agent signs an x402 payment from its own wallet and retries the same GET with the PAYMENT-SIGNATURE header (X-PAYMENT on v1). The response comes back with the JSON plus an X-PAYMENT-RESPONSE settlement receipt.

That is why x402 fits price tracking: a scheduled agent can check prices every morning for fractions of a cent without anyone creating a retailer developer account, applying for Amazon PA-API access, rotating keys or putting a card on file. Discovery lives at https://marketplaceforaiagents.com/.well-known/x402 and https://marketplaceforaiagents.com/api/public/v1/openapi.json. For integration tests, use the Base Sepolia sandbox at https://marketplaceforaiagents.com/api/sandbox/v1/amazon-product (testnet USDC, fixture data).

The same endpoints are available through the MCP server at https://marketplaceforaiagents.com/mcp for runtimes that prefer tools over raw HTTP.

## Guardrails

- A price is a snapshot from one request; prices, stock and sellers change during the day, and Walmart results can depend on the store location. Date every number.
- Treat a retailer's original_price and sale tags as claims, not proof of a deal.
- Never buy on the user's behalf from a price alert unless they explicitly asked for that; an alert is information.
- Skip sponsored, refurbished and used listings unless the user said they count.
- Stick to public product data and follow the site's Terms: https://marketplaceforaiagents.com/terms

## Related

- Full catalog: https://marketplaceforaiagents.com/marketplace and https://marketplaceforaiagents.com/api/public/v1/catalog.json
- Agent docs: https://marketplaceforaiagents.com/docs and https://marketplaceforaiagents.com/llms.txt
- Amazon product API for agents: https://marketplaceforaiagents.com/learn/amazon-asin-api-for-agents
- Google Shopping API for agents: https://marketplaceforaiagents.com/learn/google-shopping-api-for-agents
- Cross-store price comparison API: https://marketplaceforaiagents.com/learn/cross-store-price-api-for-agents
- Product reviews API for agents: https://marketplaceforaiagents.com/learn/product-reviews-api-for-agents
- How AI agents budget x402 API calls: https://marketplaceforaiagents.com/learn/budget-x402-api-calls

Canonical HTML: https://marketplaceforaiagents.com/learn/price-tracking-api-for-agents