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

Every "DuckDuckGo Shopping API" page I found was written by a vendor explaining why you should buy theirs. None of them showed what the API actually returns. So I ran product queries through /api/shopping?engine=ddg myself in early August 2026 and wrote down what came back.

The honest version: a DuckDuckGo product query 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 query set the next day, 6–8 of 10 carried a price. That is the kind of detail the marketing pages leave out — and it is exactly what you need before you build a pipeline on top.

How I tested

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

I logged four things: 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 a DuckDuckGo product card actually is

DuckDuckGo'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 source renders one — a price. Some carry a rating and a review count. These are paid placements, not organic links: every card in the rail is a sponsored slot, so there is no organic-vs-ads split to analyze.

That is a property of the source, not a missing feature. Any tool that reads DuckDuckGo Shopping runs into the same ceiling, because the page itself only shows that much.

The endpoint: /api/shopping with engine=ddg

The Shopping endpoint is /api/shopping. DuckDuckGo is one of four engines — google, yahoo (the default), ddg, and brave. Pass engine=ddg to pull DuckDuckGo product listings.

A first request looks like this:

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

A working Node.js example

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

const res = await fetch(
  'https://apiserpent.com/api/shopping?q=iphone+15+case&engine=ddg&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 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 DuckDuckGo Shopping results for a product," there are no more results to get. The realistic use case is a fast, clean read of what DuckDuckGo 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. DuckDuckGo's cards 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.
• An organic-vs-paid split. Every card in the rail is a paid placement.

None of these are API defects — they are properties of the source. The honest framing is that DuckDuckGo Shopping data is a useful second opinion on a 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 DuckDuckGo Shopping

Because each result is a merchant offer at a price (where one renders), DuckDuckGo data slots into the same shopping price-monitoring playbook as the other engines: query on a schedule, normalize the price strings to a numeric value, and track the lowest offer per product over time. When the minimum drops below a threshold, you have a price-drop signal. Our price-drop alerts post shows how to turn that into a notification.

FAQ

What DuckDuckGo 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.

Is there an official DuckDuckGo Shopping API?

No. DuckDuckGo does not offer a public API that reads its product search listings. A shopping API that returns those product cards as JSON is the standard path, and Serpent exposes them through /api/shopping with engine=ddg.

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 in your pipeline rather than assuming every result has one.

How many DuckDuckGo 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.

Are DuckDuckGo Shopping results organic or paid?

They are paid placements. Every product card in the rail is a paid slot, so the sponsored field is true across the board rather than a clean organic/ads split.

How much does the DuckDuckGo Shopping API cost?

DuckDuckGo 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.