# Google Shopping Scraper (`devcake/google-shopping`) Actor

Google Shopping and Google Lens scraper for price comparison, competitor research and product discovery across 49 countries.

- **URL**: https://apify.com/devcake/google-shopping.md
- **Developed by:** [devcake](https://apify.com/devcake) (community)
- **Categories:** E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 results

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 Product & Price Scraper

Extract Google Shopping product data, prices, sellers, ratings, delivery details, and images. Search by keyword or product photo and turn shopping results into an easy-to-use list.

***

### What this Google Shopping scraper does

The **Google Shopping Scraper** helps you collect product listings without copying results by hand.

Use it to:

- 🔎 Search for one or many products by keyword
- 📷 Upload a product photo or use public image links
- 🖼️ Find product listings related to an image
- 🌍 Choose a country and language for your search
- 💱 Optionally convert prices to another currency
- 📦 Collect up to 1,000 unique products for each search
- 🔀 Keep keyword and image searches together in one job

There is no Google sign-in required. Add your searches, start the tool, and receive a clean product list ready to review or download.

***

### Who it's for

- 🛒 **Online sellers** — research products, prices, and competing stores
- 🏬 **Retail teams** — compare product listings and watch market prices
- 🏷️ **Brands** — check how products appear across Google Shopping
- 📊 **Market researchers** — gather product, seller, rating, and delivery information
- 🤝 **Buying teams** — discover sellers and compare available offers
- 💼 **Agencies** — prepare shopping research for clients in different countries

***

### What data you get

| Information | What it tells you |
|---|---|
| Product name | The title shown in Google Shopping |
| Current price | The displayed selling price |
| Converted price | Optional target-currency price and exchange rate |
| Original price | The earlier price when a reduction is shown |
| Foreign price | A separately labelled comparison price in another currency |
| Discount | The displayed saving or discount |
| Seller | The store offering the product |
| Delivery | Available delivery information |
| Returns | Available return information |
| Rating | The product's displayed star rating |
| Review count | The displayed number of reviews |
| Product image | A public HTTP(S) thumbnail URL |
| Result position | Where the product appeared in the results |
| Search used | The keyword or image that produced the result |
| Identified product | The words found from a product photo when available |
| Source link | The Google Shopping results page |
| Locale diagnostics | Requested country/language, expected and observed currency, market verification, and network route |

Some details only appear when Google includes them in the listing. For example,
`original_price`, `discount`, `delivery`, `returns`, `rating`, and
`review_count` can legitimately be empty. A missing optional field does not mean
the parser failed.

***

### Popular ways to use it

#### Scrape Google Shopping results

Run a single keyword, get a clean dataset. Title, price, seller, rating, image URL, and a stable Google product ID per row. Repeat for any number of queries in one run.

#### Track prices on Google Shopping

Run the same keyword on a schedule. The Actor deduplicates products within each
search and returns stable Google product IDs where available. Use those IDs to
join separate run datasets into your own price history.

#### Google Shopping price scraper

Build a daily competitor snapshot. Capture price, original price, and discount per row so you can spot price moves and promotions without opening every listing.

#### Google Shopping product data export

Pull structured product data into a CSV or JSON feed. Each row carries the seller name, rating, review count, image URL, and the Google product ID needed for downstream joins.

#### Search products by image

Upload a product photo or pass a public image URL. The Actor extracts a useful query from the picture and runs it through Google Shopping, so a single image turns into a structured product list.

#### Google product search by image

Useful for reverse lookup, brand research, and competitor matching. The Actor preserves the original image source in `query` and the recognized product query in `identifiedQuery`.

#### Competitor price monitoring software

Track rival SKUs across stores and countries. Repeated runs against the same keywords produce the data you need for price-matching and competitive alerts.

#### Automated competitor price monitoring

Schedule runs from the Actor's UI or your own scheduler. Capture Google Shopping prices on a cadence and export a clean competitor table.

#### Retail competitor price monitoring

Switch the country code and language to capture localised Shopping results. Compare identical keywords across markets to see how each retailer positions the same product.

#### Google Shopping seller research

See which stores appear for important product searches and how branded items are presented in Google Shopping. Capture merchant names, ratings, and review counts by keyword.

#### Google Shopping product research

Explore products before adding them to your catalog. Review prices, ratings, sellers, discounts, delivery details, and product images in one place.

#### Google Shopping country comparison

Run the same query under different country codes. Compare listings, prices, and currencies across markets without manually switching locales.

#### Google Shopping multiple countries

Run the same input separately for each country code to gather regional catalogues
and currencies, then combine the datasets for comparison.

#### Google Shopping API alternative

Read public result pages through Apify's Google SERP route, with a
country-targeted residential fallback when needed. No Google sign-in or CAPTCHA
bypass is used.

#### Google Shopping scraper API

Use the dataset's stable Google product IDs as your internal keys. Output JSON rows that drop straight into a PIM or catalog.

#### Best competitor price tracking tool

Bounded reads, transparent failures, and a clean competitor table. Repeated runs surface price moves and discount campaigns across stores.

***

### Search options

| Option | Required? | What to enter |
|---|---:|---|
| **Search queries** (`queries`) | No\* | One or more product searches, such as `wireless headphones` |
| **Country** (`country`) | No | The Google Shopping market you want; United States is selected by default. The scraper uses the matching Google country domain and proxy location, then checks the result currency. |
| **Language** (`language`) | No | The Google interface and search language; English is selected by default. Merchant titles are not translated. |
| **Max results** (`maxResults`) | No | Products to collect for each search, from 1 to 1,000; default is 40 |
| **Convert prices to** (`targetCurrency`) | No | Target ISO currency for converted prices. Select **Do not convert** to keep conversion disabled. The original price is always retained. |
| **Upload image** (`image`) | No\* | One PNG, JPG, GIF, or WebP product photo, or a public image link |
| **Image URLs** (`imageUrls`) | No\* | Up to 50 public JPEG, PNG, GIF, or WebP links; each download is limited to 10 MB and searched automatically with Google Lens |

\*Add at least one keyword or image.

Image searches always use Google Lens Products. No mode selection is required.
If Lens cannot identify a usable product query, that image is reported as a
failure instead of running an unrelated generic search.

***

### Quick start

1. **Add your search** — enter product keywords, upload a photo, add image links, or combine them.
2. **Choose your market** — select the country, language, number of products, and optional conversion currency.
3. **Start the tool** — wait while it collects the available Google Shopping listings.
4. **Use your results** — review the product table or download it for further work.

> **Easy first search:** Try `wireless headphones` with a limit of 40 results.

***

### Simple example

#### Search settings

```json
{
  "queries": ["wireless headphones"],
  "country": "US",
  "language": "en",
  "maxResults": 40,
  "targetCurrency": "EUR"
}
```

#### Example result

```json
{
  "position": 1,
  "title": "Wireless Bluetooth Headphones",
  "price": "$39.99",
  "converted_price": "EUR 35.10",
  "exchange_rate": 0.87778,
  "original_price": null,
  "foreign_price": null,
  "seller": "Example Store",
  "image_url": "https://encrypted-tbn0.gstatic.com/shopping?q=tbn:example",
  "rating": "4.6",
  "review_count": "1,248",
  "delivery": "Free delivery",
  "query": "wireless headphones",
  "searchMode": "text",
  "country": "US",
  "language": "en",
  "google_domain": "google.com",
  "expected_currency": "USD",
  "observed_currency": "DOLLAR",
  "market_match": true,
  "route": "serp"
}
```

***

### Why use this Google Shopping data extractor

- ⏱️ **Save time** — collect many shopping listings in one go
- ⚖️ **Compare more easily** — place prices, sellers, ratings, and delivery details side by side
- 🔍 **Search your way** — use keywords, product photos, or both
- 🌍 **Research different markets** — choose the country and language that matter to you
- 🎯 **Stay focused** — set a clear result limit for every search
- 🧹 **Work with clean results** — receive one organized row for each product found

Google Shopping pages can change, and some searches may occasionally show a verification page instead of products. When that happens, the tool stops safely rather than returning misleading results.

When Google embeds a card thumbnail directly in the HTML instead of exposing a
remote URL, the Actor validates the image, stores one deduplicated copy in the
run key-value store, and returns its public HTTP URL in `image_url`.

The same fail-safe applies to localization. If the dominant returned currency
conflicts with the requested country, the scraper retries through the
country-targeted residential route. If the mismatch remains, the run fails
instead of publishing products from the wrong market.

Runs use bounded automatic concurrency: up to four searches globally, with a
two-search limit for the heavier Lens path. Dataset writes are queued separately
so storage latency does not occupy a scrape slot. The `SUMMARY` record includes
request, retry, byte, queue-wait, scrape, dataset-write, and total-duration
diagnostics.

When `targetCurrency` is selected, the Actor fetches one exchange rate for the
entire run and uses decimal arithmetic with target-currency rounding. It
prefers the open-source [Frankfurter API](https://frankfurter.dev/), whose
reference rates are sourced from central banks, and falls back to the
open-source [Fawaz currency API](https://github.com/fawazahmed0/exchange-api).
The original `price` is never overwritten. Converted rows expose
only `converted_price` and `exchange_rate`; provider and rate-date details stay
internal. The `SUMMARY` record reports the exchange rate and converted-row
count.

***

### Frequently asked questions

#### How do I track prices on Google Shopping?

Run the same keyword repeatedly. Each run has its own dataset; use the stable
Google product IDs to join rows and deduplicate them in your time-series store.

#### How to search a product by image on Google?

Upload the photo as `image` or pass a public URL in `imageUrls`. The Actor automatically searches it with Google Lens and returns the related product cards.

#### Can Google find a product from an image?

Often. Google Lens can identify brands and product names from a clear photo.
This Actor returns structured product rows alongside the recognized query; it
reports an image-level failure when Lens cannot produce a usable query.

#### Is there a Google Shopping API?

The official Content API for Shopping requires a Merchant Center account and a quota. This Actor is an alternative that reads public result pages anonymously, so you can start small and scale without Merchant Center access.

#### Why can some product titles still be in another language?

The language option controls Google's interface and search context. Product
titles are supplied by merchants, so Google may include a foreign-language title
when it considers the offer relevant. Check `market_match`,
`expected_currency`, and `observed_currency` to confirm that the requested market
was actually served. `DOLLAR` means Google displayed an ambiguous `$` symbol
that is compatible with the selected dollar-denominated market.

#### How does currency conversion work?

Choose a value in **Convert prices to**. The Actor parses the localized current
price, resolves ambiguous symbols such as `$` from the selected country, and
multiplies it by one dated reference rate shared by the run. It does not convert
the separately labelled `foreign_price`, and it does not replace Google's
original `price`. If no trustworthy rate can be obtained, the run stops instead
of publishing guessed converted values.

#### Why are some output fields empty?

Google does not show every attribute on every Shopping card. Original price and
discount only exist for promotions; delivery, returns, ratings, and reviews also
depend on the merchant and listing. The scraper leaves unavailable values empty
instead of guessing them.

# Actor input Schema

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

Enter one or more product searches. Each query is scraped separately. Optional when image inputs are provided.

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

Select the Google Shopping market. Requests use that country's Google domain and proxy location, and returned prices are checked against its expected currency.

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

Select the Google interface and search language. Merchant-provided product titles are returned as published and are not translated.

## `maxResults` (type: `integer`):

Stop after this many unique products per query. Keep low for testing.

## `targetCurrency` (type: `string`):

Optionally convert each current price from the selected country's currency. The original Google price is always preserved.

## `image` (type: `string`):

Upload one PNG, JPG, GIF, or WebP product image. A public URL is also accepted.

## `imageUrls` (type: `array`):

Public JPEG, PNG, GIF, or WebP image URLs to process. Each download is limited to 10 MB.

## Actor input object example

```json
{
  "queries": [
    "wireless headphones"
  ],
  "country": "US",
  "language": "en",
  "maxResults": 40,
  "targetCurrency": "NONE"
}
```

# Actor output Schema

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

No description

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

No description

## `summary` (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": [
        "wireless headphones"
    ],
    "maxResults": 40
};

// Run the Actor and wait for it to finish
const run = await client.actor("devcake/google-shopping").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": ["wireless headphones"],
    "maxResults": 40,
}

# Run the Actor and wait for it to finish
run = client.actor("devcake/google-shopping").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": [
    "wireless headphones"
  ],
  "maxResults": 40
}' |
apify call devcake/google-shopping --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/acts/08OSwkxadzhARSh0B/builds/SxnUKty6dM0Bj1XOG/openapi.json