# Google Shopping Scraper: Prices, Stores and Ratings (`dtkfoundry/google-shopping`) Actor

Google Shopping scraper for product prices and price comparison in any country: price, sale and usual price, store, rating, reviews, delivery and returns, with Google's product ids. Up to 300 products per search. Pay per product.

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

## Pricing

from $1.00 / 1,000 products

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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: Prices, Stores and Ratings

Product prices from Google Shopping for any search, in 14 countries: price, sale price ("Was"), Google's usual
price ("Usually", with its "Low price" badge), discount, store, whether more stores sell it, delivery and
returns terms, rating, review count, and Google's product, catalog and offer IDs. Search the way you would on
Google Shopping: "coffee maker", "running shoes women".

- **The country you asked for.** Google localizes Shopping by the visitor's location, so the actor pins every
  search to your country and rejects any page that comes back in another country's currency (it retries
  through a fresh connection). Prices are always in that country's currency.
- **Up to 300 products per search.** Google shows about 60 products per search. Ask for more and the actor also
  runs Google's own price-range searches for your query ("Under $50", "$50 - $100" ...) and merges the unique
  products. Every product says which search found it.
- **Reliable.** Tested on Apify across the US, UK, Germany, Canada and Australia: 75 of 75 searches answered
  with 4,320 products, and a field audit of live US, UK and German results checked every record (2 of 489
  had no store, because Google's own listing names none).
- **Pay per product: $0.001.** Searches that fail or find nothing are never charged, and a product found by two
  searches is delivered and charged once.

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `queries` | array | `[]` | One product search per line. Empty = a free format example. |
| `country` | string | `us` | `us`, `gb`, `ca`, `au`, `ie`, `de`, `fr`, `es`, `it`, `nl`, `in`, `jp`, `br`, `mx`. |
| `maxProductsPerQuery` | integer | `60` | 1-300. Above ~60, Google's price-range searches are added. |
| `includeThumbnails` | boolean | `false` | Google's small product image as an inline `data:` URI (a few KB each). |

```json
{
    "queries": ["coffee maker", "running shoes women"],
    "country": "us",
    "maxProductsPerQuery": 120
}
```

### Output (one record per product)

A real record from a run on 2026-10-21 (US, "dog bed"):

```json
{
    "status": "ok",
    "query": "dog bed",
    "country": "us",
    "rank": 1,
    "matchedSearch": "dog bed",
    "title": "Premium Orthopedic Memory Foam Dog Bed Washable Water-Resistant Cover",
    "price": 142,
    "priceText": "$142.00",
    "priceIsFrom": false,
    "currency": "$",
    "originalPrice": 199,
    "originalPriceText": "$199",
    "usualPrice": null,
    "usualPriceText": null,
    "discount": "28% OFF",
    "store": "Dog Friendly Co",
    "multipleStores": true,
    "condition": "new",
    "delivery": "Free delivery",
    "returns": "60-day returns",
    "rating": 4.2,
    "reviewsCount": 158,
    "foreignPriceText": null,
    "tags": [],
    "productId": "1536341855018882428",
    "catalogId": "787790632844172304",
    "offerId": "11203800988645934347",
    "groupId": "8521707887380974439"
}
```

- `price` is the current price as a number, `priceText` exactly as Google shows it, `currency` its symbol.
- `originalPrice` is a sale's "Was" price; `usualPrice` is Google's "Usually" price for products it marks as a
  low price (then `tags` holds "Low price").
- `store` is the store Google shows first; `multipleStores: true` means Google lists more stores ("& more").
  When many stores sell a product "from" a price (`priceText` like `$76+`, `priceIsFrom: true`), Google names no
  single store and `store` is empty.
- `condition` is `new`, `used` or `refurbished` (Google's "Pre-owned" / "Refurbished" badges).
- `foreignPriceText` is the store's own-currency price when Google converted it ("Foreign price: £67").
- `productId`, `catalogId` and `offerId` are Google's own ids (an offer id is missing for some catalog products).
- A search with no products gives one record with `status: "no-results"`; a search that could not be completed
  gives `status: "failed"` and an `error`. Neither is charged.

### Pricing

Pay per event, no subscription.

| Event | Price | When it is charged |
|---|---|---|
| Product | **$0.001** | Once per unique product delivered. 60 products = $0.06. |

Set a maximum charge in the run options and the actor stops before it would go over. Apify's standard
run-start event adds $0.00005 per run.

### Limits, stated plainly

- No link to the store's page: on Google Shopping a product opens Google's own product viewer, which is not a
  link. Use the title, store and Google's ids to find it.
- Prices, stores and delivery terms are what Google Shopping shows for your country; they change often and can
  differ from a store's final checkout price. Local "nearby" stock is left out (it would reflect where Google
  thought the request came from, not you).
- English interface only (`hl=en`), so labels like "Free delivery" are in English in every country.
- Public data only: no login, no personal data.

### Privacy

Only your search terms are sent to Google. Results are stored only in your run's dataset. The actor runs with
limited permissions and reads nothing else in your account.

# Actor input Schema

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

One per line, the way you would search Google Shopping: "coffee maker", "running shoes women", "iphone 17 case". Leave empty for a free format example.

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

Whose Google Shopping to search; prices come in that country's currency.

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

Up to 300. Google shows about 60 products per search; for more, the actor also runs Google's own price-range searches for your query ("Under $50", "$50 - $100" ...) and merges the unique products. Each product is one charged result.

## `includeThumbnails` (type: `boolean`):

Google's small product image, as an inline data: URI (a few KB per product). Off by default for smaller datasets.

## Actor input object example

```json
{
  "queries": [
    "coffee maker",
    "running shoes women"
  ],
  "country": "us",
  "maxProductsPerQuery": 60,
  "includeThumbnails": false
}
```

# Actor output Schema

## `results` (type: `string`):

Every product with price, store, rating, reviews and Google's product ids.

## `resultsCsv` (type: `string`):

The same products as CSV.

# 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",
        "running shoes women"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("dtkfoundry/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": [
        "coffee maker",
        "running shoes women",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("dtkfoundry/google-shopping").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": [
    "coffee maker",
    "running shoes women"
  ]
}' |
apify call dtkfoundry/google-shopping --silent --output-dataset

```

## MCP server setup

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

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/aGGUxfZyemsRy9dDf/builds/J6HztF5C28gvieWAP/openapi.json