[Blog](https://scrapfly.io/blog) / [api](https://scrapfly.io/blog/tag/api) / [Google Shopping API: What Google Offers and How to Get Shopping Results Data](https://scrapfly.io/blog/posts/google-shopping-api-and-alternatives) # Google Shopping API: What Google Offers and How to Get Shopping Results Data by [Mayada Shaaban](https://scrapfly.io/blog/author/mayada-shaaban-90143e67) Nov 10, 2026 19 min read [\#api](https://scrapfly.io/blog/tag/api) [\#ecommerce](https://scrapfly.io/blog/tag/ecommerce) [\#python](https://scrapfly.io/blog/tag/python) [ ](https://www.linkedin.com/sharing/share-offsite/?url=https%3A%2F%2Fscrapfly.io%2Fblog%2Fposts%2Fgoogle-shopping-api-and-alternatives "Share on LinkedIn") [ ](https://x.com/intent/tweet?url=https%3A%2F%2Fscrapfly.io%2Fblog%2Fposts%2Fgoogle-shopping-api-and-alternatives&text=Google%20Shopping%20API%3A%20What%20Google%20Offers%20and%20How%20to%20Get%20Shopping%20Results%20Data "Share on X") [ ](https://www.facebook.com/sharer/sharer.php?u=https%3A%2F%2Fscrapfly.io%2Fblog%2Fposts%2Fgoogle-shopping-api-and-alternatives "Share on Facebook") Summarize this article with [ ](https://chat.openai.com/?q=Summarize%20this%20article%20and%20explain%20how%20Scrapfly%20helps%20me%20scrape%20any%20website%20at%20scale%20and%20bypass%20anti-bot%20systems%20for%20my%20use%20case%3A%20https%3A%2F%2Fscrapfly.io%2Fblog%2Fposts%2Fgoogle-shopping-api-and-alternatives) [ ](https://claude.ai/new?q=Summarize%20this%20article%20and%20explain%20how%20Scrapfly%20helps%20me%20scrape%20any%20website%20at%20scale%20and%20bypass%20anti-bot%20systems%20for%20my%20use%20case%3A%20https%3A%2F%2Fscrapfly.io%2Fblog%2Fposts%2Fgoogle-shopping-api-and-alternatives) [ ](https://x.com/i/grok?text=Summarize%20this%20article%20and%20explain%20how%20Scrapfly%20helps%20me%20scrape%20any%20website%20at%20scale%20and%20bypass%20anti-bot%20systems%20for%20my%20use%20case%3A%20https%3A%2F%2Fscrapfly.io%2Fblog%2Fposts%2Fgoogle-shopping-api-and-alternatives) [ ](https://www.perplexity.ai/search/new?q=Summarize%20this%20article%20and%20explain%20how%20Scrapfly%20helps%20me%20scrape%20any%20website%20at%20scale%20and%20bypass%20anti-bot%20systems%20for%20my%20use%20case%3A%20https%3A%2F%2Fscrapfly.io%2Fblog%2Fposts%2Fgoogle-shopping-api-and-alternatives) [ ](https://www.google.com/search?udm=50&aep=11&q=Summarize%20this%20article%20and%20explain%20how%20Scrapfly%20helps%20me%20scrape%20any%20website%20at%20scale%20and%20bypass%20anti-bot%20systems%20for%20my%20use%20case%3A%20https%3A%2F%2Fscrapfly.io%2Fblog%2Fposts%2Fgoogle-shopping-api-and-alternatives) Google Shopping is a great source of product prices, however it's a JavaScript heavy page which means we can't just request it with an HTTP client. For example, if we take a look at what httpx gets for `wireless earbuds`, there's only a "Please click here if you are not redirected within a few seconds" message and no product cards. What about an official Google Shopping API? Google does have the Merchant API, though it's used by sellers to manage their own products in Merchant Center and it doesn't return any search results. So, we'll take a look at what that API does cover and then scrape the Shopping results page with Python instead - all the way to 66 product cards in JSON. ## Key Takeaways - There's no public Google API for Shopping search results. Google's own Shopping API, the Merchant API, is made for merchants managing their own products. - The Merchant API replaced the Content API for Shopping, which Google sunset on August 18, 2026. - Status code 200 isn't enough on Google Shopping - a plain HTTP request to a results URL can return it with no product cards at all. Our scraper should look for the cards instead. - Shopping prices and stores follow the location. Meaning, the `gl` URL parameter and the proxy country should point to the same market. - The results grid can't give us every seller's price for a product (each Shopping result card shows a single store). - Scrapfly's [Web Scraping API](https://scrapfly.io/products/web-scraping-api) renders a Shopping page through a US proxy with the Unblocker (previously ASP). Its Extraction API turns the cards into JSON from a plain prompt - no selectors to write! **Get web scraping tips in your inbox**Trusted by 100K+ developers and 30K+ enterprises. Unsubscribe anytime. ## Is There a Google Shopping API? Not exactly. If we open Google's Merchant API docs we can see that it's made for merchants. It manages the store's own products in Merchant Center, which means we can't use it to read other stores' listings. What about competitor prices then? Google doesn't document any API for Shopping search results, so we have to collect them from the public results page instead - a pretty common [ecommerce data collection](https://scrapfly.io/use-case/ecommerce-web-scraping) task! Note that some older forum answers still recommend Google's Search API for Shopping. Unfortunately, it was retired back in 2013 so these tutorials won't work anymore. [Best SERP APIs in 2026: Official Google Alternatives & Third-Party ProvidersNo official Google SERP API exists. Compare official alternatives (DuckDuckGo, Brave, Yandex) and third-party SERP APIs (SerpApi, Serper, DataForSEO, Scrapfly) with verified performance benchmarks and current pricing data.](https://scrapfly.io/blog/posts/google-serp-api-and-alternatives) ## What Does the Merchant API Do, and What Happened to the Content API for Shopping? So what Shopping APIs does Google actually have? There are 2 of them, and the key thing they share is that both are made for merchants - neither of them returns Shopping search results. The first one is the [Merchant API](https://developers.google.com/merchant/api/overview), which sellers use to manage their own Merchant Center account - their products, inventory, data sources and reports. The second one is the older Content API for Shopping, which Google sunset on August 18, 2026. Since September 1, projects without an extension get occasional HTTP 410 Gone errors from it. Unfortunately, extensions only buy some time, as they end with the final shutdown in early 2027 (see the [Content API sunset guide](https://developers.google.com/shopping-content/guides/deprecation-and-sunset)). Both of them only work for a logged-in seller through OAuth 2.0 or a service account. For example, here's what we get when listing products for a made-up account ID without logging in: bash ```bash curl https://merchantapi.googleapis.com/products/v1/accounts/123456/products ``` json ```json { "error": { "code": 401, "message": "Request is missing required authentication credential. Expected OAuth 2 access token, login cookie or other valid authentication credential. See https://developers.google.com/identity/sign-in/web/devconsole-project.", "status": "UNAUTHENTICATED", "details": [ { "@type": "type.googleapis.com/google.rpc.ErrorInfo", "reason": "CREDENTIALS_MISSING", "domain": "googleapis.com", "metadata": { "method": "google.shopping.merchant.products.v1.ProductsService.ListProducts", "service": "merchantapi.googleapis.com" } } ] } } ``` As you can see, Google refuses the request with a 401 `UNAUTHENTICATED` error, as there are no credentials attached. Meaning, there's no public query we could send for Shopping search results. Even the market data in its reports (like best sellers or a `benchmark_price` for products a store already sells) is only there for the merchant. ## How Do You Get Google Shopping Results Without an Official API? Since there's no API for it, we'll have to scrape the Shopping results page itself - the same page we see in the browser, with prices and stores for our query and location. Scraping it isn't that straightforward though, as Google makes this page pretty difficult to read for scrapers. ### Why Do Simple Google Shopping Scrapers Get Blocked or Return Nothing? Google Shopping is using several techniques that make scraping difficult. The first one is JavaScript rendering - the page needs JavaScript to show its product cards, so if we request it with a regular HTTP client like httpx (`pip install httpx`) we won't see them: python ```python import httpx url = "https://www.google.com/search?q=wireless+earbuds&udm=28&hl=en&gl=us" headers = { "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 " "(KHTML, like Gecko) Chrome/141.0.0.0 Safari/537.36" } response = httpx.get(url, headers=headers) print(response.status_code) print("JBL Vibe Beam" in response.text) # a product from the rendered page print("not redirected within a few seconds" in response.text) ``` In the example above, we're requesting the Shopping page for "wireless earbuds" and checking whether one of the products we see in the browser is in the response: text ```text 200 False True ``` As you can see, the request is successful with a 200 status code, however there are no products in it. The only text on the page is "Please click here if you are not redirected within a few seconds". So, our scraper should always check for product cards and not just the status code. The second one is Google's "unusual traffic" page, which asks for a CAPTCHA when Google thinks the traffic is automated. Google's own [help page](https://support.google.com/websearch/answer/86640) lists "search scrapers" as one of the causes and says shared networks can trigger it too. Unfortunately, that's where scrapers on cloud servers can get into trouble - one [r/webscraping user](https://www.reddit.com/r/webscraping/comments/1ejup0c/scraping_google_shopping_pricing_page/) expected AWS IPs to "face Captcha after 1/2 results". The third one is the page's markup itself. We could write CSS selectors for the product cards, though we'd have to fix them every time Google updates its page. So instead of selecting product cards, we'll describe them and let an extraction prompt find them for us. Regular Google search pages have similar problems, which we cover in our guide on [scraping Google search results](https://scrapfly.io/blog/posts/how-to-scrape-google). As for the blocking, we'll be using Scrapfly's [Unblocker](https://scrapfly.io/products/unblocker) in the next section. ## How Do You Fetch a Google Shopping Results Page as JSON? To get past the first two problems we'll be using Scrapfly's [Web Scraping API](https://scrapfly.io/products/web-scraping-api). It can render the Shopping page in a real browser through a US proxy with the Unblocker turned on. For our scraper we'll be using Python with: - scrapfly-sdk - Scrapfly's [Python SDK](https://scrapfly.io/docs/sdk/python) which will let us send requests through the Web Scraping API (the `unblocker` argument needs version 0.12.0 or newer) - parsel - HTML parsing library which we'll only use to read the page title These packages can be installed via `pip` command: bash ```bash pip install "scrapfly-sdk>=0.12.0" parsel ``` Now, let's request the Shopping page for "wireless earbuds". Our script reads the API key from the `SCRAPFLY_KEY` environment variable: python ```python import os from urllib.parse import urlencode from scrapfly import ScrapflyClient, ScrapeConfig client = ScrapflyClient(key=os.environ["SCRAPFLY_KEY"]) def shopping_url(query, gl="us", hl="en"): params = {"q": query, "udm": 28, "hl": hl, "gl": gl} return "https://www.google.com/search?" + urlencode(params) result = client.scrape(ScrapeConfig( url=shopping_url("wireless earbuds"), render_js=True, country="US", unblocker=True, # older SDKs call this asp=True )) print(result.status_code) print(result.selector.css("title::text").get()) ``` In the example above, we're building the Shopping URL with a small `shopping_url()` function and sending it through Scrapfly with `render_js`, `country="US"` and `unblocker` turned on. Then we print the status code and the page title (the `.selector` property is the one that needs parsel): text ```text 200 wireless earbuds - Google Shopping ``` This time we got the real Shopping page! You might also see a `session_sticky_proxy` warning from the SDK above these two lines - it's harmless and we can just ignore it. When running this on a schedule we'd also set `cost_budget`, as Scrapfly then fails any request that would cost more credits than that budget. ### Which Google Shopping URL Parameters Matter? Our `shopping_url()` function only sets four of Google's URL parameters, which is enough to get a Shopping page for one market: | Parameter | Example | What it does | |---|---|---| | `q` | `wireless+earbuds` | Search query | | `udm` | `28` | Shopping results | | `hl` | `en` | Interface language | | `gl` | `us` | Country of results | The most important one here is `gl`, as prices and stores change with location. Meaning, it should always match the proxy `country` - for example, a German proxy with `gl=us` can mix two markets in one page. What about filters like price ranges? The easiest way is to apply the filter in the browser and copy the URL, instead of building these parameters by hand. [9 Best E-commerce Web Scraping Tools for Developers in 2026Retrieval, access, extraction, discovery, browser, or screenshots? Pick the narrowest e-commerce scraping tool that fixes your broken layer in 2026.](https://scrapfly.io/blog/posts/best-e-commerce-web-scraping-tools) ## How Do You Extract Products, Prices and Stores From Google Shopping? Now that we can load the Shopping page, let's extract the product cards from it. For this we can add an `extraction_prompt` to the same request, and Scrapfly will return the product list in `extracted_data`, so we don't need any CSS selectors for it! Our prompt is basically the schema of our data, as it names every key we want and the shape of the output - the same keys our CSV code will read later. So, we'll keep it in a `CARD_PROMPT` constant to make sure every run asks for the same keys: python ```python import json import os from urllib.parse import urlencode from scrapfly import ScrapflyClient, ScrapeConfig client = ScrapflyClient(key=os.environ["SCRAPFLY_KEY"]) CARD_PROMPT = ( "Return a JSON array of the product cards on this Google Shopping results page. " "Use these keys for each card: product_name, price, original_price (only if shown), " "store_name (store or seller), rating, review_count." ) def shopping_url(query, gl="us", hl="en"): params = {"q": query, "udm": 28, "hl": hl, "gl": gl} return "https://www.google.com/search?" + urlencode(params) result = client.scrape(ScrapeConfig( url=shopping_url("wireless earbuds"), render_js=True, country="US", unblocker=True, # older SDKs call this asp=True extraction_prompt=CARD_PROMPT, )) cards = result.scrape_result["extracted_data"]["data"] print(len(cards), "cards") print(json.dumps(cards[:3], indent=2)) # save the cards for the price monitoring step with open("cards.json", "w") as f: json.dump(cards, f, indent=2) ``` In the example above, we're sending the same rendered request as before, only this time with our prompt attached. Then we print the first three cards and save all of them to `cards.json` for later: text ```text 66 cards [ { "original_price": null, "price": "$64.99", "product_name": "JBL Vibe Buds 2 Noise Cancelling True Wireless Earbuds", "rating": "5.0", "review_count": "737", "store_name": "Target & more" }, { "original_price": "$130", "price": "$89.99", "product_name": "Soundcore by Anker Liberty 5 Wireless Noise Cancelling In-Ear Earbuds", "rating": "4.7", "review_count": "1.7K", "store_name": "soundcore US & more" }, { "original_price": "$80", "price": "$68.95", "product_name": "Beats Solo Buds Wireless Earbuds", "rating": "3.2", "review_count": "6.1K", "store_name": "Best Buy & more" } ] ``` Your output will differ, as Shopping cards and prices change between runs. All 66 of our cards had a name, price and store, 61 had a rating and review count, and 39 showed an original price. ### Prompt Extraction or an Auto Model: Which Fits Shopping Pages? Scrapfly's [Extraction API](https://scrapfly.io/products/extraction-api) has three ways to extract data: templates with CSS or XPath rules, [LLM prompts](https://scrapfly.io/docs/extraction-api/llm-prompt) like the one we just used and [automatic AI models](https://scrapfly.io/docs/extraction-api/automatic-ai) like `product_listing`. Let's give the `product_listing` model a try on the same page: python ```python import json import os from scrapfly import ScrapflyClient, ScrapeConfig client = ScrapflyClient(key=os.environ["SCRAPFLY_KEY"]) result = client.scrape(ScrapeConfig( url="https://www.google.com/search?q=wireless+earbuds&udm=28&hl=en&gl=us", render_js=True, country="US", unblocker=True, extraction_model="product_listing", # instead of extraction_prompt )) products = result.scrape_result["extracted_data"]["data"]["products"] print(len(products), "products") print(json.dumps(products[0], indent=2)) ``` Here we're sending the same Shopping URL, only with `extraction_model` in place of our prompt. This is the first product it found: text ```text 40 products { "identifiers": null, "image_url": null, "name": "JBL Vibe Beam 2 True Wireless Earbuds", "position": 1, "price": { "amount": 39.99, "currency": "USD", "raw": "$39.99 $65" }, "rating": 4.2, "specifications": null, "tags": [ "38% OFF" ], "url": "https://www.google.com/search?sca_esv=8995e508bdeacb41&udm=28&hl=en&gl=us&sxsrf=APpeQnsBZod0pTYDMBPTHlUBLOxyYaYcPQ:1793102552407&q=best+overall+wireless+earbuds+&shopmd=1&source=w2bmore&sa=X&ved=2ahUKEwjbjLrFk9qXAxXTJkQIHVT7FUIQ5-8KegQIGRAE" } ``` The price is already split into `39.99` and `USD` here, though there's no store name or review count, and the $65 original price is only in the `raw` string. The `url` also leads back to a Google search page (in another run this model found 66 products, and for 45 of the 46 products it shared with our prompt the ratings matched). Since we need the store to tell offers apart, we'll stick with the prompt for Shopping pages - just compare a few cards with the page in the browser before trusting a new one. As for templates, they're CSS selectors again, which is exactly what we're trying to avoid here. Scrapfly #### Scale your web scraping effortlessly Scrapfly handles proxies, browsers, and anti-bot bypass — so you can focus on data. [Try Free →](https://scrapfly.io/register)## What Data Does a Google Shopping Result Card Give You? Each product card on the Shopping grid is pretty small, so there isn't much on it. If we take a look at the second card from our run, we can see everything it has: | Field | Example from our run | Notes | |---|---|---| | name | Soundcore by Anker Liberty 5 Wireless Noise Cancelling In-Ear Earbuds | As shown | | price | $89.99 | String with symbol | | original price | $130 | Only on discounts | | store | soundcore US & more | One store shown | | rating | 4.7 | Out of 5 | | review count | 1.7K | Abbreviated | Here we have the Soundcore earbuds at $89.99 from soundcore US, down from $130, with a 4.7 rating from about 1.7K reviews. The "& more" after the store is interesting too, as Google is telling us other stores have these earbuds as well. The grid just doesn't say which ones or at what price, and for that we'd need to scrape the product's own page (which we won't cover here). Most of the other 65 cards look the same, but not all of them. A Soundcore pair from Back Market, for example, has "Refurbished" right in its price ($169.00 Refurbished), and a $25.00 JLab JBuds Mini pair on Mercari has no rating or reviews at all. Even the "& more" isn't always there - the TikTok Shop cards just say TikTok Shop. We'll have to handle all of these when cleaning up the data in the next section. [7 Best E-commerce Product Data APIs for Developers in 2026Seven e-commerce product data APIs compared by access model, from storefront catalogs and marketplace listings to seller-only operations feeds.](https://scrapfly.io/blog/posts/best-ecommerce-product-data-apis) ## How Do You Turn Shopping Results Into Price Monitoring Data? Our cards are still plain text though - the Soundcore earbuds cost `"$89.99"` and have `"1.7K"` reviews, which isn't something we can compare between runs. On top of that, a few products are in our list more than once. Let's fix both of these and write the cleaned up cards to a CSV file: python ```python import csv import json import re from datetime import datetime, timezone def parse_price(raw): # grabs "169.00" out of "$169.00 Refurbished" match = re.search(r"([$€£])\s*([\d,]+(?:\.\d+)?)", raw or "") if not match: return None, None return float(match.group(2).replace(",", "")), match.group(1) def parse_count(raw): if not raw: return None raw = raw.replace(",", "").upper() if raw.endswith("K"): return int(float(raw[:-1]) * 1000) return int(raw) def normalize(card, position): price, currency = parse_price(card.get("price")) original, _ = parse_price(card.get("original_price")) return { "position": position, "name": card.get("product_name"), "store": card.get("store_name"), "price": price, "original_price": original, "currency": currency, "rating": float(card["rating"]) if card.get("rating") else None, "reviews": parse_count(card.get("review_count")), "price_raw": card.get("price"), } def dedupe(rows): seen, unique = set(), [] for row in rows: key = (row["name"], row["store"], row["price"]) if key not in seen: seen.add(key) unique.append(row) return unique cards = json.load(open("cards.json")) rows = dedupe([normalize(card, i) for i, card in enumerate(cards, start=1)]) if not rows: # an empty run would overwrite the last good CSV raise SystemExit("no cards extracted, keeping the old shopping_run.csv") run = {"query": "wireless earbuds", "gl": "us", "proxy_country": "US", "scraped_at": datetime.now(timezone.utc).isoformat()} with open("shopping_run.csv", "w", newline="") as f: writer = csv.DictWriter(f, fieldnames=[*run, *rows[0]]) writer.writeheader() for row in rows: writer.writerow({**run, **row}) print(f"{len(cards)} cards, {len(cards) - len(rows)} duplicates removed") print(rows[0]) ``` Here the `parse_price()` function grabs the number out of strings like `"$169.00 Refurbished"`, while `parse_count()` turns `"1.7K"` into `1700`. Then `dedupe()` keeps one copy of each name, store and price, and every row gets the run's query, country and time. If the extraction came back empty, the script stops before opening the CSV, so the last good file stays. If we run it on our cards we'll see: text ```text 66 cards, 10 duplicates removed {'position': 1, 'name': 'JBL Vibe Buds 2 Noise Cancelling True Wireless Earbuds', 'store': 'Target & more', 'price': 64.99, 'original_price': None, 'currency': '$', 'rating': 5.0, 'reviews': 737, 'price_raw': '$64.99'} ``` So 10 of our 66 cards were duplicates - the JLab GO POP+ earbuds from TikTok Shop alone were in there seven times! Note that the Bose QuietComfort Ultra earbuds stayed in twice though - once at $229.00 from Dell and once at $245.45 from Greentoe. Both rows stay, as these are two separate offers $16.45 apart, and that's exactly the kind of difference we want to see. Our competitor pricing tutorial shows how to [build a price tracker](https://scrapfly.io/blog/posts/how-to-track-competitor-pricing-using-web-scraping) that compares runs like this one. Matching products whose titles differ between stores is harder, and that's where [product matching across stores](https://scrapfly.io/blog/posts/how-to-build-a-grocery-price-comparison-tool-with-python) comes in. [Competitor Price Monitoring with Crawler APIBuild an automated competitor price monitoring system using Scrapfly Crawler API. Track thousands of products, handle anti-bot protection, and integrate with repricing tools.](https://scrapfly.io/blog/posts/competitor-price-monitoring-with-crawler-api) ## Power Up With Scrapfly Apart from our first httpx test, the Shopping requests in this article went through Scrapfly's [Web Scraping API](https://scrapfly.io/products/web-scraping-api). Let's quickly recap what each option in our `ScrapeConfig` did for us. The `unblocker` option turned on Scrapfly's [Unblocker](https://scrapfly.io/products/unblocker) for each of these requests. Our `country` option picked the proxy from Scrapfly's [residential and datacenter pools](https://scrapfly.io/docs/scrape-api/proxy), so it could match the `gl` market, while `render_js` loaded the page in a [real cloud browser](https://scrapfly.io/docs/scrape-api/javascript-rendering) - that's why the product cards were there at all. Then, our `extraction_prompt` handed the cards to the [Extraction API](https://scrapfly.io/products/extraction-api), which returned them as JSON. Alternatively, we could use an [automatic AI model](https://scrapfly.io/docs/extraction-api/automatic-ai) like `product_listing` instead of an [LLM prompt](https://scrapfly.io/docs/extraction-api/llm-prompt). That's just the tip of the iceberg though - [sessions](https://scrapfly.io/docs/scrape-api/session) can keep cookies, headers and IPs consistent across multi step flows, and there are [Python](https://scrapfly.io/docs/sdk/python) and [TypeScript](https://scrapfly.io/docs/sdk/typescript) SDKs as well as [no-code integrations](https://scrapfly.io/docs/integration/getting-started). ### Web Scraping API Scrape any website with our powerful API. Anti-bot bypass, JavaScript rendering, and rotating proxies built-in. [Try Web Scraping API](https://scrapfly.io/docs/scrape-api/getting-started) ## FAQ Is there a free Google Shopping API?No, not for Shopping search results. Google's Merchant API does give merchants some market data, like best-seller and price competitiveness reports, though only inside their own Merchant Center account. Google has no public API for the results page, so for other sellers' prices we have to scrape it like we did above. Did the Content API for Shopping shut down?It is being retired in stages. Google sunset it on August 18, 2026 and replaced it with the Merchant API. If you still have Content API code running, you might've already seen HTTP 410 Gone errors, as those started on September 1, 2026 for projects without an extension. The API is set to go away for good in early 2027. Can you get every seller's price for a product from Google Shopping?Not really - every card on the grid only names one store. The other offers are on the product's own page. How do you get Google Shopping results for another country?Set the `gl` parameter and the proxy `country` to the same country, e.g. `gl="de"` with `country="DE"` for Germany (our `parse_price()` only handles US prices though). ## Summary We started this guide by taking a look at Google's Shopping APIs and found that the Merchant API is made for sellers - it gives them some market data through its reports, but Google has no public API for Shopping search results. Then we built a Google Shopping scraper which is capable of rendering the results page, extracting product cards with a prompt and turning them into clean price data for monitoring. For this we've used Python with the scrapfly-sdk package, and to avoid being blocked we used Scrapfly's [Web Scraping API](https://scrapfly.io/products/web-scraping-api) with the Unblocker. That got us 66 product cards for "wireless earbuds" in a single request. For more on Scrapfly see our documentation and try it out! Legal Disclaimer and PrecautionsThis tutorial covers popular web scraping techniques for education. Interacting with public servers requires diligence and respect: - Do not scrape at rates that could damage the website. - Do not scrape data that's not available publicly. - Do not store PII of EU citizens protected by GDPR. - Do not repurpose *entire* public datasets which can be illegal in some countries. Scrapfly does not offer legal advice but these are good general rules to follow. For more you should consult a lawyer. [ Add as a preferred source ](https://google.com/preferences/source?q=scrapfly.io) Table of Contents Table of Contents - [Key Takeaways](#key-takeaways) - [Is There a Google Shopping API?](#is-there-a-google-shopping-api) - [What Does the Merchant API Do, and What Happened to the Content API for Shopping?](#what-does-the-merchant-api-do-and-what-happened-to-the-content-api-for-shopping) - [How Do You Get Google Shopping Results Without an Official API?](#how-do-you-get-google-shopping-results-without-an-official-api) - [Why Do Simple Google Shopping Scrapers Get Blocked or Return Nothing?](#why-do-simple-google-shopping-scrapers-get-blocked-or-return-nothing) - [How Do You Fetch a Google Shopping Results Page as JSON?](#how-do-you-fetch-a-google-shopping-results-page-as-json) - [Which Google Shopping URL Parameters Matter?](#which-google-shopping-url-parameters-matter) - [How Do You Extract Products, Prices and Stores From Google Shopping?](#how-do-you-extract-products-prices-and-stores-from-google-shopping) - [Prompt Extraction or an Auto Model: Which Fits Shopping Pages?](#prompt-extraction-or-an-auto-model-which-fits-shopping-pages) - [What Data Does a Google Shopping Result Card Give You?](#what-data-does-a-google-shopping-result-card-give-you) - [How Do You Turn Shopping Results Into Price Monitoring Data?](#how-do-you-turn-shopping-results-into-price-monitoring-data) - [Power Up With Scrapfly](#power-up-with-scrapfly) - [FAQ](#faq) - [Summary](#summary) Join the Newsletter Get monthly web scraping insights Scale Your Web Scraping Anti-bot bypass, browser rendering, and rotating proxies, all in one API. Start with 1,000 free credits. No credit card required 1,000 free API credits Anti-bot bypass included [Start Free](https://scrapfly.io/register) [View Docs](https://scrapfly.io/docs/onboarding) Not ready? Get our newsletter instead. ## Related Articles [ python scrapeguide ### How to Scrape Google Search Results in 2026 In this scrape guide we'll be taking a look at how to scrape Google Search - the biggest index of public web. We'll cov... ](https://scrapfly.io/blog/posts/how-to-scrape-google) [ curl ### How to Use cURL GET Requests Here's everything you need to know about cURL GET requests and some common pitfalls you should avoid. ](https://scrapfly.io/blog/posts/how-to-use-curl-get-requests) [ python playwright ### How to Scrape Google Maps We'll take a look at to find businesses through Google Maps search system and how to scrape their details using either S... ](https://scrapfly.io/blog/posts/how-to-scrape-google-maps) Scale your web scraping effortlessly, **1,000 free credits** [Start Free](https://scrapfly.io/register)