Category:Scraping Tools
Best Google Shopping APIs in 2026: Only 3 of 16 Providers Actually Work
Head of Marketing
Searching for a Google Shopping API in 2026 lands you in a minefield of documentation for products that no longer exist.
Google spent the last two years dismantling the classic Shopping surface, and most provider docs, tutorials, and comparison listicles never caught up. Endpoints that worked in 2024 now return explicit shutdown errors, or worse, 200 responses full of nothing while the credits still bill. And to clear up the first confusion right away: Google's own "Shopping Content API" is for merchants uploading product feeds, not for reading search results. Result extraction runs entirely through third-party scraping APIs.
We checked all 16 providers from our benchmark roster for a real Google Shopping product, then live-tested the four that have one, same day (2026-08-03), five passes per query, success counted only when the fields actually arrived.
| Provider | Search | Product lookup | Price filters | Avg response | Cost per 1K | Starting price | Free tier |
|---|---|---|---|---|---|---|---|
| Scrape.do | 100% | 100% | 100% via tokens¹ | 3.5s | $1.16 | $29/mo | 1,000 credits/mo, no card |
| SerpApi | 100% | 100% | 100% | 0.7s | $25.00 | $25/mo | 250 searches/mo |
| ScrapingDog | 100% | 100%² | 0% | 7.5s | $2.00 | $40/mo | 200-credit trial |
| ScraperAPI | 100% | 0% (no path) | 0% | 9.3s | ~$12.25³ | $49/mo | 1K credits |
| Oxylabs | blocked: account scope | $1.00/1K | $49/mo | 2,000-result trial | |||
| Decodo | blocked: quota + no endpoint | $19/mo | 2,000 req/mo |
¹ Via Google's shoprs filter tokens; Scrape.do's first-class price params are currently ignored (detailed in its section). ² Via the immersive endpoint; its legacy product endpoint is dead. ³ Estimated; ScraperAPI does not publish this endpoint's credit multiplier.
What Happened to Google Shopping
This section is the reason most of what you read about Google Shopping APIs is wrong, so it comes before any ranking.
The classic product page is dead. For years, every provider offered a product endpoint keyed by product_id that returned the offers/sellers page. Google shut that surface down. SerpApi's google_product engine now returns an explicit error stating Google has shut down the Google Product service. ScrapingDog's legacy google_product endpoint fails less honestly: it returns 200 with an empty scaffold, no title, no sellers, and still bills 5 credits per call. We verified both live on 2026-08-03.
The replacement is the immersive product view. What used to be a product page is now a popup driven by opaque page tokens that appear inside shopping search results. Every working product lookup today follows the same two-step: search, harvest the token (or catalog ID), then call an immersive-product endpoint with it. SerpApi, ScrapingDog, and Scrape.do all implement this path, each with different token mechanics.
Old-style price filtering is dead too. The tbs=price:1,ppr_min:... URL parameters that every 2023-era tutorial recommends are ignored by today's surface. Filtering only works through Google's own opaque shoprs tokens, which arrive in the filters array of a search response, or through a provider converting your parameters to those tokens server-side.
The search side, meanwhile, is healthy. Every provider we tested returns a consistent ~40 products per page with title, price, and seller. Search is commoditized; product lookups and filtering are where 13 of 16 providers fall away.
How We Tested
Ten shopping searches with commercial variety (wireless earbuds, air fryers, LEGO sets, standing desks), including two non-US locales: kaffeemaschine on google.de with gl=de, and robot vacuums on google.co.uk with gl=gb. Five product lookups per provider, using each provider's own ID mechanism with IDs harvested the same day. Three filter tests: a $50-$150 price bucket, a $100 maximum, and a price-ascending sort.
Five passes per query, sequential, 400 ms apart, all on 2026-08-03.
Verification was field-based. A search passed with 5+ items where most carried title, price, and seller. A product lookup passed with a title plus at least one offer carrying price and seller. A filter test passed when at least 70% of priced items landed inside the range, or 80% of results were monotonically ascending for the sort test. A 200 with an empty or ad-only shell counted as a failure.
Two harness corrections happened mid-run and both affected segments were fully re-run: ScrapingDog's product test moved from its dead legacy endpoint to the working immersive one, and Scrape.do's filter test moved from first-class parameters to shoprs tokens after we proved the first-class parameters were being ignored. Both raw behaviors are reported below as findings, because they are exactly what a buyer would hit. Single-day run; treat the latency figures as a same-conditions snapshot.
1. Scrape.do
- Trustpilot: 5.0 (68 reviews)
- Capterra: 5.0 (49 reviews)
Scrape.do's Google Shopping API passed search 50/50 at a 3.5-second average and product lookups 25/25 at 2.3 seconds, with the response shape tracking SerpApi closely enough to be a drop-in migration for most parsing code.
Its product lookup uses the most script-friendly handle in this comparison. Where SerpApi and ScrapingDog hand out opaque page tokens that expire, Scrape.do's search items carry a stable catalog_id, Google's own catalog identifier. Store it, look products up days later, no token freshness dance. The one rule: the product endpoint requires the search query q alongside catalog_id, and 400s without it.
Offer depth is a quiet advantage: the product response includes a stores array with per-seller name, link, rating, and price, plus a continuation endpoint that pages through all sellers. SerpApi caps at 13.
Now the quirk, reported straight because we found it: Scrape.do documents first-class min_price, max_price, and sort_by parameters, and they do not currently work. The API accepts them and echoes them back in search_parameters, but results come back unfiltered and unsorted. Filtering does work, 10 out of 10 in our tests, by passing the shoprs tokens the API itself returns in its filters array. So the capability is there, but through the token path rather than the documented convenience params. We flagged it to the team; until it lands, use the tokens.
Pricing: every call is 10 credits, so Hobby at $29/250K credits is $1.16 per 1,000 calls, dropping to $0.79 (Pro) and $0.71 (Business). Free tier is 1,000 credits monthly, no card. Non-US queries came back 100% with correctly localized currency (€ and £ in our German and UK samples).
2. SerpApi
- Trustpilot: 5.0 (~102 reviews)
- G2: 4.8 (28 reviews)
- Capterra: 5.0 (65 reviews)
SerpApi turned in the only flawless line on the board: search, product, filters, and sort all at 100%, with sub-second averages helped by their caching layer.
The filter result deserves emphasis because SerpApi is alone here. Their first-class min_price, max_price, and sort_by parameters genuinely work end-to-end, because SerpApi converts them to Google's shoprs tokens server-side before the request goes out. Every one of our 15 filter passes came back correctly bucketed or correctly sorted. No other provider in this benchmark can say that about first-class params.
The engine catalog is the deepest available (shopping, a lighter shopping variant, the immersive product engine, and a filters-enumeration API), and the docs are refreshingly honest, stating outright that start pagination is ignored and Google returns a fixed ~40 items. They are equally transparent that their old google_product engine is dead, with a proper deprecation notice instead of a silent empty response.
The cost is the cost: Starter at $25 per 1,000 searches is $25.00 per 1K, 21 times Scrape.do's entry rate, easing to $9.17 per 1K on the Big Data tier. Cached repeat searches are free, which softens monitoring workloads that re-run identical queries. The immersive endpoint returns 3-5 stores by default and caps at 13 with more_stores=true.
3. ScrapingDog
- Trustpilot: 4.7 (~585 reviews)
- G2: 3.0 (5 reviews, stale)
ScrapingDog passed search 50/50, though slowest of the working three at a 7.5-second average with an 11-second p90, and passed product lookups 25/25 through its google_immersive_product endpoint, which at 1.7 seconds average was quicker than its own search.
The warning label: ScrapingDog still documents and serves its legacy google_product endpoint, and that endpoint is silently dead. It returns 200 with empty JSON, no error, no deprecation notice, and bills 5 credits for the privilege. Anyone following the current docs into product_id lookups burns credits on nothing. The working path is harvesting page_token from search items and calling the immersive endpoint, and the tokens expire, so harvest and consume promptly. Two more small traps: the immersive endpoint errors without a country parameter, and there is no working price-filter mechanism at all (its responses only expose On-sale/Nearby quick-filter tokens, and tbs is dead ecosystem-wide).
Pricing is where it claws back: shopping calls are 10 credits, so Lite at $40/200K credits is $2.00 per 1K, and Standard at $90 drops to $0.90 per 1K, the cheapest working search+product path in this benchmark at volume.
4. ScraperAPI
- Trustpilot: ~4.x (42 reviews)
- G2: 4.4 (16 reviews)
- Capterra: 4.6 (62 reviews)
ScraperAPI's structured shopping endpoint passed our search rule 50/50, and that is the entire product.
The payload is the thinnest in the run: title, price, seller, thumbnail, and nothing else. No product IDs. No ratings or review counts. No immersive tokens. Which mechanically explains the 0% on product lookups: there is nothing in a ScraperAPI search item to look a product up by. Their own docs concede the point, noting the deprecated product endpoint's link values now point at further ScraperAPI URLs that must be requested separately as raw pages. It was also the slowest passing provider (9.3-second average, 20.5-second p90), and one early probe returned a completely empty shopping_results shell on a 200, so intermittent empties are real.
Pricing is hard to state precisely because the endpoint's credit cost is not published (it is a dashboard-side "Domain Multiplier"). At the documented Google SERP rate of 25 credits, Hobby at $49/100K credits works out to roughly $12.25 per 1K, which would make the thinnest payload also one of the priciest. Usable for simple price-point sampling; not for anything that needs to follow a product.
How Each Product Lookup Works
The two-step search-then-lookup flow is universal now, but the handle you carry between the calls differs per provider, and it changes how you architect a scraper:
| Provider | Handle | Lifetime | Second call |
|---|---|---|---|
| Scrape.do | catalog_id + original q |
stable | shopping/product?q=...&catalog_id=... |
| SerpApi | immersive_product_page_token |
expires | engine=google_immersive_product&page_token=... |
| ScrapingDog | page_token |
expires | google_immersive_product?page_token=... |
| ScraperAPI | none | not possible |
With expiring tokens, the search and the product lookup must live in the same job: harvest, consume, done. With a stable catalog_id, the two halves decouple; a Monday crawl can feed a Friday price check. That architectural difference is worth more than a latency chart for anyone building a monitoring pipeline.
Field Coverage: What Comes Back in a Search Item
Measured across 120-138 real search items per provider, not read from docs:
| Field | Scrape.do | SerpApi | ScrapingDog | ScraperAPI |
|---|---|---|---|---|
| title | 100% | 100% | 100% | 100% |
| price (formatted) | 100% | 100% | 100% | 100% |
| extracted_price (numeric) | 100% | 100% | 100% | 100% |
| currency | 100% | 100% | 100% | 100% |
| seller/source | 100% | 100% | 100% | 100% |
| product/catalog id | 100% | 100% | 100% | 0% |
| rating | 99% | 90% | 92% | 0% |
| review count | 98% | 90% | 92% | 0% |
| delivery info | 49% | 56% | 50% | 0% |
| thumbnail | 100% | 100% | 99% | 100% |
| old price (discounts) | 26% | 28% | 36% | 0% |
| immersive page token | 100% | 100% | 100% | 0% |
The core commercial quintet (title, both price forms, currency, seller) is at 100% for everyone, confirming the search layer really is commoditized. The old-price field on 26-36% of items is the discount detector: pair it with the current price on scheduled runs and markdowns surface themselves. And ScraperAPI's column of zeros is the field-level anatomy of why it has no product path.
What About Oxylabs, Decodo, and the Rest
Sixteen providers were checked; here is everyone who did not make the benchmark table.
Oxylabs has a real, maintained shopping product: google_shopping_search and google_shopping_product sources with parsed output and product tokens, priced from $49/month at $1.00 per 1K results. We could not benchmark it because our credentials are scoped to their Web Unblocker product and the Web Scraper API returns 401. That is a "blocked, not tested" verdict, stated plainly rather than silently dropped.
Decodo produced the strangest finding of the run. The account was quota-dead (persistent 429s), but the deeper issue is that Decodo's current documentation lists no Google Shopping target at all (google, google_search, google_ads, google_ai_mode, google_lens, google_travel_hotels, and that is the list) while an active marketing page continues to sell a Google Shopping scraper. A marketing page with no endpoint behind it is worth knowing about before you subscribe.
Bright Data parses shopping only as tbm=shop/udm=28 variants of the general SERP page through its zone system; there is no dedicated shopping endpoint. Apify offers community actors rather than a first-party product. And Zyte, Scrapfly, ZenRows, Firecrawl, ScrapeGraphAI, ScrapingAnt, WebScrapingAPI, and ScrapingBee have no Google Shopping product at all, verified against both current docs and full documentation mirrors.
Net count: of 16 providers, exactly three (Scrape.do, SerpApi, ScrapingDog) have a working search-plus-product path today, with Oxylabs a probable fourth we could not verify.
Which One to Pick
For most price-monitoring and ecommerce-intelligence workloads, Scrape.do is the pick: 100% on search and product at $1.16 per 1K, the only stable product identifier in the field, and working price filters via the token path. The ignored first-class filter params are the one blemish; the workaround is functional and, being SerpApi-shaped, portable.
If you need filters and sorting to work through clean first-class parameters, or sub-second latency, SerpApi is the only provider that delivers both, and you pay 21x for it. For repeated identical queries the free cache narrows that gap.
At sustained volume with product lookups, ScrapingDog's Standard tier ($0.90 per 1K) is the budget floor among working providers. Route around its dead legacy endpoint and remember the country param.
ScraperAPI works only as a thin search feed. And re-check Oxylabs with properly scoped credentials before ruling it in or out; the product looks real from the docs.
FAQ
Is there an official Google Shopping API for search results?
No. Google's official offering (the Content API for Shopping, now Merchant API) exists for merchants to upload and manage their own product feeds. It cannot read Shopping search results. Extracting what shoppers see requires a third-party scraping API.
Why do Google Shopping product lookups from older tutorials fail?
Google shut down the legacy product/offers page. Endpoints keyed by product_id now return explicit shutdown errors (SerpApi) or empty billed responses (ScrapingDog's legacy endpoint). The working replacement is the immersive-product flow: a search call harvests a page token or catalog ID, and a second call exchanges it for product details.
Can Google Shopping results be filtered by price?
Not with the old tbs= URL parameters; today's surface ignores them entirely. Working filters go through Google's shoprs tokens, which appear in each search response's filter list. SerpApi converts its price params to those tokens server-side (15/15 in our tests), and Scrape.do applies them when passed directly (10/10). ScrapingDog and ScraperAPI currently have no working filter path.
How many results does one Google Shopping search return?
Around 40 products per page for every provider we measured, and deep pagination is effectively unavailable (SerpApi documents its start parameter as ignored). Plan coverage through query and locale variety rather than paging depth.
The search layer is a solved problem; any of four providers will hand you 40 titled, priced, sellered products per query. The product and filter layers are where the ecosystem quietly broke when Google rebuilt its Shopping surface, and where 13 of 16 providers currently fall away. Everything above is dated 2026-08-03 and the method is documented, so when providers fix or break things again, the run is repeatable.
Head of Marketing
