# Google Shopping Scraper

Google Shopping Scraper searches Google Shopping by keyword and country and returns one JSON row per product: title, price as a number, currency, priceText, oldPrice, merchant, rating, reviewCount, productUrl, thumbnailUrl, delivery, isSponsored and position. It costs $0.0025 per product ($2.50 per 1,000, $1.70 per 1,000 on higher plans), with no start fee and no browser or API key. Run it in the Apify Console, the API or an MCP client.

## Key facts

- Price: from $0.0025 per product delivered, $2.50 per 1,000, down to $0.0017 on higher Apify plans
- Pricing model: Pay per event
- Output: JSON, CSV, Excel, XML, RSS via Apify datasets
- Access: Apify Console, REST API, Python and JS clients, MCP tool google_shopping
- Version: Updated Nov 2026, build 0.1.4
- Actor: subimpact/google-shopping-scraper

## Who it is for

- Ecommerce teams benchmarking competitor pricing by market
- Retail analysts tracking merchant offers on a product family
- Brand protection teams finding resellers and grey-market listings
- Marketplace sellers watching their price position

## Use cases

### Track a product family's prices

Set queries to specific variants such as iphone 16 128gb and iphone 16 pro max 256gb, then run daily and diff on title plus merchant. price and oldPrice show whether a discount is real, and priceText keeps Google's exact wording for installment cards where the number is a monthly amount rather than the full price.

### See who sells it cheapest

sortBy price_low_to_high orders the delivered rows by price, and each row carries merchant, rating, reviewCount and delivery. That produces a merchant ladder for a keyword: who is cheapest, who is well rated and who offers free delivery. Because gl also decides the currency, a my run returns MYR prices rather than a converted USD figure.

### Find the best rated offers

sortBy rating_high_to_low puts the strongest rated cards first, with rating and reviewCount expanded from Google's abbreviations, so 23K becomes 23000. Filtering out rows with no rating gives a shortlist of established sellers, which is useful before adding a merchant to a procurement list or a comparison page.

### Watch for sponsored placement

isSponsored marks cards in a module Google labels as sponsored, so you can separate paid placement from organic results before reporting a price gap. That matters when a low price looks like a market signal but is actually a promoted tile, and it keeps a competitor analysis honest about which offers Google chose to surface.

### Localise prices by country

gl changes both the result set and the currency Google prints, so the same query with gl set to gb, de and my returns three local price lists. currency records the ISO code inferred from the price text. That is a cheap way to compare a product's positioning across markets without a currency conversion step of your own.

## Price events

- Product delivered (`product-scraped`): $0.0025, lowest tier $0.0017. One Google Shopping product row delivered with status ok: title, price, currency, merchant, rating, review count, delivery and image. Platform usage included. Empty and error rows are never charged.

Prices from the Apify Store. Apify shows the final price before each run.

## How it compares with other Apify actors

Price per 1,000 products at Apify Store list prices, checked 20 Nov 2026.

| Actor | Price per 1,000 products (Free plan) | Higher plans (Gold) | Start fee per run | Platform usage | Users | Rating | Last build |
| --- | --- | --- | --- | --- | --- | --- | --- |
| Google Shopping Scraper (Cheap, No Browser) (this API) | $2.50 | $1.70 | None | Included | 1 | No reviews yet | 20 Nov 2026 |
| [Google Shopping Insights](https://apify.com/epctex/google-shopping-scraper) | $4.40 | $4.40 | $0.00005 | Paid separately | 2,558 | No reviews yet | 20 Nov 2026 |
| [✨ Google Shopping Scraper](https://apify.com/damilo/google-shopping-apify) | $3.50 | $3.50 | None | Included | 1,567 | 4.6 (5 reviews) | 19 Nov 2026 |
| [Google Shopping Scraper](https://apify.com/burbn/google-shopping-scraper) | $20.00 | $5.00 | $0.008 | Included | 1,219 | 5.0 (2 reviews) | 10 Sep 2026 |
| [Free Google Shopping Scraper - Extract offers from any EAN/SKU](https://apify.com/s-r/free-google-shopping-scraper---extract-offers-from-any-ean-sku) | Bills one item per offer found for an EAN or SKU, not per search result product. | Same unit, see the first price column | None | Included | 624 | No reviews yet | 17 Nov 2026 |

### Where Google Shopping Insights is stronger

- Larger user base among the Google Shopping actors listed here
- Optional comparison prices and extra product details per item
- Rows carry a shopping id, a merchant link and the search position

### Where this API is stronger

- Platform usage is included in the actor price
- One row holds price, old price, merchant, rating and delivery text
- No browser required, so runs use less compute

### Where ✨ Google Shopping Scraper is stronger

- Most monthly runs among the shopping actors listed here
- Each product can carry an offers list next to the headline price
- Query, country, language and pagination are all separate inputs

### Where this API is stronger

- Rows state the old price and the currency explicitly
- A list of queries runs in one job with a cap per query
- Plain HTTP with no browser in the container

### Where Google Shopping Scraper is stronger

- Seller and store detail sits beside offers and shipping information
- Long standing listing with steady monthly use
- Extracts offers and shipping terms for each product

### Where this API is stronger

- Rows carry old price, currency and delivery text for every product
- Plain HTTP, so no browser rendering is needed
- A per query cap and a total item cap keep a run bounded

### Where Free Google Shopping Scraper - Extract offers from any EAN/SKU is stronger

- Starts from an EAN or SKU rather than a keyword search
- Collects the offers of every seller for that identifier
- Well suited to checking one product across many shops

### Where this API is stronger

- Keyword search returns many products per query with a position
- Rows carry old price, delivery text and merchant per product
- Several queries run in one job with a per query cap

Google Shopping has several established actors, all billing per product row. epctex has the largest audience and adds comparison prices, damilo is the most active and returns offer lists, burbn returns seller and shipping detail, and s-r turns an EAN or SKU into offers from every seller. Ours keeps price, old price, merchant, rating and delivery in one row.

Prices are Apify Store list prices, checked 20 Nov 2026. Platform usage 'Paid separately' means Apify bills compute on top of the event price. Check each listing before you buy.

## Input

- `queries` (array, optional): One or more Google Shopping searches, e.g. `iphone 16` or `running shoes`. Each query returns Google's first Shopping results page (about 40 products). Add more queries to cover more products. Maximum 100 queries per run.
- `gl` (string, optional): Two-letter country code for the Google country setting. It also decides the currency Google shows (us = USD, gb = GBP, de = EUR, my = MYR, ...). Examples: us, gb, de, my, sg, au, in.
- `hl` (string, optional): Google interface language. Use a two-letter code like en, de or ms, or a regional code like en-GB.
- `maxProductsPerQuery` (integer, optional): Upper bound on delivered product rows for each query. Google's first Shopping page is server-rendered with about 40 product cards and there is no working page-2 URL (verified November 2026), so in practice a query returns at most 40-50 r...
- `maxItems` (integer, optional): Global cost ceiling: the run stops after this many product rows, across all queries. At $0.0025 per product, 100 rows cost $0.25. The default single query returns about 40 products, so a default run costs about $0.10 plus proxy usage.
- `sortBy` (string, optional): How Google should order the results. Google's own sort control is discovered on each page and followed (one extra request per query); if the page shows no sort control the results stay in Google's default order.
- `includeInlineThumbnails` (boolean, optional): Google embeds many product images directly in the page as base64 data (about 10 KB each) instead of linking them. Off (default): those rows get thumbnailUrl = null and your dataset stays small. On: thumbnailUrl holds the data: URI. Linke...
- `concurrency` (integer, optional): How many queries are fetched in parallel. Higher is faster but uses more proxy sessions at once. Default 5.

### Example input

```json
{
  "queries": [
    "iphone 16"
  ],
  "gl": "us",
  "hl": "en",
  "maxProductsPerQuery": 40,
  "maxItems": 100,
  "concurrency": 5
}
```

## Output fields

- `query` (string/null): The search query this product was found for.
- `position` (integer/null): 1-based position of the product in the delivered rows for its query. Null on empty and error rows.
- `title` (string/null): Product title exactly as Google shows it. Null on empty and error rows.
- `price` (number/null): Price as a number in the row's currency, parsed from the price Google shows. Monthly installment cards carry the per-month amount (see priceText). Null when Google shows no price.
- `currency` (string/null): ISO 4217 currency code inferred from the price text (symbol or code) and the row's country setting, e.g. USD, GBP, EUR, MYR, VND.
- `priceText` (string/null): The price exactly as Google shows it, e.g. "$829.00" or "$25.23/mo".
- `oldPrice` (number/null): The comparison price Google shows next to a discounted item ("Was $660" or "Usually $360"), as a number. Null when the card has no discount.
- `merchant` (string/null): Store or seller Google shows on the card, e.g. "Best Buy" or "Walmart - YYWireless & more".
- `rating` (number/null): Star rating on a 0-5 scale, e.g. 4.4. Null when the card shows no rating.
- `reviewCount` (integer/null): Number of reviews behind the rating. Google abbreviates on the card (23K), so values are expanded to integers. Null when the card shows no reviews.
- `productUrl` (string/null): A Google Shopping link for this exact product title. Google builds its per-product page URLs client-side, so the server-rendered HTML carries no per-product URL; this link re-runs the title as a Shopping search.
- `thumbnailUrl` (string/null): Product thumbnail. Either a Google image URL (https://encrypted-tbn*.gstatic.com/...) or, for cards whose image Google inlines, a data: URI of the same image.
- `delivery` (string/null): Delivery line Google shows for the offer, e.g. "Free delivery" or "Free delivery by Tue". Null when the card shows none (Google shows delivery mostly for US results).
- `isSponsored` (boolean/null): True when the card is labelled as a sponsored placement by Google, otherwise false.
- `scrapedAt` (string): ISO 8601 timestamp of the request that produced this row.
- `status` (string): ok for a product row, empty for a query that returned no products, error for a query that failed. Empty and error rows are never charged.
- `error` (string/null): Reason for an empty or error row. Null on product rows.

## Sample output

Trimmed from one of our own test runs. Personal data is redacted.

```json
[
  {
    "query": "wireless earbuds",
    "position": 1,
    "title": "JLab Go Air Pop True Wireless Earbuds. 3D",
    "price": 14.99,
    "currency": "USD",
    "priceText": "$14.99",
    "oldPrice": null,
    "merchant": "Target",
    "rating": 4.3,
    "reviewCount": 33000,
    "productUrl": "http://www.google.com/search?q=JLab+Go+Air+Pop+True+Wireless+Earbuds.+3D&udm=28&hl=en&gl=us",
    "thumbnailUrl": null,
    "delivery": "Free delivery on $35+",
    "isSponsored": false,
    "scrapedAt": "2026-11-20T03:42:41.085Z",
    "status": "ok",
    "error": null
  },
  {
    "query": "wireless earbuds",
    "position": 2,
    "title": "Bose QuietComfort Noise-Cancelling Wireless Earbuds",
    "price": 129,
    "currency": "USD",
    "priceText": "$129.00",
    "oldPrice": 179,
    "merchant": "Best Buy",
    "rating": 4.2,
    "reviewCount": 5300,
    "productUrl": "http://www.google.com/search?q=Bose+QuietComfort+Noise-Cancelling+Wireless+Earbuds&udm=28&hl=en&gl=us",
    "thumbnailUrl": null,
    "delivery": "Free delivery",
    "isSponsored": false,
    "scrapedAt": "2026-11-20T03:42:41.085Z",
    "status": "ok",
    "error": null
  }
]
```

## How to run it

1. Put your keywords in queries, for example ["iphone 16"], up to 100 per run.
2. Set gl to the country, such as us, gb, de or my, which also fixes the currency, and hl to the interface language.
3. Set maxProductsPerQuery, 40 by default, and maxItems, 100 by default, as the run's spend ceiling.
4. Choose sortBy: relevance, price_low_to_high, price_high_to_low or rating_high_to_low.
5. Start the run in the Apify Console; one row per product card appears, plus status rows for queries with no results.
6. Export as JSON, CSV or Excel, and keep priceText next to price when installment offers are in the set.

### cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/subimpact~google-shopping-scraper/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"queries":["iphone 16"],"gl":"us","hl":"en","maxProductsPerQuery":40,"maxItems":100,"concurrency":5}'
```

### Python

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")
run = client.actor("subimpact/google-shopping-scraper").call(run_input={
      "queries": [
        "iphone 16"
      ],
      "gl": "us",
      "hl": "en",
      "maxProductsPerQuery": 40,
      "maxItems": 100,
      "concurrency": 5
    })

for item in client.dataset(run["default_dataset_id"]).iterate_items():
    print(item)
```

### JavaScript

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: '<YOUR_APIFY_TOKEN>' });
const run = await client.actor('subimpact/google-shopping-scraper').call({
  "queries": [
    "iphone 16"
  ],
  "gl": "us",
  "hl": "en",
  "maxProductsPerQuery": 40,
  "maxItems": 100,
  "concurrency": 5
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();

console.log(items);
```

### MCP

```bash
claude mcp add subimpact-data -e APIFY_TOKEN=<YOUR_APIFY_TOKEN> -- npx -y @subimpact/data-mcp

# Then ask your agent to use the google_shopping tool.
```

### n8n

Use the Apify node (Run an Actor).
Actor ID: subimpact/google-shopping-scraper
Input JSON: paste the example input below.

## Limits

- Google ships about 40 cards per query and has no working page 2, so coverage per query is limited.
- Sponsored tiles in the separate ad carousel at the top of the page are not included.
- delivery is present mainly on US results and null elsewhere.
- Installment cards put the monthly amount in price rather than the full price.

## FAQ

### What does a product cost?

$0.0025 per delivered product row, which is $2.50 per 1,000 products, and $1.70 per 1,000 on higher Apify plans. There is no start fee. Queries that return no products or fail are delivered as status rows and cost nothing.

### Do I need a Google API key or browser?

No. The Actor requests Google's Shopping tab and parses the server-rendered product cards over plain HTTP through Apify's Google SERP proxy, so there is no browser, no key and no captcha service. Proxy usage is part of the price and the Actor never falls back to a direct request.

### How many products can one query return?

About 40, and a page with recommendation shelves can carry 40 to 60. There is no working page-2 URL, so maxProductsPerQuery only trims what one page holds. To cover more, add narrower queries such as a specific model, capacity or colour.

### Why is price sometimes a monthly amount?

Some cards are installment offers, and price then holds the per-month amount with priceText carrying the full wording, such as a monthly figure spread over 36 months. Read priceText whenever the number looks too low for the product, and filter those rows out before a price comparison.

### What currency are prices in?

The currency of the gl country, because Google serves local prices rather than converting to your account's currency. currency gives the ISO code, so a gl of my returns MYR, gb returns GBP and de returns EUR, and priceText keeps the original formatting.

### Does the productUrl open the product page?

Not directly to the merchant. Google builds per-product page URLs in the browser and ships no usable per-product link in the HTML, so productUrl re-runs the exact product title as a Shopping search, which is a link that opens reliably.

### Why is delivery missing on some rows?

Google prints delivery lines mostly on US results, so the field is null when the card carries none. The same applies to rating, which is null on cards without a star rating, and to oldPrice, which Google prints only when it holds a reference price for the offer.

## Links

- Page: https://subimpact.net/apis/google-shopping-scraper/
- Category: https://subimpact.net/apis/category/ecommerce/
- Run on Apify: https://apify.com/subimpact/google-shopping-scraper
- All data APIs: https://subimpact.net/apis/
- Catalogue JSON: https://subimpact.net/apis/catalogue.json
