Product reviews API for AI agents (Amazon & Google Maps reviews JSON, no API key)

Grok Bot, Claude Cowork and Cursor agents get review questions all day: "is this USB-C hub any good," "what do people complain about with this air fryer," "find me a well-reviewed barbecue place in Austin and tell me what to order," "vet this contractor before I call." The answer has to come from real review text with real dates, not from the model's memory. Amazon's Product Advertising API needs an Associates account and does not hand out review text, and Google's Places API needs a Cloud project with billing. An unattended agent can do neither.

One-line answer: for a product, call GET https://marketplaceforaiagents.com/api/public/v1/amazon-reviews?asin=<ASIN> and read reviews[]; for a business or venue, call GET https://marketplaceforaiagents.com/api/public/v1/place-dossier?q=<name+city> and read results["google-maps-reviews"].reviews[]. The first 3 calls per agent identity are free across the whole marketplace; after that each call (or each step of an intent) is settled over x402 in USDC on Base (regular price $0.005 per step; promotional pricing, when active, is advertised in the 402 and the site banner, so always trust the live 402 amount). No account, no API key, no monthly plan.

Endpoint contracts

sort_by on the Maps reviews endpoints accepts relevance, newest, highest_rating or lowest_rating. review-risk, deal-triage and place-dossier are intents: the server chains the engines and returns intent, chain, steps_run, billed_steps and price alongside results, so the agent can log exactly what it bought. One intent invocation consumes one free-tier call, not one per step.

Listings: https://marketplaceforaiagents.com/listings/amazon-reviews, https://marketplaceforaiagents.com/listings/review-risk, https://marketplaceforaiagents.com/listings/google-maps-reviews, https://marketplaceforaiagents.com/listings/place-dossier, https://marketplaceforaiagents.com/listings/deal-triage. Machine specs: https://marketplaceforaiagents.com/agent/listings/amazon-reviews.md and https://marketplaceforaiagents.com/agent/listings/place-dossier.md.

What comes back (from live calls on 2026-10-14)

We ran review-risk for an Anker 5-in-1 USB-C hub (ASIN B0BQLLB61B) and place-dossier for Franklin Barbecue in Austin. Both returned 200 with billed_steps 2. These are the fields worth extracting.

Volume is a sample, not the full corpus. The Amazon call returned 8 reviews in reviews[] for a product with 18,995 ratings, and the Maps call returned 10 reviews for a place with 7,310. Treat them as the most visible reviews and say so to the user. The aggregate numbers (product.rating and product.reviews on Amazon, place_result.rating and place_result.reviews on Maps) cover everyone, so lead with those and use the text for the why.

Maps topics[] is the cheapest complaint-clustering signal you will get: it is Google's own keyword index over all reviews (for Franklin Barbecue, brisket appeared in 1,237 of them). Use it to decide what to look for in the sampled text.

The amazon-reviews response already carries the product block, because the upstream engine is the product page. If you only need rating, price and the top reviews, one amazon-reviews call is the cheaper path. Use review-risk when you want the product record and the reviews under separate result keys with an itemized chain for your logs.

Amazon calls can take 15 seconds or more upstream, so give the HTTP client a 30 second timeout rather than the usual 10.

Agent workflow: from a vague ask to a cited verdict

• Resolve the item. Product: amazon-search?q=<name> and pick the ASIN whose title matches, preferring the listing with the most reviews. Business: place-dossier?q=<name+city> does the lookup for you; if you already hold a place_id or data_id from google-maps, call google-maps-reviews directly.
• Pull reviews: amazon-reviews?asin=<ASIN>, or place-dossier as above. For a local business, add a second call with sort_by=lowest_rating to see complaints the relevance sort hides, or sort_by=newest to check whether recent experience matches the average.
• Weight the sample: prefer is_verified_purchase true on Amazon and recent extracted_date or iso_date values on both. Note when the newest review is months old.
• Cluster: group complaints by theme (heat, cable length, wait time, price). On Maps, cross-check themes against topics[] counts before claiming a pattern.
• Report: lead with the aggregate rating and review count, then two or three pros and cons, each backed by a short quote, the star rating and the date. Link the review or listing. Never invent a quote, a star count or a review total.
• Price check (optional): for a purchase, deal-triage?q=<product>&asin=<ASIN> adds Google Shopping offers so the verdict comes with where to buy.

import { wrapFetchWithPayment } from "@x402/fetch";
const pay = wrapFetchWithPayment(fetch, wallet);
const base = "https://marketplaceforaiagents.com/api/public/v1";

// Product reviews
const r = await (await pay(`${base}/amazon-reviews?asin=B0BQLLB61B`)).json();
const product = { title: r.product?.title, rating: r.product?.rating, count: r.product?.reviews, price: r.product?.buybox?.price?.raw };
const reviews = (r.reviews ?? []).map((x) => ({
  stars: x.rating, date: x.extracted_date, verified: x.is_verified_purchase, title: x.title, text: x.text?.slice(0, 400), link: x.link,
}));
const lowStars = reviews.filter((x) => x.stars <= 3);

// Business reviews, worst first
const d = await (await pay(`${base}/place-dossier?q=Franklin+Barbecue+Austin&sort_by=lowest_rating`)).json();
const place = d.results["google-maps-reviews"]?.place_result;
const topics = d.results["google-maps-reviews"]?.topics ?? [];
const complaints = (d.results["google-maps-reviews"]?.reviews ?? []).map((x) => ({ stars: x.rating, date: x.iso_date, text: x.text?.slice(0, 400) }));

console.log(d.chain, d.billed_steps, d.price);

Review responses are big (our review-risk call was about 41 KB, place-dossier about 35 KB) and full of long review bodies. Trim text in code before anything enters your context window.

Paying with x402: what the 402 tells you

x402 USDC on Base is the no-account rail: the agent needs a funded wallet, not an Amazon Associates account, a Google Cloud billing profile or a review-data subscription, so it can buy exactly the reviews one answer needs and stop. Charges settle only when the upstream call succeeds; a failed upstream call returns 502 upstream_error and is not charged. A discontinued or unavailable ASIN is the common cause, and the error body says "Amazon Product didn't return any results", so re-resolve the ASIN with amazon-search instead of retrying.

After the free tier, an unpaid request returns HTTP 402 with the requirement in the body and, base64-encoded, in the PAYMENT-REQUIRED header. For intents the requirement itemizes the chain:

curl -i "https://marketplaceforaiagents.com/api/public/v1/review-risk?asin=B0BQLLB61B"

HTTP/2 402
{
  "x402Version": 2,
  "error": "payment_required",
  "accepts": [
    {
      "scheme": "exact",
      "network": "eip155:8453",
      "asset": "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
      "amount": "<live total, atomic USDC>",
      "payTo": "0x05e82e03753c7bc99fb24d10a876cce53f24b7b7",
      "maxTimeoutSeconds": 60,
      "extra": {
        "steps": 2,
        "perStep": "<live per-step price>",
        "total": "<live total>",
        "chain": ["amazon-product", "amazon-reviews"]
      }
    }
  ],
  "acceptsV1": [ { "network": "base", "maxAmountRequired": "<live total, atomic USDC>", ... } ]
}

deal-triage is a variable chain: its 402 carries minSteps 2 and steps 3 and is charged at the advertised maximum (3 steps), even when you pass asin and fewer steps actually run. Validate network, asset and payTo against your allowlist, check extra.total against the task budget, sign the EIP-3009 USDC authorization and resend the same URL with an X-PAYMENT header. The settlement receipt comes back in X-PAYMENT-RESPONSE. x402 v1 clients can use acceptsV1.

Budget formula: total steps times the live per-step price. Set per-task and per-day USDC caps and debit only from successful X-PAYMENT-RESPONSE receipts. Full spend-policy pattern: https://marketplaceforaiagents.com/learn/budget-x402-api-calls.

MCP

The same endpoints are reachable through the site's MCP server at https://marketplaceforaiagents.com/mcp (streamable HTTP, no auth; payment is the auth). Use list_apis to find amazon-reviews, review-risk, deal-triage, google-maps-reviews and place-dossier, get_payment_requirements to read the live price, and call_api with the slug to execute, paying via _meta["x402/payment"]. Setup details: https://marketplaceforaiagents.com/learn/mcp-x402-marketplace.

Agent playbook

FAQ

Do I need an Amazon or Google API key? No. Calls are paid per call with x402 USDC on Base; there is no signup, OAuth or dashboard.

Do I get every review? No. Each call returns the most visible reviews (about 8 on Amazon and 10 on Maps in our tests) plus the aggregate rating and total count. Present the text as a sample.

Why did amazon-reviews return 502? Usually the ASIN is discontinued or unavailable on that marketplace. You were not charged. Re-resolve with amazon-search and try the current ASIN.

Can I read reviews from Amazon outside the US? Pass amazon_domain, for example amazon.co.uk or amazon.de. The response also splits review_results into local and global.

How many free calls do I get? 3 per agent identity across all endpoints; an intent such as place-dossier counts as one free-tier call even though it runs two steps.

What price should my agent expect? Regular $0.005 USDC per step: $0.005 for amazon-reviews or google-maps-reviews, $0.010 for review-risk or place-dossier, $0.015 for deal-triage. Read the live 402 for the current amount, since promotional pricing may be lower.

Related entrypoints

• Marketplace: https://marketplaceforaiagents.com/marketplace
• Docs: https://marketplaceforaiagents.com/docs
• llms.txt: https://marketplaceforaiagents.com/llms.txt
• Amazon product API for agents: https://marketplaceforaiagents.com/learn/amazon-asin-api-for-agents
• Google Maps API for agents: https://marketplaceforaiagents.com/learn/google-maps-api-for-agents
• Cross-store price API for agents: https://marketplaceforaiagents.com/learn/cross-store-price-api-for-agents
• Brand monitoring API for agents: https://marketplaceforaiagents.com/learn/brand-monitoring-api-for-agents
• How agents budget x402 API calls: https://marketplaceforaiagents.com/learn/budget-x402-api-calls
• x402 protocol explained: https://marketplaceforaiagents.com/learn/x402-protocol-explained

Capability first, payment second: one call gets real review text, star ratings and dates as JSON, and x402 USDC on Base settles it only when the free tier is spent.