# Google Shopping Scraper (Cheap, No Browser) (`subimpact/google-shopping-scraper`) Actor

Search Google Shopping by keyword and get one row per product: title, price, currency, old price, merchant, rating, review count, delivery, image and a shopping link. No browser, no API key. From $2.50 per 1,000 products.

- **URL**: https://apify.com/subimpact/google-shopping-scraper.md
- **Developed by:** [subimpact network](https://apify.com/subimpact) (community)
- **Categories:** E-commerce, SEO tools
- **Features:** Limited permissions
- **Stats:** 1 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.70 / 1,000 product delivereds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Google Shopping Scraper (Cheap, No Browser)

Scrape Google Shopping results by keyword and country and get one clean JSON row per product:
title, price as a number, currency, old price, merchant, rating, review count, delivery, product
image and a link. Pure HTTP through Apify's Google SERP proxy — no browser, no API key, no captcha
solving service.

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

### What you get

One dataset item per product card, plus one status row for any query that returned no products or
failed (those rows are never charged). This is a real row from a live `gl=us` run (2026-11-15):

```json
{
  "query": "iphone 16",
  "position": 31,
  "title": "Apple iPhone 16 Pro - Carrier Unlocked - 256gb Black Titanium, Size: 6.3 in display",
  "price": 628.95,
  "currency": "USD",
  "priceText": "$628.95",
  "oldPrice": 930,
  "merchant": "Walmart - Kiss Electronics Inc",
  "rating": 4.8,
  "reviewCount": 112,
  "productUrl": "http://www.google.com/search?q=Apple+iPhone+16+Pro+-+Carrier+Unlocked+-+256gb+Black+Titanium%2C+Size%3A+6.3+in+display&udm=28&hl=en&gl=us",
  "thumbnailUrl": "https://encrypted-tbn1.gstatic.com/shopping?q=tbn:ANd9GcT7P8p5BwQ-v6ZhSDGKjre49S8YkSJWcHta9Gdn47H6IhEkBTyUHtB0mLJ2q_F6Iq86AZhJJrs4HHUF7I8xPqwduS7LVfu3DIgX8217V257",
  "delivery": "Free delivery",
  "isSponsored": false,
  "scrapedAt": "2026-11-14T19:46:02.628Z",
  "status": "ok",
  "error": null
}
```

#### Fields

| Field | Meaning |
| --- | --- |
| `query` | The search query this row was found for. |
| `position` | 1-based position in the delivered rows for that query. |
| `title` | Product title exactly as Google shows it. |
| `price` | Price as a number in `currency`, parsed from the price on the card (`$1,035.00` → `1035`, `₫21,990,000` → `21990000`, `1.234,56 €` → `1234.56`). Monthly installment cards carry the per-month amount — check `priceText`. |
| `currency` | ISO 4217 code inferred from the price text and `gl` (`USD`, `GBP`, `EUR`, `MYR`, `VND`, ...). |
| `priceText` | The price exactly as Google shows it, e.g. `"$829.00"` or `"$25.23 per month for 36 months"`. |
| `oldPrice` | The comparison price Google prints next to a discount (`"Was $660"`, `"Usually $360"`) as a number. `null` when the card has no discount. |
| `merchant` | Store or seller on the card, e.g. `"Best Buy"` or `"Walmart - YYWireless & more"` (Google's own wording). |
| `rating` | Star rating, 0–5. `null` when the card shows none. |
| `reviewCount` | Reviews behind the rating, expanded from Google's abbreviations (`23K` → `23000`). |
| `productUrl` | A Google Shopping link for this exact product title. Google builds per-product page URLs in the browser and ships no per-product link in the HTML (its `/shopping/product/<id>` endpoint answers "Not available" for ids taken from the results page), so the row carries a link that re-runs the title as a Shopping search — a link you can actually open. |
| `thumbnailUrl` | Product image. Either a Google image URL (`https://encrypted-tbn*.gstatic.com/...`) When Google inlines the image instead of linking it, `null` by default, or the `data:` URI if you turn on `includeInlineThumbnails`. |
| `delivery` | Delivery line as shown, e.g. `"Free delivery"` or `"Free delivery by Tue"`. Google prints these mostly for US results; `null` when absent. |
| `isSponsored` | `true` when the card sits in a module Google marks as sponsored. |
| `scrapedAt` | ISO 8601 timestamp of the request that produced the row. |
| `status` | `ok` for a product row, `empty` for a query with no products, `error` for a failed query. |
| `error` | Reason for an `empty`/`error` row, otherwise `null`. |

### Input

| Field | Default | Notes |
| --- | --- | --- |
| `queries` | `["iphone 16"]` | Up to 100 Google Shopping searches per run. |
| `gl` | `"us"` | Country setting. It also decides the currency Google prints (`us` → `$`, `gb` → `£`, `de` → `€`, `my` → `RM`). |
| `hl` | `"en"` | Interface language, e.g. `en`, `de`, `ms`, `en-GB`. |
| `maxProductsPerQuery` | `40` | Upper bound per query. Google renders roughly 40 product cards on the first results page (a page with recommendation shelves can carry 40–60); this cap trims them. |
| `maxItems` | `100` | Global spend ceiling across all queries. Default 100 rows = $0.25 of product charges. |
| `sortBy` | `"relevance"` | `relevance`, `price_low_to_high`, `price_high_to_low`, `rating_high_to_low`. |
| `concurrency` | `5` | Queries fetched in parallel. |

### Pricing

**$2.50 per 1,000 products** — that is $0.0025 per delivered product row, plus proxy usage. There is
no start fee. Only product rows are charged: a query that returns no products, or that fails, is
delivered as an `empty`/`error` row and costs nothing.

The charged event is `product-scraped`. A run stops when it reaches `ACTOR_MAX_PAID_DATASET_ITEMS`
(or the equivalent platform limit), so the maximum charge is capped by that setting and by
`maxItems`.

Cheap by design: one HTTP request per query (two when you ask for a non-default `sortBy`), no
browser, no unblocker.

### How it works

The actor requests `google.com/search?q=<query>&udm=28` (Google's Shopping tab) through Apify's
`GOOGLE_SERP` proxy and parses the server-rendered product cards. Google renders about 40 cards per
query server-side, so no browser and no scrolling is needed.

When `sortBy` is not `relevance`, the actor reads Google's own sort control out of the page and
follows that exact link, then also orders the delivered rows itself — a Shopping page is assembled
from several product modules (the main grid plus recommendation shelves like "General Use Earbuds")
and Google only sorts the main module, so the dataset order always matches what you asked for.
If a page has no sort control, the results keep Google's default order and the run log says so.

### Costs and limits

- Each query costs one proxy request. A run with 10 queries therefore makes 10–20 requests.
- `maxProductsPerQuery` is an upper bound: Google ships about 40 cards per query and there is no
  working page-2 URL (verified November 2026 — `start=20/40/60` returns a client-side redirect shell
  with no products). To collect more, add more, narrower queries.
- Google serves the currency of the `gl` country, not of your Apify account.

### Tips

- One query per product family, e.g. `iphone 16 128gb`, `iphone 16 pro max 256gb` — narrower
  queries give cleaner merchant and price lists.
- Use `sortBy: "price_low_to_high"` for price monitoring and `rating_high_to_low` to find the
  best-rated offers first.
- Compare `oldPrice` with `price` to spot real discounts; Google prints `oldPrice` only when it has
  a reference price for the offer.
- Run it on a schedule and diff by `title` + `merchant` to track price moves.

### Notes and limitations

- Sponsored tiles in Google's separate ad carousel on top of the page are not included; the rows
  are the products from the Shopping results modules.
- `delivery` is only present where Google prints it (mostly `gl: "us"`).
- Some cards are per-month installment offers; `price` is then the monthly amount and `priceText`
  carries the full text so nothing is hidden.
- The actor never falls back to a direct connection: it needs Apify Proxy with the `GOOGLE_SERP`
  group, which every Apify plan includes.

### Run monitoring and privacy

If a run fails or times out, this Actor tells its developer the run ID and status, so we can fix problems fast. It never sends your input, your results or your account data.

# Actor input Schema

## `queries` (type: `array`):

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` (type: `string`):

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` (type: `string`):

Google interface language. Use a two-letter code like en, de or ms, or a regional code like en-GB.

## `maxProductsPerQuery` (type: `integer`):

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 rows; this cap just trims them.

## `maxItems` (type: `integer`):

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` (type: `string`):

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` (type: `boolean`):

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. Linked images (https://encrypted-tbn\*.gstatic.com/...) are always kept.

## `concurrency` (type: `integer`):

How many queries are fetched in parallel. Higher is faster but uses more proxy sessions at once. Default 5.

## Actor input object example

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

# Actor output Schema

## `products` (type: `string`):

Dataset items: query, position, title, price, currency, priceText, oldPrice, merchant, rating, reviewCount, productUrl, thumbnailUrl, delivery, isSponsored, scrapedAt and status.

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

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

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "queries": [
        "iphone 16"
    ],
    "gl": "us",
    "hl": "en",
    "maxProductsPerQuery": 40,
    "maxItems": 100,
    "concurrency": 5
};

// Run the Actor and wait for it to finish
const run = await client.actor("subimpact/google-shopping-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "queries": ["iphone 16"],
    "gl": "us",
    "hl": "en",
    "maxProductsPerQuery": 40,
    "maxItems": 100,
    "concurrency": 5,
}

# Run the Actor and wait for it to finish
run = client.actor("subimpact/google-shopping-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "queries": [
    "iphone 16"
  ],
  "gl": "us",
  "hl": "en",
  "maxProductsPerQuery": 40,
  "maxItems": 100,
  "concurrency": 5
}' |
apify call subimpact/google-shopping-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,subimpact/google-shopping-scraper"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/04pyjBE2jFBjmodd5/builds/JjkikQyjKzTuMIEFN/openapi.json
