# Google Shopping Results Scraper (`fetch_cat/google-shopping-results-scraper`) Actor

Extract Google Shopping product results by keyword, country, language, price range, and max item count for price and merchant research.

- **URL**: https://apify.com/fetch\_cat/google-shopping-results-scraper.md
- **Developed by:** [Hanna Nosova](https://apify.com/fetch_cat) (community)
- **Categories:** E-commerce, Marketing, SEO tools
- **Stats:** 1 total users, 1 monthly users, 96.8% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.23 / 1,000 item extracteds

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/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.
Actors are written with capital "A".

## 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.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## Google Shopping Results Scraper

Extract product cards from Google Shopping search results by keyword, country, language, and optional price range.

Use this actor to monitor product prices, compare sellers, find marketplace positioning, and export structured shopping data without copying result pages by hand.

### At a glance

- **Best for:** product price monitoring, merchant comparison, category research, paid-shopping snapshots, and ecommerce reporting.
- **Inputs:** product queries, country, language, result limit, optional price filters, and proxy settings.
- **Outputs:** one row per saved Google Shopping product card with title, price, merchant, rating, review count, shipping text, source URL, and timestamp.
- **Exports:** download CSV, JSON, Excel, XML, RSS, or use the Apify Dataset API.
- **Cost:** `$0.005` per run plus the `item` event for each saved product card.

### Ready-to-run examples

Use these saved Store examples as starting points. Open any example to prefill the Actor input, then adjust URLs, keywords, limits, or filters for your own run.

- **[Google Shopping gaming monitor scraper](https://apify.com/fetch_cat/google-shopping-results-scraper/examples/google-shopping-gaming-monitor-results)**
- **[Google Shopping skincare serum scraper](https://apify.com/fetch_cat/google-shopping-results-scraper/examples/google-shopping-skincare-serum-results)**
- **[Google Shopping Germany sneakers scraper](https://apify.com/fetch_cat/google-shopping-results-scraper/examples/google-shopping-de-sneakers-results)**
- **[Google Shopping UK air fryer price scraper](https://apify.com/fetch_cat/google-shopping-results-scraper/examples/google-shopping-uk-air-fryer-prices)**
- **[Google Shopping headphones under $100 scraper](https://apify.com/fetch_cat/google-shopping-results-scraper/examples/google-shopping-headphones-under-100)**
- **[Google Shopping laptops under $1000 scraper](https://apify.com/fetch_cat/google-shopping-results-scraper/examples/google-shopping-laptops-under-1000)**
- **[View all ready-to-run examples](https://apify.com/fetch_cat/google-shopping-results-scraper/examples)** (10 examples)

### What can it do?

Google Shopping Results Scraper searches Google Shopping for your product keywords and saves visible product result cards as a clean dataset.

| Capability | What it does |
| --- | --- |
| Search products | Run one Google Shopping query or a list of queries in the same job. |
| Target locale | Set country and language to compare localized shopping results. |
| Export product cards | Save titles, prices, merchants, ratings, review counts, shipping snippets, source URLs, and timestamps. |
| Filter prices | Optionally keep only products inside a minimum or maximum price range. |
| Control spend | Cap `maxItems` to keep test runs small and predictable. |

### Who is it for?

- **Ecommerce teams:** track how products appear in Google Shopping and compare visible offers.
- **Price intelligence teams:** monitor merchant prices, advertised pricing, and offer changes.
- **Marketplace analysts:** review ranking and seller coverage for product categories.
- **Agencies:** collect shopping snapshots for client reporting.
- **Product managers:** research comparable products before launch.
- **SEO and paid-shopping specialists:** understand competitive Shopping result pages by query and region.

### Why use this actor?

- Google Shopping pages are built for browsing, not spreadsheet exports.
- The actor converts result cards into flat JSON records.
- Each item is easy to export to CSV, Excel, Google Sheets, BigQuery, Snowflake, or your own API.
- Query and timestamp metadata make repeated runs easier to compare over time.
- The actor is designed for low-volume monitoring and research workflows.

### Output fields

| Field | Description |
| --- | --- |
| `query` | Search term that produced the item |
| `position` | Result position in the saved output |
| `productTitle` | Product title |
| `priceText` | Displayed price text |
| `priceValue` | Numeric price when available |
| `currency` | Currency inferred from the displayed symbol |
| `merchant` | Merchant or seller snippet |
| `productUrl` | Product link when available from the result markup |
| `imageUrl` | Product image URL when available |
| `rating` | Star rating |
| `reviewCount` | Number of reviews |
| `shipping` | Delivery or shipping snippet |
| `sourceUrl` | Google Shopping page URL used for extraction |
| `scrapedAt` | Time the result was saved |

### Output example

```json
{
  "query": "coffee maker",
  "position": 1,
  "productTitle": "Keurig K-Classic Coffee Maker K-Cup Pod Single Serve",
  "priceText": "$129.99",
  "priceValue": 129.99,
  "currency": "USD",
  "merchant": "Keurig.com",
  "productUrl": null,
  "imageUrl": null,
  "rating": 4.3,
  "reviewCount": 9700,
  "shipping": "Free delivery by Thu",
  "sourceUrl": "http://www.google.com/search?tbm=shop&udm=28&q=coffee+maker&hl=en&gl=US&num=100",
  "scrapedAt": "2026-06-30T10:00:00.000Z"
}
```

### Pricing

This Actor uses Apify pay-per-event pricing. The prices below come from the current Actor pricing configuration. Apify public plans map to Store discount tiers, so the table shows both the user-facing plan context and the pricing tier name. The final price shown in Apify depends on the user account plan and any custom agreement.

| Event | What is charged | Price |
| --- | --- | ---: |
| `start` | One-time fee charged when a run starts. Covers fixed startup cost (init, proxy warmup, first HTTP setup). | $0.005 |

| Event | What is charged | Free / no discount | Starter / Bronze | Scale / Silver | Business / Gold | Custom / Platinum | Custom / Diamond |
| --- | --- | ---: | ---: | ---: | ---: | ---: | ---: |
| `item` | Charged per item extracted. | $0.43569 / 1,000 | $0.37886 / 1,000 | $0.29551 / 1,000 | $0.22732 / 1,000 | $0.15155 / 1,000 | $0.10608 / 1,000 |

Apify may also charge platform usage for compute, storage, proxies, or data transfer outside this Actor pricing. Check the Actor run and the Apify Pricing tab for the exact cost shown to your account.

### How to use

1. Open the actor on Apify.
2. Add one or more shopping queries.
3. Choose a country code such as `US`, `GB`, `CA`, `AU`, or `DE`.
4. Choose a language code such as `en`, `es`, `de`, or `fr`.
5. Set `maxItems` to the number of products you want.
6. Optionally add `minPrice` or `maxPrice`.
7. Keep proxy enabled for best reliability.
8. Start the run.
9. Download the dataset as JSON, CSV, Excel, XML, or RSS.

### Input configuration

| Setting | JSON key | What it does |
| --- | --- | --- |
| Shopping queries | `queries` | Product names, category phrases, SKUs, model numbers, or comparison keywords such as `coffee maker`, `running shoes`, or `4k monitor`. |
| Maximum results | `maxItems` | Total saved product cards across all queries. If you enter 3 queries and set `maxItems` to 60, the run stops after 60 total records. |
| Country | `country` | Two-letter country code such as `US`, `GB`, `CA`, `AU`, or `DE`. Google Shopping availability and ranking vary by region. |
| Language | `language` | Google interface language for snippets, such as `en`, `es`, `de`, or `fr`. |
| Minimum price | `minPrice` | Optional post-extraction filter that keeps products at or above this numeric price. |
| Maximum price | `maxPrice` | Optional post-extraction filter that keeps products at or below this numeric price. |
| Proxy configuration | `proxyConfiguration` | Optional proxy settings. Google may return interstitial or rate-limit pages without a suitable proxy on larger runs. |

The Actor automatically matches Apify Proxy country routing to `country`. It rotates a proxy session after a classified block, challenge, timeout, or connection reset; ordinary HTTP 5xx retries remain on the same bounded route.

### Input example

```json
{
  "queries": ["coffee maker"],
  "country": "US",
  "language": "en",
  "maxItems": 20,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": ["GOOGLE_SERP"],
    "apifyProxyCountry": "US"
  }
}
```

### Tips for better results

- **Use specific product keywords:** model names and SKU-like phrases work better for merchant-level price comparison.
- **Use category keywords for landscape research:** broader phrases are useful when you want a market overview.
- **Start small:** test a few queries before scheduling larger recurring jobs.
- **Keep batches focused:** compare one region and product type at a time.
- **Use timestamps:** compare the same query over days or weeks.
- **Avoid vague one-word terms:** they often return mixed products that are harder to analyze.

### Common workflows

- **Price monitoring:** schedule the same query every day and compare `priceValue` by title and merchant.
- **Competitive research:** run category terms and review which brands and stores appear most often.
- **Assortment discovery:** search model names and collect alternative sellers or similar products.
- **Agency reporting:** export CSV files for client dashboards and shopping landscape reports.
- **Product launch research:** compare titles, ratings, review counts, and shipping offers for adjacent products.

### Integrations

- **Google Sheets:** review product cards manually or share quick reports.
- **BigQuery or Snowflake:** store long-term price intelligence and category snapshots.
- **Make or Zapier:** create no-code scheduled alerts.
- **Apify webhooks:** notify your app when a run finishes.
- **Apify API:** trigger runs from internal dashboards.
- **CSV exports:** support spreadsheet-based reporting.

### API usage

#### Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('fetch_cat/google-shopping-results-scraper').call({
  queries: ['coffee maker'],
  country: 'US',
  language: 'en',
  maxItems: 20
});
console.log(run.defaultDatasetId);
```

#### Python

```python
from apify_client import ApifyClient
import os

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('fetch_cat/google-shopping-results-scraper').call(run_input={
    'queries': ['coffee maker'],
    'country': 'US',
    'language': 'en',
    'maxItems': 20,
})
print(run['defaultDatasetId'])
```

#### cURL

```bash
curl -X POST 'https://api.apify.com/v2/acts/fetch_cat~google-shopping-results-scraper/runs?token=YOUR_APIFY_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"queries":["coffee maker"],"country":"US","language":"en","maxItems":20}'
```

### MCP and AI agents

You can connect this actor to AI tools through the official Apify MCP server.

Use the MCP server URL with the actor tool enabled:

```text
https://mcp.apify.com?tools=fetch_cat/google-shopping-results-scraper
```

Add it in Claude Code:

```bash
claude mcp add apify-google-shopping "https://mcp.apify.com?tools=fetch_cat/google-shopping-results-scraper"
```

Or configure an MCP client with JSON:

```json
{
  "mcpServers": {
    "apify-google-shopping": {
      "url": "https://mcp.apify.com?tools=fetch_cat/google-shopping-results-scraper"
    }
  }
}
```

The default Apify MCP server can search and run Actors. The focused URL exposes only this Actor to clients that support tool-scoped MCP connections.

Example prompts:

- "Search Google Shopping for coffee makers in the US and summarize price ranges."
- "Compare merchants for running shoes and list products with ratings above 4.5."
- "Find the first 20 Google Shopping results for wireless mouse and export titles and prices."

### Scheduling

Use Apify schedules for recurring price snapshots.

Daily runs are useful for fast-changing categories.

Weekly runs are often enough for market landscape reports.

Keep `maxItems` aligned with the number of products you actually review.

### Data quality notes

Google Shopping layouts and snippets can vary by country, language, query, and time.

Some cards may not expose every field.

`productUrl` and `imageUrl` can be `null` when Google renders those values through an interactive viewer instead of a direct visible link.

The actor saves fields only when they are visible or parseable from the result card.

### Troubleshooting

#### Why did my run return no results?

Check that the query has Google Shopping results in the selected country.

Try a lower `maxItems` value.

Keep proxy enabled.

If Google returns an interstitial, wait and retry with a smaller batch.

#### Why are some fields null?

Google does not show every field on every card.

For example, some results do not show ratings, reviews, shipping, images, or direct product links.

#### Why do prices differ by location?

Google Shopping ranking and merchant availability are localized.

Use the same `country` and `language` values when comparing repeated runs.

### Limits

This actor is intended for public Google Shopping result cards.

It does not log in to Google.

It does not open merchant checkout pages.

It does not scrape private account data.

It does not guarantee identical output for every locale because Google changes layouts frequently.

### Legality

This actor extracts publicly visible search-result information.

You are responsible for using the data lawfully and respecting applicable terms, privacy rules, and platform policies.

Do not use scraped data for prohibited, deceptive, or privacy-invasive purposes.

Consult legal counsel if your use case has regulatory requirements.

### Related actors

Explore related actors from `fetch_cat` for ecommerce, search, and product intelligence workflows:

- [Shopify Products Scraper](https://apify.com/fetch_cat/shopify-products-scraper)
- [AliExpress Products Scraper](https://apify.com/fetch_cat/aliexpress-products-scraper)
- [Walmart Products Scraper](https://apify.com/fetch_cat/walmart-products-scraper)
- [Google Search Results Scraper](https://apify.com/fetch_cat/google-search-results-scraper)
- [Bing Search Results Scraper](https://apify.com/fetch_cat/bing-search-results-scraper)
- [Website Contact Finder](https://apify.com/fetch_cat/website-contact-finder)

### FAQ

#### Can I scrape multiple keywords in one run?

Yes. Add multiple values to `queries` and set a total `maxItems` cap.

#### Can I target another country?

Yes. Set `country` to a two-letter code such as `GB`, `CA`, `AU`, or `DE`.

#### Can I filter by price?

Yes. Use `minPrice` and `maxPrice` to filter extracted results after the page is parsed.

#### Can I schedule monitoring?

Yes. Use Apify schedules and export each run's dataset for trend analysis.

#### Does it scrape product detail pages?

No. Version 0.1 focuses on result cards because they are the safest and fastest unit for search monitoring.

#### What happens if Google changes the page?

The actor includes defensive parsing and clear failure messages. If the layout changes significantly, rerun with a small query and report the issue.

### Support

If a run fails, returns no data, or a field looks wrong, open an issue from the Actor page.

Please include the Apify run ID or run URL, input JSON, one example public URL, query, or input item, what you expected, and what the dataset returned. Small reproducible inputs make parsing or site-layout issues much faster to fix.

### Privacy and data handling

This Actor only requests the permissions needed to run the input you provide. It uses your input (such as URLs, search terms, identifiers, filters, and limits) only to fetch the requested public data from the relevant source site or API for this Actor, then writes results to your Apify dataset/key-value store.

Data may pass through Apify platform services and Apify Proxy during the run, and requests are sent only to the target site or public data provider required for this Actor's results. FetchCat does not send your inputs or outputs to advertising networks, data brokers, or model-training services, and does not retain run data outside Apify storage after the run except when you explicitly share run details for transient support debugging.

You are responsible for using this Actor lawfully, respecting the target site's terms, and avoiding unnecessary personal or sensitive data in inputs. Review the output before storing, sharing, or combining it with other data.

# Actor input Schema

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

Google Shopping keywords to search. Use product names, SKUs, categories, or comparison terms.

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

Total number of Google Shopping product results to save across all queries.

## `country` (type: `string`):

Two-letter Google Shopping country/region code, for example US, GB, CA, AU, or DE.

## `language` (type: `string`):

Google interface language code, for example en, es, de, fr, or it.

## `minPrice` (type: `number`):

Optional numeric lower price filter applied after extraction.

## `maxPrice` (type: `number`):

Optional numeric upper price filter applied after extraction.

## `proxyConfiguration` (type: `object`):

Google blocks most direct traffic. The default uses Apify's GOOGLE\_SERP proxy group and automatically matches its country to the Shopping country input.

## Actor input object example

```json
{
  "queries": [
    "coffee maker"
  ],
  "maxItems": 20,
  "country": "US",
  "language": "en",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "GOOGLE_SERP"
    ],
    "apifyProxyCountry": "US"
  }
}
```

# Actor output Schema

## `overview` (type: `string`):

No description

## `runSummary` (type: `string`):

No description

## `pendingQueries` (type: `string`):

No description

# 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": [
        "coffee maker"
    ],
    "country": "US",
    "language": "en",
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "GOOGLE_SERP"
        ],
        "apifyProxyCountry": "US"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("fetch_cat/google-shopping-results-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": ["coffee maker"],
    "country": "US",
    "language": "en",
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["GOOGLE_SERP"],
        "apifyProxyCountry": "US",
    },
}

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

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).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": [
    "coffee maker"
  ],
  "country": "US",
  "language": "en",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "GOOGLE_SERP"
    ],
    "apifyProxyCountry": "US"
  }
}' |
apify call fetch_cat/google-shopping-results-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=fetch_cat/google-shopping-results-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/acts/sPsvlLsaVlJacKsww/builds/G0BlJWLlsXBEX6LfU/openapi.json