---
title: "How to Scrape Google Shopping (2026 Guide) | Scrape.ly"
description: "Scrape Google Shopping prices, sellers, ratings and review counts by search or URL. No-code steps, API code, a real run and its exact cost per product."
url: https://scrape.ly/blog/scrape-google-shopping
markdown: https://scrape.ly/blog/scrape-google-shopping.md
---

[Tutorials](https://scrape.ly/blog/category/tutorials.md)

# How to Scrape Google Shopping: Prices, Sellers and Ratings in Seconds

Scrape Google Shopping by search or results URL and get product title, price, seller, rating, review count and position as clean rows, for any country. The no-code steps, curl, Python, Node.js and MCP, a real run from 26 October 2026 and its exact cost.

[Shelfbright Actor publisher on the Scrape.ly Store](https://scrape.ly/blog/author/shelfbright.md)

- Published

  Oct 26, 2026

- Reading time

  9 min read

![Pixel-art robot with an orange >\_ on its terminal head lifts a yellow price tag off a shopping results page headed by the four-colour Google Shopping bag and two product tiles, and drops it into a crate of price tags](https://scrape.ly/media/scrape-google-shopping.png?w=1080)

To scrape Google Shopping, send a product search or a Shopping results URL to a scraper that reads Google's public Shopping results and saves each product with its title, price, seller, rating, review count and position. On Scrape.ly that is one ready-made Actor: you type "wireless mouse", pick a country, and get rows back in a few seconds at $4.17 per 1,000 products, with no Google account, Merchant Center or proxy of your own.

This guide covers the fields you get, the no-code steps, the same job in curl, Python, Node.js and through an AI agent, then a real run from 26 October 2026 with its log and exact cost. It closes with the pitfalls and the legal picture. More Google how-tos: [Google Flights](https://scrape.ly/blog/scrape-google-flights.md) and [Google Scholar](https://scrape.ly/blog/scrape-google-scholar.md).

## What data you can scrape from Google Shopping

The [Google Shopping Scraper](https://scrape.ly/store/shelfbright/google-shopping-scraper.md) saves one row per product card. These are the fields you'll use most:

| Field                                      | What it holds                                                              |
| ------------------------------------------ | -------------------------------------------------------------------------- |
| `productName`                              | Product title as Google shows it                                           |
| `price`                                    | Price text with the currency symbol, such as `$12.99`                      |
| `merchantName`                             | The store on the card: Target, Walmart, Best Buy …                         |
| `reviewsScore`, `reviewsCount`             | Average rating out of 5 and number of reviews, when shown                  |
| `positionOnSearchPage`                     | Rank in the results for that search, starting at 1                         |
| `searchKeyword`                            | The query the row came from                                                |
| `shoppingId`                               | Google Shopping catalog ID, stable across runs                             |
| `productLink`, `productImage`              | Link to the product on Google Shopping and the image URL                   |
| `sponsored`                                | True for sponsored listings, when you ask for them                         |
| `withoutDiscountPrice`                     | The crossed-out previous price, in browser mode                            |
| `productDetails`, `merchantLink`           | Longer description and the first store offer, when requested               |
| `offerTitle`, `deliveryInfo`, `returnInfo` | The store's own title, delivery and returns text, on comparison-price rows |

Rating, review count and image are left out of a row when Google doesn't show them for that product. The `shoppingId` is the field to key on if you track the same products over time, because titles can change between runs.

## How to scrape Google Shopping without code

1. Open the Actor's page in the Scrape.ly Store.
2. Pick the preset [Wireless mice in the US, 10 products](https://scrape.ly/store/shelfbright/google-shopping-scraper/presets/search-us.md). "Try this input" loads it in the console. This is the exact input of our run:

```json
{
  "queries": ["wireless mouse"],
  "maxItems": 10,
  "countryCode": "us",
  "maxItemsPerQuery": 5,
  "includeSponsoredResults": false,
  "includeComparisonPrices": false,
  "includeExtraProductDetails": false
}
```

3. Change the query and country to yours, and click **Start**.
4. Open the **Products** view and export JSON, CSV, Excel or HTML.

The fields that matter most:

- `queries`: product searches, one per line. Each one is searched once, so duplicates cost nothing extra.
- `startUrls`: Shopping results URLs copied from your browser, used when `queries` is empty. A normal website URL stops the run with a clear message.
- `countryCode` and `location`: the country sets the Google Shopping site and the proxy exit; `location` narrows it to a city such as "Austin, Texas, United States".
- `maxItems` and `maxItemsPerQuery`: the cap for the whole run and for each search. The preset caps each search at 5, which is why our run saved 5 products, not 10.
- `includeComparisonPrices`, `includeSponsoredResults`, `includeExtraProductDetails`: optional extras that switch the run to browser mode (see the pitfalls below).

Want the same search from Germany? The [Wireless mice in Germany](https://scrape.ly/store/shelfbright/google-shopping-scraper/presets/search-de.md) preset changes only `countryCode`, so you can compare markets row by row.

Scrape.ly Store Google Shopping Scraper Products, prices, sellers, ratings and review counts from any Google Shopping search or results URL, for any country. $4.17 per 1,000 products, platform usage included.

[Try it free](https://scrape.ly/store/shelfbright/google-shopping-scraper.md) [Browse the Store](https://scrape.ly/store.md)

## Scrape Google Shopping with the API

Create an API token under **Settings → API & Integrations** in the dashboard and export it as `SCRAPELY_TOKEN`. Our run finished in 8 seconds, so the synchronous endpoint can start it and return the products in one call:

```shell
curl -X POST "https://api.scrape.ly/v2/actors/shelfbright~google-shopping-scraper/run-sync-get-dataset-items"
  -H "Authorization: Bearer $SCRAPELY_TOKEN"
  -H "Content-Type: application/json"
  -d '{"queries": ["wireless mouse"], "maxItems": 10, "countryCode": "us", "maxItemsPerQuery": 5}'
```

The call waits up to 45 seconds and returns a JSON array; add `?format=csv` for CSV. Runs with comparison prices or many searches can take longer, and then the call answers `408` while the run keeps going. For those, start the run with `POST /v2/actors/shelfbright~google-shopping-scraper/runs`, poll `/v2/actor-runs/RUN_ID?waitForFinish=60` until the status is `SUCCEEDED`, and read `/v2/actor-runs/RUN_ID/dataset/items`. The [Actors API docs](https://scrape.ly/docs/api-actors.md) show the full flow.

Python (`pip install scrapely-client-python`). `call()` waits for the run however long it takes. This script turns the price text into a number and prints the cheapest offer per store:

```python
import os
from scrapely_client import ScrapelyClient

client = ScrapelyClient(os.environ["SCRAPELY_TOKEN"], api_url="https://api.scrape.ly")

run = client.actor("shelfbright/google-shopping-scraper").call(
    run_input={"queries": ["wireless mouse"], "maxItems": 10, "countryCode": "us", "maxItemsPerQuery": 5}
)
print(run.status)  # SUCCEEDED, FAILED, ABORTED or TIMED-OUT

cheapest = {}
for item in client.dataset(run.default_dataset_id).iterate_items():
    price = float(item["price"].lstrip("$").replace(",", ""))
    store = item["merchantName"]
    if store not in cheapest or price < cheapest[store][0]:
        cheapest[store] = (price, item["productName"])

for store, (price, name) in sorted(cheapest.items(), key=lambda kv: kv[1][0]):
    print(f"{store:10} ${price:6.2f}  {name}")
```

Node.js (`npm install scrapely-client`):

```javascript
import { ScrapelyClient } from 'scrapely-client';

const client = new ScrapelyClient({ token: process.env.SCRAPELY_TOKEN, baseUrl: 'https://api.scrape.ly' });

const run = await client.actor('shelfbright/google-shopping-scraper').call({
  queries: ['wireless mouse'],
  maxItems: 10,
  countryCode: 'us',
  maxItemsPerQuery: 5,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items.map((i) => [i.positionOnSearchPage, i.price, i.merchantName, i.productName]));
```

The [Python client docs](https://scrape.ly/docs/client-python.md) cover paging through large datasets; the JavaScript client works the same way. If you'd rather think of this as an endpoint than an Actor, the [Google Shopping API](https://scrape.ly/api/google-shopping-api.md) page describes the same data as an API product.

### With an AI agent (MCP)

Scrape.ly runs a hosted MCP server at `https://mcp.scrape.ly`. In Cursor, add it to `~/.cursor/mcp.json`:

```json
{
  "mcpServers": {
    "scrapely": {
      "url": "https://mcp.scrape.ly",
      "headers": { "Authorization": "Bearer YOUR_TOKEN" }
    }
  }
}
```

In Claude Code, run `claude mcp add --transport http scrapely https://mcp.scrape.ly` and sign in with `/mcp`. To give the agent only this Actor, use `https://mcp.scrape.ly?actors=shelfbright/google-shopping-scraper`. Then ask: "Use scrapely to run shelfbright/google-shopping-scraper for 'wireless mouse' in the US, 5 products, and give me a table of price, store, rating and review count." The agent calls `call-actor`, then `get-actor-output`. Our run in this article was started exactly that way. The [MCP docs](https://scrape.ly/docs/mcp.md) list the other clients.

## A real run: wireless mice in the US

We ran the preset on 26 October 2026. It saved 5 products in 8 seconds, and its list price was $0.0209. All five came from Google's US Shopping results for "wireless mouse":

| # | Product                                        | Price  | Store    | Rating | Reviews |
| - | ---------------------------------------------- | ------ | -------- | ------ | ------- |
| 1 | Logitech M196 Bluetooth Wireless Mouse         | $12.99 | Target   | 4.8    | 5,200   |
| 2 | Logitech M220 Silent Wireless Mouse            | $13.83 | Walmart  | 4.7    | 41,000  |
| 3 | LOGITECH SIGNATURE M650 WIRELESS MOUSE         | $33.99 | Best Buy | 4.8    | 21,000  |
| 4 | Logitech G305 Lightspeed Wireless Gaming Mouse | $29.49 | Target   | 4.6    | 6,400   |
| 5 | Logitech Silent Wireless Mouse                 | $13.83 | Walmart  | 4.1    | 269     |

The sellers here are retailers, so nothing needed masking. The log, without the platform's start-up lines:

```plaintext
20261026T14:25:25.173Z [Scrapely] Container started (setup 5.8 s)
20261026T14:25:26.542Z [scrapely.actor] INFO  [Scrapely] Initializing API storage for run b8cb3e0732dd4932b
20261026T14:25:26.668Z [scrapely.actor] INFO  Using fast mode. A search switches to browser mode only if fast mode fails.
20261026T14:25:27.078Z [scrapely.actor] INFO  Saved 5 products: 5 in fast mode (1 result pages), 0 in browser mode; 0 searches switched to browser mode. Search API calls: 1 (1 sent at startup, 0 resent, slowest 1304 ms).
20261026T14:25:27.078Z [scrapely.actor] INFO  [Status message]: Saved 5 products from 1 searches.
20261026T14:25:27.609Z [Scrapely] Container state: status=exited exitCode=0 oomKilled=false
```

What the five rows show:

- **One brand owns the top of the page.** Every product was a Logitech mouse, from a $12.99 Bluetooth model to the $33.99 Signature M650. If you research a category, run several queries, or you'll only see who wins the generic term.
- **Three stores split the page.** Target had two of the five cards, Walmart two and Best Buy one. Both Walmart cards showed $13.83, so a price tracker that keys on the store alone would mix two different mice.
- **Reviews tell you about demand.** The M220 carried 41,000 reviews against 269 for the plain "Silent Wireless Mouse" at the same price. Review counts above a thousand come rounded, the way Google shows them.
- **Fast mode did the work.** One search call, zero browser sessions and zero retries. Most of the 8 seconds was the container starting.

## What it costs

The Actor has two charge events: **$0.00417 per product** saved ($4.17 per 1,000) and **$0.00005 per run** for the Actor start. Platform usage (compute, proxy, browser) is included in those prices. A search that matches nothing saves no rows and pays no product fee. Prices checked on 26 October 2026.

- **Our run:** 5 × $0.00417 + $0.00005 = **$0.0209** at list price. The account was billed $0.0167, because its plan has a 20% Store discount.
- **A daily price check:** 20 queries × 25 products = 500 products, so 500 × $0.00417 + $0.00005 = $2.09 per run, about $63 for a month of daily runs.
- **1,000 products:** about $4.17, start fee included.

The Free plan's $5 of monthly credit covers close to 1,200 products. Set a maximum charge per run and the run stops when it reaches it, so a typo in `maxItems` can't turn into a large bill. See [pricing](https://scrape.ly/pricing.md) for plans.

## What to watch out for

- **Prices are text.** `price` keeps the currency symbol (`$12.99`, `12,99 €`). Strip it before you sort or average, as the Python example does, and keep `countryCode` in your rows if you compare markets.
- **About 250 to 300 products per search.** That's how many Google lists for a broad query. For a full category, split it into several narrower queries; the per-query and per-run limits keep the run predictable.
- **Extras are slower.** Sponsored listings, comparison prices and longer descriptions need browser mode: 30 to 60 seconds for 10 products, at most about 100 products per search, and sometimes rate-limited by Google outside the US. If Google blocks its Shopping page for a run, the Actor still saves the regular products and says so in the status message.
- **Location works in fast mode only.** City-level results apply to normal searches, not to browser-mode extras.
- **Results move.** Prices, sellers and ranking change through the day and by location. Save the run date with each row and schedule the same search to build a history keyed on `shoppingId`.
- **Layouts change; fields don't.** DIY guides break when Google renames classes: [MrScraper's guide](https://mrscraper.com/blog/how-to-scrape-google-shopping) (18 August 2026) parses `div.sh-dgr__content` cards with Playwright. With the Actor you read `price` and `merchantName`, and the publisher keeps the parser current.

## Is it legal to scrape Google Shopping?

The Actor reads the same public Shopping results any logged-out visitor sees, without signing in or buying anything, and the rows hold product and business facts: titles, prices, stores and ratings. Google's rules on automated access are specific, though. Its [Terms of Service](https://policies.google.com/terms) (effective July 30, 2026) list "using automated means to access content from any of our services in violation of the machine-readable instructions on our web pages (for example, robots.txt files that disallow crawling, training, or other activities)" as abuse, and Google's [robots.txt](https://www.google.com/robots.txt) disallows `/search` for all crawlers. Shopping results live under `/search` (the product links in our run carry `udm=28`), so read both before you build a product on this data.

Shopping data rarely includes personal data. Product images and titles belong to the stores and brands, so use the data for analysis and price monitoring rather than republishing Google's pages. Our guide on [whether web scraping is legal](https://scrape.ly/blog/is-web-scraping-legal.md) covers the general rules. This is general information, not legal advice: for commercial use, get advice for your case.

## Why Scrape.ly for Google Shopping data

- **No official route exists for this data.** Google's Content API for Shopping, which manages a merchant's own product feed, [was sunset on August 18, 2026](https://developers.google.com/shopping-content/guides/products/overview) in favor of the Merchant API, and neither searches other sellers' listings. The Actor reads the public results for any query and country.
- **Fast mode instead of a browser fleet.** Hand-built scrapers run headless Chromium, match proxy country to locale and wait for JavaScript. Our run used one search call and no browser at all.
- **Cost you can predict to the cent.** $4.17 per 1,000 products, platform usage included, plus a hard cap per run.
- **Built for monitoring.** Schedule the same queries daily, send rows to Google Sheets or a webhook, and compare them with Amazon, Walmart or [AliExpress](https://scrape.ly/blog/scrape-aliexpress.md) prices, as in our [price scraping](https://scrape.ly/blog/price-scraping.md) and [e-commerce scraping](https://scrape.ly/blog/ecommerce-scraping.md) guides.

## FAQ

### Does Google Shopping have an API?

Not for search results. Google's Merchant API serves merchants managing their own Merchant Center products, and the older Content API for Shopping was sunset on August 18, 2026. To read public Shopping results for any query, use a scraper such as the Google Shopping Scraper, which you can call over REST like any API.

### Can you scrape Google Shopping with Python?

Yes. Install `scrapely-client-python`, call `shelfbright/google-shopping-scraper` with your queries and iterate over the dataset, as in the example above. The scraping runs in the cloud, so your script needs no browser, parser or proxy.

### How do I scrape other sellers' prices for one product?

Turn on `includeComparisonPrices`, or start from the [Wireless mouse prices by store](https://scrape.ly/store/shelfbright/google-shopping-scraper/presets/search-us-comparison-prices-addon.md) preset. The Actor opens each product and saves one row per store with its price, delivery and returns text. It runs in browser mode, so expect 30 to 60 seconds for 10 products.

### Can I scrape Google Shopping for other countries?

Yes. Set `countryCode` (for example `de`, `gb` or `in`) and, optionally, a city in `location`. Pasted Shopping URLs keep the country already in the URL. Review counts outside English-speaking countries can come rounded, as Google shows them.

### How many products can I get from one search?

As many as Google lists, which is about 250 to 300 for a broad search. Use several related queries for more, and set `maxItemsPerQuery` so one broad term doesn't use up the whole run.

### How much does it cost to scrape Google Shopping?

$0.00417 per product plus $0.00005 per run, platform usage included, so about $4.17 per 1,000 products. Our 5-product run cost $0.0209 at list price.

Scrape.ly Store Scrape Google Shopping Run the wireless-mouse preset as-is, or type your own products and country. Prices, stores, ratings and review counts in seconds, at $4.17 per 1,000 products.

[Try it free](https://scrape.ly/store/shelfbright/google-shopping-scraper.md) [Browse the Store](https://scrape.ly/store.md)

About the author

[Shelfbright](https://scrape.ly/blog/author/shelfbright.md) Actor publisher on the Scrape.ly Store

Prices, stock and seller data from shops and marketplaces, from Amazon and AliExpress to Vinted and Leboncoin. For price trackers, catalogue teams and resellers. A Scrapely studio.

- [Website](https://scrape.ly/users/shelfbright.md)

Keep reading

## More in Tutorials

- [![Pixel-art robot with an orange >\_ on its terminal head pulls a film card with a poster and a gold star rating out of a cinema whose bulb-lit marquee carries the yellow IMDb logo, and drops it into a crate](https://scrape.ly/media/scrape-imdb.png?w=750)](https://scrape.ly/blog/scrape-imdb.md)
  ### [How to Scrape IMDb: Titles, Ratings, Cast and Box Office](https://scrape.ly/blog/scrape-imdb.md)
  [Scrape IMDb titles by keyword, chart, list, search URL or filters and get rating, votes, Metascore, genres, runtime, cast, directors, plot, budget and box office as clean rows. No-code steps, curl, Python, Node.js and MCP, a real run and what IMDb's terms say.](https://scrape.ly/blog/scrape-imdb.md)
- [![Pixel-art robot with an orange >\_ on its terminal head pulls a fare card with a blue plane and price off a departure board topped with the blue Google Flights logo, and drops it into a crate](https://scrape.ly/media/scrape-google-flights.png?w=750)](https://scrape.ly/blog/scrape-google-flights.md)
  ### [How to Scrape Google Flights: Fares, Airlines, Stops and Price History](https://scrape.ly/blog/scrape-google-flights.md)
  [Scrape Google Flights for any route and date and get every itinerary as JSON: fare, airline, flight numbers, times, stops, layovers, aircraft, legroom and carbon, plus Google's price insights. No-code steps, API and MCP code, and a real run that cost two cents.](https://scrape.ly/blog/scrape-google-flights.md)
- [![Pixel-art robot with an orange >\_ on its terminal head pulls a product card with a photo and a red price out of a stack of cardboard parcels marked with the red AliExpress logo, and drops it into a crate](https://scrape.ly/media/scrape-aliexpress.png?w=750)](https://scrape.ly/blog/scrape-aliexpress.md)
  ### [How to Scrape AliExpress: Products, Prices, Variants and Shipping](https://scrape.ly/blog/scrape-aliexpress.md)
  [Search AliExpress by keyword, then pull every product's variants, stock, shipping fees and seller record into clean rows. No code, curl, Python, Node.js or an AI agent, with two real runs from 26 October 2026 and the exact cost.](https://scrape.ly/blog/scrape-aliexpress.md)

## The internet is full of data. Start owning yours.

Scrape.ly gives you the infrastructure, the tooling, and the team to extract, process, and operationalize web data at any scale. Setup takes minutes.

[Get Started Free](https://my.scrape.ly/register) [Chat with Support](mailto:hello@scrape.ly?subject=Question%20about%20Scrape.ly\&body=Hi%2C%20I%20have%20a%20question%20about%20Scrape.ly.)

No credit card. No setup calls.
