How to Scrape Google Shopping Results

Google does not document Merchant API as a general API for searching public Google Shopping results. It is for managing a merchant’s own Merchant Center account and related product, inventory, and performance data. If you need public Shopping results, first check Google’s current terms and machine-readable instructions, applicable law, and whether your intended use is permitted. There is no supported public-results scraper contract documented in the sources cited here.

This guide explains the distinction, how to choose an authorized route, what to record for a reproducible product comparison, and how to capture a Shopping page for visual inspection without treating a screenshot as structured product data.

1. Start by identifying the data you actually need

“Google Shopping API” can mean different things. Clarify whether you need data you own in Merchant Center, product information submitted by merchants, public search results, or a visual record of a page. Those are different tasks with different access routes.

Need	Relevant route	What it does not establish
Manage your own Merchant Center products, inventory, account, or reports	Google Merchant API, with account permissions and OAuth 2.0	It is not documented as an endpoint for arbitrary public Shopping searches.
Provide Google with your own product information	Merchant Center feeds and product structured data	These are merchant data-sharing routes, not public-results extraction interfaces.
Research products shown to the public on Shopping	Review the applicable terms, machine-readable instructions, laws, and your use before automating access	The sources reviewed do not document a stable public results API, selector set, or response schema.
Keep a visual record of a page you are authorized to view	A browser screenshot or screenshot service	A screenshot is an image, not a structured, validated product feed.

Google says Merchant Center participation is required for listings in the Shopping tab, and describes structured data and feeds as ways merchants share product data with Google. Product information may take time to synchronize across sources, so do not assume every view reflects an instantaneous update. See Google’s product data guidance.

2. Check terms and permissions before automating public access

Google’s Terms of Service cover Google Shopping. They prohibit automated access that violates machine-readable instructions on Google pages, giving robots.txt disallow rules as an example, and prohibit bypassing systems or protective measures. That is Google’s stated service rule; it does not settle whether a particular method or downstream use is lawful in every jurisdiction.

Identify the exact pages, fields, volume, and purpose you need.
Read the current Google terms and the relevant machine-readable instructions for the pages involved.
Consider applicable privacy, intellectual-property, contract, and local-law requirements for collection and reuse.
If you cannot establish that the access and intended use are permitted, do not automate it. Seek an authorized source or appropriate legal advice.
Do not build around CAPTCHA avoidance, proxy rotation to evade controls, identity concealment, or other bypasses. Google’s terms expressly address bypassing systems or protective measures.

This article does not provide a public Google Shopping scraper or claim that scraping is universally lawful or unlawful. The research did not establish jurisdiction-specific legal outcomes, and the public interface is not documented here as a supported extraction contract.

3. Use Merchant API for your own merchant data

If you are managing your own Merchant Center account, assess the official Merchant API documentation. Google announced Merchant API as the successor and primary interface replacing Content API for Shopping. The announcement stated that Content API would shut down after August 18, 2026; check the current migration and version status before implementation because API lifecycles change.

Merchant API requires suitable account access and OAuth 2.0. Follow Google’s current setup instructions for project configuration, scopes, credentials, and the specific account and product operations you need. Do not copy an endpoint or scope from an old Content API integration and assume it remains valid. Merchant API is the route to investigate for authorized merchant-account management; it is not a documented public Shopping results search endpoint.

4. If public research is permitted, define a reproducible collection plan

There is no stable public-results schema established by the sources in this guide. If your exact method and use are permitted, treat the result as variable page content and design your process around validation rather than assuming a particular selector or field always exists.

Fix the scope. Record the query, country, language, device or viewport, collection time, and any filters. Shopping results can vary by these and other factors.
Specify required fields. Decide whether you need product name, seller, displayed price, currency, availability, destination URL, or another field. Record missing values explicitly.
Preserve provenance. Store the source URL, capture time, query and context alongside each observation. Keep raw evidence only as long as your policies and permissions allow.
Validate values. Prices may be displayed with locale-specific separators or currency symbols. Availability and offers can change. Do not parse a number while silently discarding its currency or seller context.
Check consistency. Compare repeated observations, note changes, and separate “not shown” from “unavailable.” Google notes that data synchronization can lag across product sources.
Use conservative operational limits. Avoid unnecessary requests, stop on access restrictions or errors, and do not retry in ways that evade a control.
Review downstream use. Confirm permission to retain, analyze, or republish the collected fields, images, and links.

Do not promise selector stability, universal coverage, or identical results across locations. A result set is a time- and context-specific observation, not an authoritative inventory or price guarantee.

5. Capture a visual reference with a browser

A browser screenshot can document what a permitted page looked like at a particular moment. It cannot reliably turn visible cards into structured records, establish completeness, or prove that a price remains current. The following is a generic Playwright pattern for a page you are authorized to access. It does not bypass restrictions and intentionally leaves selectors and consent handling to the page and your permitted workflow.

import asyncio
from pathlib import Path
from playwright.async_api import async_playwright

async def main():
    url = "https://www.google.com/search?tbm=shop&q=example+product"
    async with async_playwright() as p:
        browser = await p.chromium.launch(headless=True)
        page = await browser.new_page(viewport={"width": 1440, "height": 1000})
        response = await page.goto(url, wait_until="domcontentloaded", timeout=30000)
        print("HTTP status:", response.status if response else "no response")
        await page.screenshot(path="shopping-reference.png", full_page=True)
        await browser.close()

asyncio.run(main())

Install the package and browser binaries using the current Playwright Python installation guide. The example captures a visual reference; it does not extract products. The query URL is illustrative, and page routing or behavior may change. If access is denied, a challenge appears, or the page is blank, stop and review the applicable instructions rather than trying to defeat the restriction.

cURL: request a page only where permitted

cURL can retrieve an HTTP response for inspection, but it does not execute browser JavaScript or create a screenshot. This example is a basic request to a URL; it is not a recommendation to automate Google Shopping collection.

curl --fail --location --max-time 30 \
  'https://www.google.com/search?tbm=shop&q=example%20product' \
  --output response.html

Python: retrieve a permitted page response

import requests

url = "https://example.com/page-you-are-authorized-to-access"
response = requests.get(url, timeout=(5, 30))
response.raise_for_status()
print("status:", response.status_code)
print("content type:", response.headers.get("content-type"))
print(response.text[:1000])

This requests example does not execute JavaScript and does not imply that a particular Google page permits automated access. Use the actual authorized source and its documented access method.

Node.js: retrieve a permitted page response

const url = 'https://example.com/page-you-are-authorized-to-access';
const response = await fetch(url, { signal: AbortSignal.timeout(30000) });
if (!response.ok) {
  throw new Error(`HTTP ${response.status}`);
}
console.log('content type:', response.headers.get('content-type'));
console.log((await response.text()).slice(0, 1000));

For a browser-rendered visual capture in Node.js, use Playwright’s current official setup documentation and the same navigation and screenshot steps shown in the Python example. Neither HTTP example supplies a supported Google Shopping extraction API.

6. Or skip the browser setup

For a visual screenshot of a page you are authorized to view, ScreenshotNeo is a website screenshot API and MCP server for developers. One GET request returns a PNG, JPEG, WebP, or PDF. See the ScreenshotNeo API documentation for parameters and setup.

curl -G "https://api.screenshotneo.com/v1/shot" -d access_key=YOUR_API_KEY --data-urlencode url=https://www.google.com/search?tbm=shop%26q=example%2Bproduct -o shot.webp

import requests
r = requests.get("https://api.screenshotneo.com/v1/shot", params={"access_key": "YOUR_API_KEY", "url": "https://www.google.com/search?tbm=shop&q=example+product"}, timeout=90)
open("shot.webp", "wb").write(r.content)

const q = new URLSearchParams({ access_key: 'YOUR_API_KEY', url: 'https://www.google.com/search?tbm=shop&q=example+product' });
const res = await fetch(`https://api.screenshotneo.com/v1/shot?${q}`);
if (!res.ok) throw new Error(`Screenshot request failed: ${res.status}`);
await import('node:fs/promises').then(fs => fs.writeFile('shot.webp', Buffer.from(await res.arrayBuffer())));

Cookie banners, newsletter popups, and chat widgets are removed before the shot. Bot checks, blank pages, timeouts, and failed loads are never billed; response headers report the page verdict and billing status. Its MCP server lets AI agents use screenshot, page-info, and PDF capture tools. The free plan includes 1,000 screenshots a month with no card; paid plans start at $5 for 3,000. A screenshot documents appearance; it does not provide structured Shopping results or authorize access to a page.

7. Troubleshooting and edge cases

Symptom	Likely cause	What to do
Merchant API authorization fails	The account lacks access, OAuth configuration is incomplete, or scopes/credentials do not match the operation.	Use the current Merchant API setup documentation; verify account permissions and OAuth configuration.
Expected public results endpoint is missing	Merchant API is being confused with public Shopping search.	Merchant API documents merchant account data management. Do not treat it as a public-results endpoint.
Browser screenshot is blank or incomplete	Navigation may not have completed, the page may depend on later rendering, or access may be restricted.	Check the response and page state, use a reasonable wait for pages you may access, and stop if a restriction or challenge is shown.
HTTP response differs from what the browser displays	A simple HTTP client does not run page JavaScript.	Use a browser only for an authorized visual task; do not assume page markup is an extraction contract.
Price parsing produces the wrong value	Locale separators, currency, promotions, or seller context were ignored.	Keep the original displayed string and record locale, currency, seller, and capture time before normalization.
Results change between runs	Query context, country, device, time, product availability, or source synchronization changed.	Record context for every observation and treat results as time-specific.
Page shows a CAPTCHA or access block	The service is restricting access or requesting an interaction.	Do not attempt to bypass the control. Stop and use an authorized route.

8. Reliability, performance, and cost

Reliability: An undocumented public interface can change without notice. Merchant API has a documented purpose, but only for authorized Merchant Center data operations. Design around the source’s actual contract.
Freshness: Product price and availability are time-sensitive, and source synchronization may lag. Timestamp observations and avoid presenting them as guarantees.
Performance: For authorized work, request only the data or captures needed, use bounded timeouts, and avoid redundant polling. Browser rendering consumes more resources than a plain HTTP request, but a plain request may not represent rendered content.
Failure handling: Distinguish HTTP failures, navigation timeouts, incomplete content, access restrictions, and missing fields. Retrying an ordinary transient failure is different from evading a protective measure; stop when a restriction is encountered.
Cost: Merchant API setup and operating costs should be checked in current Google documentation and your cloud/account configuration. For ScreenshotNeo screenshots, the free tier is 1,000 per month; paid plans start at $5 for 3,000, with yearly billing offering two months free. Only clean shots are billed, and cache hits cost nothing.
Compliance and maintenance: Include engineering time for validation, page or API changes, permissions review, data retention, and downstream-use review. A third-party data service also requires independent review of its terms, coverage, and fields.

9. FAQ

Does Google Merchant API return Google Shopping search results?

It is documented for Merchant Center account, product, inventory, and reporting workflows, not as a general public Shopping search API.

Can I use product structured data to read competitors’ listings?

Google describes structured data as a way for merchants to share product information about their pages. It is not a public search-results extraction API.

Does a screenshot prove a product’s current price?

No. It records a visual state at capture time. Price, availability, seller, and context can change.

Is scraping Google Shopping legal?

This guide cannot determine the answer for every jurisdiction, method, and use. Check current terms, machine-readable instructions, applicable law, and your intended collection and reuse.