How to Get Brave Shopping Product Data in 2026 (Tested)

Brave is the newest major engine, and most Shopping APIs ignore its product data entirely. The pages that do mention "Brave Shopping API" are usually thin vendor copy. So I ran product queries through /api/shopping?engine=brave myself in early August 2026 and wrote down what came back.

The honest version: Brave returns a compact rail of product cards — usually 10–11 listings, never more. Every card has a position, title, merchant, and URL. Prices, ratings, and review counts are conditional. On my first runs, prices came back null on most placements (0/10, 0/10, then 1/11). When I re-ran the same queries the next day, 6–8 of 10 carried a price. Brave's coverage is strongest for US product queries, which makes it a useful second look at the US market — not a replacement for a deep catalog feed.

How I tested

I ran five product queries through /api/shopping with engine=brave: sony wh-1000xm5, iphone 15 case, nike running shoes, breville barista express, and kindle paperwhite. From the United States, English, country=us, num=10 and num=100, August 3–4, 2026.

I logged which fields were populated, how often prices were null, how long the result list actually was, and which fields never appeared. Two runs of the same query set let me see how stable the price field is.

Which fields actually come back

The stable core is position, title, merchant/store, url, and thumbnail. That is enough to build a price-monitoring pipeline as long as you treat price as optional.

What Brave product listings actually are

Brave's product listings are the cards that appear at the top of a shopping-intent search. Each one bundles the product's name, a thumbnail, the merchant selling it, and — when the placement renders one — a price. Some carry a rating and a review count. These are placements: some listings carry a sponsored flag, so expect a mix rather than a clean organic/ads split.

Brave is the newest of the four Shopping engines (Google, Yahoo, DuckDuckGo, and Brave), and its coverage is strongest for US product queries. If the shoppers you care about are in the US, Brave is a natural first engine to query — the merchants and prices it surfaces are the ones a US shopper actually sees.

The endpoint: /api/shopping with engine=brave

The Shopping endpoint is /api/shopping. Yahoo is the default engine, so a plain request returns Yahoo Shopping results without any extra parameters. Add engine=brave explicitly to pull the Brave product grid, and switch to engine=google or engine=ddg for the other product indexes.

A first request looks like this:

https://apiserpent.com/api/shopping?q=iphone+15+case&engine=brave&num=10&country=us

A working Node.js example

Here is the whole thing in Node.js with fetch — query Brave Shopping, then print each product's title, price, and merchant:

const res = await fetch(
  'https://apiserpent.com/api/shopping?q=iphone+15+case&engine=brave&num=10',
  { headers: { 'X-API-Key': 'YOUR_API_KEY' } }
);
const json = await res.json();

for (const p of json.results.shopping) {
  console.log(p.position, p.title, p.price ?? 'no price', p.merchant);
}

Five lines. No parser to maintain, no HTML to clean — the product cards arrive as JSON objects ready to store in a database, compare, or feed into a price-alerting loop.

The response shape and the honest price field

Each product result carries the fields that make up the card. A typical item looks like this:

{
  "position": 1,
  "title": "Spigen Mag Armor MagFit for iPhone 15",
  "price": "$49.99",
  "currency": "USD",
  "merchant": "spigen.com",
  "store": "spigen.com",
  "url": "https://spigen.com/products/...",
  "thumbnail": "https://.../product.jpg",
  "rating": 4.5,
  "reviews": 342,
  "sponsored": true,
  "snippet": "Shockproof military-grade case with built-in MagSafe..."
}

Now the honest caveat, with numbers. On August 3, 2026 I ran the five queries and prices came back null on 0, 0, and 1 of the placements across my runs. When I re-ran the same queries on August 4, 6–8 of 10 placements carried a price. The price field is real when it is there — but it is not guaranteed on any given read.

This is not a bug in the API. Some product placements simply render without a visible price at the moment the results are read, and the API returns null rather than inventing a number. Build your pipeline to treat null prices as expected (use p.price ?? 'no price', or skip nulls when averaging) rather than assuming every result has one.

Depth ceiling: ~10–11 listings, no pagination

The second hard limit is depth. I requested num=100 on the same queries and got the same 10–11 listings back. There is no pagination on this source, and requesting more does not conjure extra listings.

That matters for the same reason the field-coverage table matters: if your plan is "scrape all Brave Shopping results for a product," there are no more results to get. The realistic use case is a fast, clean read of what Brave shows for a query — not a full product catalog. If you need deep catalogs or discount history, a dedicated product feed is the right tool.

What you do NOT get

• More than ~11 results. The rail is short and there is no next page.
• A guaranteed price. Some placements render without one, so price can be null on any given read.
• Delivery or condition fields. Brave's product placements do not expose shipping speed, product condition, or an internal product ID.
• Old-price / discount data. There is no original-price field, so a true "was / now" discount split is not available from this source.
• A clean organic-vs-paid split. Listings are placements, and many carry a sponsored flag.

None of these are API defects — they are properties of the source. The honest framing is that Brave Shopping data is a useful second opinion on the US market, not a complete one. For a deeper comparison of what the four engines return, see our Google product-SERP field audit and the Shopping API hub.

Price monitoring with Brave Shopping

Because each result is a merchant offer at a price (where one renders), Brave data slots directly into the shopping price-monitoring playbook and the price-drop alert pattern — query on a schedule, normalize the price strings, and track the lowest offer per product over time. Pass country=us (or your market) to localize the merchants and prices that come back.

FAQ

What Brave Shopping data does the API return?

A compact rail of product cards as JSON: position, title, merchant and store names, product URL, and thumbnail on every listing; price, currency, rating, reviews, sponsored, and snippet when the source provides them. In my August 2026 tests the rail was 10–11 listings per query, with prices on 6–8 of 10 on re-test.

Which engine is the default for the Shopping API?

Yahoo is the default engine, so a bare call returns Yahoo Shopping results. You can switch to Brave product listings at any time by passing engine=brave — the same normalized card fields, one parameter away.

Is a price always returned for every product?

No. In my first runs prices were null on most placements (0/10, 0/10, then 1/11); a re-test returned prices on 6–8 of 10. Some placements render without a visible price, so price can be null. Always handle null prices rather than assuming every result has one.

How many Brave Shopping results do you actually get per query?

About 10–11 listings, no matter the num you pass. I requested num=100 and still got 10–11. There is no pagination on this source, so treat the response length as the ceiling.

Is Brave Shopping good for price monitoring?

Yes. Brave's coverage is strongest for US product queries, and each result is a merchant offer at a price (where the placement shows one). Combined with the other engines on the same endpoint, it adds a US-focused cross-market view to a price monitor.

How much does the Brave Shopping API cost?

Brave Shopping search costs $0.60 per 1,000 requests on the Default tier, $0.54 per 1,000 on Growth, and $0.42 per 1,000 on Scale. New accounts get 10 shared free calls on every endpoint, then pay-as-you-go. Credits never expire and there is no monthly subscription.