# Google Shopping Scraper — Prices, Sellers & History (`anuarbakty/google-shopping-scraper`) Actor

Google Shopping scraper and price tracker: search by keyword or product link for prices, stores, ratings, delivery and photos. Product pages add every store with a direct link, each store's price history and the typical price for price comparison. Alerts when prices drop.

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

## Pricing

from $1.60 / 1,000 product from a searches

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** is a Google Shopping scraper, price comparison tool and price tracker in one. It reads Google Shopping and gives every product as a clean row: **price as a number with its currency, store, delivery, returns, rating, picture**, and Google's catalog and offer IDs. Search by keyword, or open products by link or catalog ID. Turn on product pages to get **every store Google lists for the product with a direct link to the store's own page, the price history of each store, the typical price range, all photos, specifications and variants**. Track prices between runs and get an **alert when a price drops**.

No login, no proxy settings, no API key of any other service: the Actor reads Google Shopping itself through Apify's Google SERP proxy.

### What does Google Shopping Scraper do?

- **Searches Google Shopping** by keyword in any country and language, as far as Google goes: one query gave 300 different products, page after page and across sort orders.
- **Filters like Google does**: price range, minimum rating, new or used, on sale, free delivery, chosen stores; sort by relevance, price or rating; search from a city or ZIP code.
- **Opens product pages** (optional): every store Google lists on the page with price, old price, condition, stock, delivery, returns and the **direct link to the store's product page**; photos, specifications, variants, Google's "Top insights" from reviews, forum discussions and other listings.
- **Gives the price history**: for every store on the product page, the days its price changed, with its lowest and highest price and their dates, up to 12 months back; plus Google's typical price range and the 12-month low and high.
- **Watches prices**: on a schedule, every row is marked new, price_down, price_up or unchanged with the previous price; "only new or changed" skips the rest for free; an alert goes to Slack, Discord, Telegram or any webhook when prices drop or reach your threshold.
- **Summarizes each search** in a free row: lowest, median and highest price, number of stores, top stores, products on sale.

### Why use this Google Shopping scraper?

| What goes wrong elsewhere | What happens here |
|---|---|
| Missing links, pictures and IDs | Every product has its Google product link, catalog and offer IDs, and a picture; Google gives many pictures only inside the page, and the Actor saves them and links them. With product pages, every store has its direct link |
| Price as text only | Price, old price and discount as numbers, with the ISO currency, in every country's number format |
| "Returns 0 results" with no reason | Every input that gives nothing produces a free row with the reason |
| Price history only for some products | The price history of every store Google lists on the product page, day by day, condensed to the days the price changed |
| You pay for products your filters drop | Products outside your filters and unchanged products in "only new or changed" mode are skipped and not charged |
| An automation built for another Google Shopping scraper has to be rebuilt | Inputs of other Google Shopping Actors run unchanged: 51 example inputs, prefills and public tasks of other Actors run here as they are |

### What Google Shopping data can you extract?

| Data | Fields |
|---|---|
| Product from search | Title, price, currency, old price, discount, on sale, monthly payment, condition, store, more stores, delivery, free delivery, returns, rating, reviews, picture, Google product link, position, page |
| IDs | Catalog ID, product group ID, offer ID, product and image document IDs |
| Product page | All photos, specifications, variants (color, size), every store Google lists, lowest price and its store, typical price range, 12-month low and high |
| Each store on the product page | Price, old price, discount, condition, stock, delivery, returns, offer title, **direct store link**, merchant ID, price history (changes, lowest, highest, dates) |
| Reviews and talk | "Top insights" topics with pros, cons and review sources; forum and Reddit discussions with site, age and comment count |
| Price tracking | Change (new, price_down, price_up, unchanged), previous price, change in percent, at or below your alert price |
| Search summary | Products saved and shown, products skipped by filters, lowest, median and highest price, stores, top stores, average rating |

### What can you use Google Shopping data for?

- **Price monitoring and MAP checks**: track your products and your competitors' across stores, with the direct link to each store's page and an alert when a price drops.
- **Competitor research**: who sells what, at what price, with what delivery and returns, and who holds the top positions for your keywords.
- **Product and catalog enrichment**: photos, specifications, variants and Google catalog IDs for your product feed.
- **Market and assortment analysis**: price ranges per category, number of sellers, discounts, ratings, in any country.
- **Deal finding**: products below a price, on sale or with free delivery, from a city's point of view.
- **AI agents**: fast mode answers within about 30 seconds with short rows; measured: 2 queries, 40 products in 25 seconds through the Apify MCP server.

### How to scrape Google Shopping

1. Open the Actor and type your search queries, for example `wireless earbuds`, or paste Google Shopping links, product links or catalog IDs.
2. Choose the country and, if you like, filters, sort order and how many products per query.
3. Turn on **Open each product page** to get every store with its direct link, the price history, photos and specifications.
4. Click **Start**. Download the results as JSON, CSV, Excel or HTML, or read them through the API.

For price tracking, save the input as a task with **Compare prices with the last run** on and run it on a schedule.

### How much does it cost to scrape Google Shopping?

Pay only for products you get. No subscription, a start fee of $0.00005 per run, and free summary and error rows.

| Event | Free and Bronze plans | Silver | Gold and above |
|---|---|---|---|
| Product from a search | $2.00 per 1,000 | $1.80 per 1,000 | $1.60 per 1,000 |
| Product with its product page (stores, store links, price history, photos, specs) | $6.00 per 1,000 | $5.40 per 1,000 | $4.80 per 1,000 |

Examples on the Free plan: 1,000 products from 25 searches cost $2. 200 products with their product pages cost $1.20. The $5 of monthly credit on Apify's free plan covers about 2,500 products from searches, or about 830 products with their product pages. Products your filters drop and unchanged products in "only new or changed" mode are not charged. Set a maximum cost per run in Apify and the Actor stops exactly there.

### Input

| Field | What it does |
|---|---|
| `queries` | Search queries, or Google Shopping search links (their own query, country and filters are kept) |
| `productUrls` | Google Shopping product links or catalog IDs |
| `maxProductsPerQuery` | Products per query, up to 1,000 (default 40, about one results page) |
| `maxItems` | Maximum paid rows in the run |
| `country`, `language`, `location` | Country code (us, gb, de…), language code, and a city, region or ZIP code |
| `sortOrder` | relevance, price_low, price_high, rating |
| `minPrice`, `maxPrice`, `minRating`, `condition`, `onSale`, `freeShipping`, `stores` | Filters |
| `productDetails` | Open each product page: stores with links, price history, photos, specs |
| `deepSearch` | When one search has fewer products than you asked for, also read it sorted by price and rating (on by default) |
| `trackPriceChanges`, `onlyNewOrChanged`, `monitorName`, `minPriceChangePercent` | Price tracking between runs |
| `alertWebhookUrl`, `alertPriceBelow`, `alertOnPriceDrop` | Alerts to Slack, Discord, Telegram or any webhook |
| `fastMode` | First page of each query, no product pages, short rows: for AI agents |
| `label` | Your own text in every row |

Example:

```json
{
    "queries": ["wireless earbuds", "standing desk"],
    "country": "us",
    "maxProductsPerQuery": 100,
    "maxPrice": 300,
    "freeShipping": true,
    "productDetails": true
}
```

#### Coming from another Google Shopping scraper?

Paste your old input. `query`, `q`, `searchQuery`, `keywords`, `gl`, `hl`, `google_domain`, `num`, `max_pages`, `maxResults`, `sortBy`, `sort_by`, `min_price`, `max_price`, `on_sale`, `free_shipping`, `productCondition`, `startUrls`, `fetchProductDetails`, `includeOffers`, `changedOnly`, `trackingListName` and more are read as the fields above.

### Output

One row per product. Example of a product from a search with its product page (shortened):

```json
{
    "type": "product",
    "source": "search",
    "query": "wireless earbuds",
    "position": 1,
    "title": "Example Wireless Earbuds with Charging Case",
    "price": 26.99,
    "currency": "USD",
    "oldPrice": 39.99,
    "discountPercent": 32,
    "merchant": "Example Audio",
    "delivery": "Free delivery by Nov 30",
    "returns": "30-day returns",
    "rating": 4.6,
    "reviewCount": 1400,
    "imageUrl": "https://encrypted-tbn3.gstatic.com/shopping?q=tbn:…",
    "productUrl": "https://www.google.com/search?ibp=oshop&q=wireless+earbuds&prds=catalogid:…",
    "catalogId": "429581964839730176",
    "offerId": "6386642608748888891",
    "sellerCount": 4,
    "bestPrice": 26.99,
    "bestPriceMerchant": "Example Audio",
    "bestTotalPrice": 26.99,
    "storeUrl": "https://www.example-audio.com/products/earbuds",
    "typicalPriceLow": 33.99,
    "typicalPriceHigh": 39.99,
    "lowestPrice12m": 31.99,
    "sellers": [
        {
            "merchant": "Best Buy",
            "price": 33.99,
            "oldPrice": 39.99,
            "availability": "In stock online",
            "delivery": "Free delivery by Mon on orders $35+",
            "deliveryCost": 0,
            "totalPrice": 33.99,
            "returns": "15-day returns",
            "storeUrl": "https://www.bestbuy.com/product/…",
            "priceHistory": {
                "from": "2025-11-18", "to": "2026-11-19",
                "lowest": 19.99, "lowestDate": "2025-11-30",
                "highest": 39.99, "highestDate": "2025-11-18",
                "changes": [{ "date": "2025-11-18", "price": 39.99 }, { "date": "2025-11-27", "price": 19.99 }]
            }
        }
    ],
    "specs": { "Bluetooth": "5.3", "Weight": "28.5 g (case)" },
    "country": "us",
    "scrapedAt": "2026-11-19T10:00:00.000Z"
}
```

#### Summary rows

With **Summary row per query** on (the default), each search adds one free row: products saved, products Google showed, products skipped by your filters, pages read, lowest, median and highest price, number of stores, the top stores, products on sale and the average rating.

#### Rows for inputs that gave nothing

A query or link that gives no product produces a free row with a code (NO_RESULTS, NO_MATCHING_PRODUCTS, NOTHING_CHANGED, PRODUCT_NOT_FOUND, FETCH_FAILED, TIME_LIMIT) and the reason in plain words. The run succeeds, so an automation keeps going; turn on **Fail the run when every input gives an error** to change that.

The key-value store has a **SUMMARY** record: products by kind, Google requests, how many saved products miss each main field, and per query how many products Google showed and how many were saved.

### Google Shopping price tracker: alerts when prices drop

#### How to track prices on Google Shopping

1. Save your input as a task with **Compare prices with the last run** on and a **Price memory name**.
2. Add an **Alert webhook**: a Slack or Discord webhook, a Telegram bot address with `chat_id`, or any https address (Make, n8n, Zapier).
3. Optionally set **Alert when the price is at or below**.
4. Schedule the task. Each run marks every product as new, price_down, price_up or unchanged and sends one message with the drops and the products at or below your price.

Turn on **Only new or changed products** to save and pay only for what changed.

To follow exactly the same products run after run, put their product links or catalog IDs in **Product links or catalog IDs**: each run reads those product pages and compares the best price with the last run. A search query follows whatever Google shows for it that day.

### Google Shopping price comparison and price history

Turn on **Open each product page**, or paste product links, and every product row carries the stores Google lists for it on its product page:

- each store's price, old price, condition, stock, delivery and returns, with the **direct link to the store's own product page**;
- the lowest price and its store (`bestPrice`, `bestPriceMerchant`, `bestPriceStoreUrl`), and the cheapest offer with delivery added (`bestTotalPrice`, `bestTotalPriceMerchant`), from each store's delivery cost;
- Google's typical price range and the 12-month low and high;
- the price history of every store: the days its price changed, with its lowest and highest price and their dates; `from` and `to` show how far back Google keeps it for that store, up to 12 months;
- other products Google suggests under "More options" (`moreOptions`): other variants, bundles and similar listings.

Product pages take about 30 seconds per 10 products at the default memory, and rows appear in the dataset one by one as their pages are read.

A test run read 40 product pages for "electric toothbrush" in the US and gave a direct store link for all 40.

### Is it legal to scrape Google Shopping?

The Actor reads public Google Shopping pages that anyone can open without an account. It collects product and store information, not personal data. Check that your use of the data fits the laws of your country and the terms of the sites involved; if you are not sure, ask a lawyer.

### Integrations and API

Run the Actor and get its results through the [Apify API](https://docs.apify.com/api/v2), the Apify clients for JavaScript and Python, or the CLI. Connect it to Make, Zapier, n8n, Google Sheets, Slack, Airbyte and more with Apify integrations, or start it from a webhook.

```bash
curl -X POST "https://api.apify.com/v2/acts/anuarbakty~google-shopping-scraper/run-sync-get-dataset-items?token=<YOUR_TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{"queries": ["wireless earbuds"], "maxProductsPerQuery": 20}'
```

#### Use it from AI agents (MCP)

The Actor works as a tool of the Apify MCP server in Claude, ChatGPT, Cursor and other agents. Add it with this address:

`https://mcp.apify.com/?tools=anuarbakty/google-shopping-scraper`

An agent's call can be as short as this:

```json
{ "queries": ["standing desk", "office chair"], "country": "us", "fastMode": true }
```

That call returns 40 products (20 per query) and costs $0.08 on the Free plan: $2 per 1,000 products from searches, $6 per 1,000 with product pages. Input mistakes come back as a free row that says what to fix. With **Fast mode** on, it answers within about 30 seconds with short rows: title, price, currency, store, delivery, rating, links and IDs; filters and sort order still apply. Every query gets a row: a query Google did not answer in time gets a free TIME_LIMIT row, so the agent knows to ask again.

https://www.youtube.com/watch?v=1i-dKo-0puk

### More from this developer

- [Google Ads Library Scraper](https://apify.com/anuarbakty/google-ads-library-scraper): ads of any brand or website from the Google Ads Transparency Center.
- [Facebook Ads Library Scraper](https://apify.com/anuarbakty/facebook-ads-library-scraper): Facebook and Instagram ads from the Meta Ad Library.
- [Pinterest Search Scraper](https://apify.com/anuarbakty/pinterest-search-scraper): pins, boards and trends.
- [App Store & Google Play Reviews Scraper](https://apify.com/anuarbakty/app-store-play-scraper): app reviews and ratings.
- [Threads Scraper](https://apify.com/anuarbakty/threads-scraper): posts, profiles, replies and search.
- [YouTube Transcript Scraper](https://apify.com/anuarbakty/youtube-transcript-scraper): subtitles and captions.
- [Instagram Transcript Generator](https://apify.com/anuarbakty/instagram-reels-transcript-generator): Reels to text.
- [2GIS Places Scraper](https://apify.com/anuarbakty/2gis-places-scraper) and [2GIS Reviews Scraper](https://apify.com/anuarbakty/2gis-reviews-scraper): companies and reviews from 2GIS.

### FAQ

**Does it need a Google account, cookies or my own proxy?**
No. The Actor reads public pages through Apify's Google SERP proxy, which is included in the price.

**How many products can I get for one query?**
Up to 1,000 per query. One results page holds about 40 products; the Actor reads the next pages and, when needed, the same search sorted by price and rating. How many Google has depends on the query.

**Why are some fields empty?**
Google does not show every field for every product: some have no rating, some no delivery line. The free summary row and the SUMMARY record say how many products miss each main field.

**Can I get the link to the store itself?**
Yes, with **Open each product page**: every store Google lists on the product page comes with a direct link to its own product page, and `storeUrl` holds the link of the row's offer.

**Which countries work?**
Any country Google Shopping serves: give its two-letter code. Prices come as numbers in that country's currency, read from its own number format.

**Is there a Google Shopping API?**
Google has no public API for Google Shopping results: its Merchant API covers only the products of your own store. This Actor works as a Google Shopping API: one HTTP call to the Apify API with your queries returns the products as JSON, and the Apify clients for Python and JavaScript do the same in a few lines.

**How do I use it from Python?**
Install `apify-client`, then:

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_TOKEN>")
run = client.actor("anuarbakty/google-shopping-scraper").call(run_input={"queries": ["air purifier"], "maxProductsPerQuery": 40})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item.get("title"), item.get("price"), item.get("currency"), item.get("merchant"))
```

**How fast is it?**
Measured in the Apify cloud: 40 products for one query in 11 seconds, 225 products for three queries in 46 seconds, 1,000 products in under 5 minutes on the smallest memory (256 MB). With product pages: 10 products in about 30 seconds, 40 in about 2.5 minutes.

**Can I compare prices of one product across stores?**
Yes. Paste the product's Google Shopping link or catalog ID, or turn on **Open each product page** for a search. The row lists every store Google shows for the product with its price, delivery, returns and a direct link, plus the lowest price and its store.

**How do I get only products under a price, on sale or with free delivery?**
Set **Maximum price**, turn on **On sale only** or **Free delivery only**, and choose the sort order. Products outside your filters are skipped and not charged.

# Actor input Schema

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

What to search for on Google Shopping, one query per line, for example "wireless earbuds" or "standing desk". A Google Shopping search link works too: its own query, country and filters are used.

## `productUrls` (type: `array`):

Google Shopping product links (the address of a product page, with prds=… in it) or catalog IDs. Each one gives a row with every store Google lists for the product, store links, photos, specifications, typical price and price history.

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

How many products to save for each search query. One results page holds about 40; up to 1,000 per query are read across pages and sort orders (see "Deep search").

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

Stop after this many paid rows in the whole run. 0 or empty means no limit.

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

Two-letter country code of the Google Shopping to search: us, gb, de, fr, ca, au, in, es, it, nl, br, mx, jp and any other. Prices come in that country's currency.

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

Language code of the results, for example en, de, fr, es. Empty: the main language of the country.

## `location` (type: `string`):

Search as if from this place, to get local delivery times and nearby stores. Use Google's canonical location name, for example "Austin,Texas,United States" or "10001,New York,United States".

## `sortOrder` (type: `string`):

The order Google sorts the results in.

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

Only products at this price or above, in the country's currency.

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

Only products at this price or below, in the country's currency.

## `minRating` (type: `number`):

Only products rated at least this many stars, from 1 to 5, for example 4 or 4.5.

## `condition` (type: `string`):

New only, used and refurbished only, or any: filters the search the way Google's chip does. Product pages still list every store Google shows, each with its own condition.

## `onSale` (type: `boolean`):

Only products with a discount or an old price.

## `freeShipping` (type: `boolean`):

Only products with free delivery.

## `stores` (type: `array`):

Only products sold by these stores, for example Walmart, Best Buy, Target. Each store gets its own search, the way Google's store filter does it, and an equal share of "Products per query".

## `productDetails` (type: `boolean`):

For every product from the search, also read its Google product page: every store Google lists with price, delivery cost, stock and a direct link to the store's own page, each store's price history, typical price, photos, specifications, variants and review insights. Takes about 30 seconds per 10 products. Priced as "product with details" instead of "product from search".

## `deepSearch` (type: `boolean`):

When one search has fewer products than "Products per query", read the same search sorted by price and by rating too, to find more. Used only with the relevance order.

## `mobileResults` (type: `boolean`):

Search as a phone does. Google shows a slightly different list on phones.

## `trackPriceChanges` (type: `boolean`):

Remember every product's price between runs and mark each row as new, price_down, price_up or unchanged, with the previous price and the change in percent. Turn it on in a scheduled task.

## `onlyNewOrChanged` (type: `boolean`):

Save only products that are new or whose price changed since the last run. Unchanged products are skipped and not charged.

## `monitorName` (type: `string`):

Runs with the same name share one price memory. Use one name per schedule.

## `minPriceChangePercent` (type: `number`):

Price changes smaller than this count as unchanged.

## `alertWebhookUrl` (type: `string`):

Where to send an alert at the end of the run when prices drop or fall to your threshold: a Slack, Discord or Telegram bot address, or any https address (Make, n8n, Zapier, your server get the full JSON).

## `alertPriceBelow` (type: `number`):

Mark products at or below this price and include them in the alert.

## `alertOnPriceDrop` (type: `boolean`):

Include every product whose price fell since the last run in the alert. Needs price comparison, which an alert turns on by itself.

## `fastMode` (type: `boolean`):

Answer within about 30 seconds: the first results page of each query, no product pages, short rows (title, price, store, delivery, links, rating). Filters and sort order still apply. A query Google did not answer in time gets a free TIME_LIMIT row.

## `label` (type: `string`):

Your own text, copied into every row: a client, a project, a category.

## `summaryRows` (type: `boolean`):

Add one free row per search with the lowest, median and highest price, the number of stores and the top stores.

## `saveInlineImages` (type: `boolean`):

Google gives many products of a results page only as a small picture inside the page, without a link. These pictures are saved to the run's key-value store and their signed link goes to "imageUrl", so every product has a picture. Turn off to keep only the links Google gives. With "Open each product page" every product also gets its full-size photos.

## `includeErrorRows` (type: `boolean`):

A free row with the reason for every query or link that gave no product (no results, Google did not answer).

## `failIfAllInputsFail` (type: `boolean`):

By default such a run succeeds with error rows, so that an automation keeps going. Turn this on to make it fail instead.

## `maxConcurrency` (type: `integer`):

How many Google pages to read at once.

## Actor input object example

```json
{
  "queries": [
    "wireless earbuds"
  ],
  "maxProductsPerQuery": 20,
  "country": "us",
  "sortOrder": "relevance",
  "condition": "any",
  "onSale": false,
  "freeShipping": false,
  "productDetails": false,
  "deepSearch": true,
  "mobileResults": false,
  "trackPriceChanges": false,
  "onlyNewOrChanged": false,
  "monitorName": "default",
  "minPriceChangePercent": 0,
  "alertOnPriceDrop": true,
  "fastMode": false,
  "summaryRows": true,
  "saveInlineImages": true,
  "includeErrorRows": true,
  "failIfAllInputsFail": false,
  "maxConcurrency": 5
}
```

# Actor output Schema

## `results` (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 earbuds"
    ],
    "maxProductsPerQuery": 20,
    "country": "us"
};

// Run the Actor and wait for it to finish
const run = await client.actor("anuarbakty/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": ["wireless earbuds"],
    "maxProductsPerQuery": 20,
    "country": "us",
}

# Run the Actor and wait for it to finish
run = client.actor("anuarbakty/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": [
    "wireless earbuds"
  ],
  "maxProductsPerQuery": 20,
  "country": "us"
}' |
apify call anuarbakty/google-shopping-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,anuarbakty/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/sCHPiDDr8DcJqFeIE/builds/tI5TqerVIZTarXRxu/openapi.json
