# Google Shopping Scraper - Prices, Stores & Offers (`scrapewise/google-shopping`) Actor

Scrape Google Shopping in any country: product title, price, old price, discount, currency, store, shipping, condition, rating, reviews, image, product ID and link. Optional store-by-store offers with direct links. Price, condition and store filters. Pay per product.

- **URL**: https://apify.com/scrapewise/google-shopping.md
- **Developed by:** [Scrapewise Data](https://apify.com/scrapewise) (community)
- **Categories:** E-commerce, SEO tools
- **Stats:** 4 total users, 3 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 google shopping 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 - Prices, Stores & Offers

**Google Shopping scraper that returns the products Google ranks for any keyword, in any country: title, current price, old price, discount, currency, store, shipping, condition, rating, review count, image, Google product ID and link, plus optional store-by-store offers with direct store links.**

Built for e-commerce teams and price-monitoring tools, brands enforcing MAP, and agencies and analysts that need clean product price data at **$2.50 per 1,000 products**. AI agents can call it through the Apify MCP server.

### At a glance

| | This Actor | burbn/google-shopping-scraper (most used in the last 30 days) |
|---|---|---|
| Price per 1,000 products, Free plan | **$2.50** | $20.00 |
| Price per 1,000 products, Gold plan and above | **$2.00** | $5.00 |
| Fee per run start | None | $8.00 per 1,000 run starts |
| Searches with no results, filtered-out products, duplicates, blocked requests | Free rows with an `errorCode` | Not stated on its page |
| Users in the last 30 days | 1 (published 2026-09-15) | 134 |
| Store rating | No reviews yet | 5.0 (2 reviews) |
| Public run success, last 30 days | No public runs yet; 32 of our 34 test runs succeeded | 99.9% (6,009 of 6,018) |

Competitor figures were read from the public Apify API (`api.apify.com/v2/store?search=google shopping`) on **2026-09-15** and change every day; the Store page always shows the live number. Across the ten most relevant Actors for the term that day, search-result prices ran from $2 to $70 per 1,000 products, several of them with an extra fee of up to $0.035 charged on every run start.

### One real row

Minimal input:

```json
{ "queries": ["wireless earbuds"], "country": "us", "maxItems": 30 }
```

A real row from a run of 2026-09-15, shortened in the long Google identifiers (the full row is under "Output example" below):

```json
{
  "position": 4,
  "title": "Anker Soundcore P31i",
  "price": 34.99,
  "priceText": "$34.99",
  "oldPrice": 50,
  "discountPercent": 30,
  "currency": "USD",
  "store": "soundcore US",
  "moreStores": true,
  "shipping": "Free delivery",
  "freeShipping": true,
  "condition": "new",
  "rating": 4.8,
  "reviewCount": 1500,
  "productId": "8351549705576353052",
  "searchQuery": "wireless earbuds",
  "country": "us",
  "scrapedAt": "2026-09-15T18:21:44.329053+00:00",
  "errorCode": null
}
```

### What you can do with it

- **Price monitoring:** schedule the same search terms every day and track how price, old price and discount change for each Google product ID.
- **MAP (minimum advertised price) enforcement:** search your brand or model names, filter by store, and see which retailers show a price below your policy, with the store's own product link.
- **Competitor pricing:** compare what Walmart, Best Buy, Target, Amazon marketplace sellers and small shops charge for the same product in the US, UK, Germany, Japan, Brazil or any other Google Shopping country.
- **Assortment and market research:** list the top products Google ranks for a category, with ratings, review counts and prices, to size a market or spot gaps.
- **Deal hunting and affiliate content:** keep only products on sale or with free shipping, sorted by price or rating.

### Why this one

- **$2.50 per 1,000 products, no start fee, no monthly rent.** Most Google Shopping scrapers in the Store charge $3.50 to $20 per 1,000 results or add a per-run fee.
- **Pay per unique product.** The same product often appears in several Google shelves ("Top rated", "Deals", "All products"). It is saved and charged once.
- **Any country Google Shopping supports.** Prices come in the local currency with local stores: USD, GBP, EUR, JPY, BRL, INR, CAD, AUD and more.
- **No browser.** Plain HTTP through Apify's Google SERP proxy: a 30-product run finishes in about 10 seconds.
- **Searches without products do not fail your run and are not charged.** They come back as a row with an `errorCode`, so your workflow keeps going.
- **Drop-in input.** Accepts the field names used by other Google Shopping scrapers (`searchQuery`, `searchQueries`, `countryCode`, `languageCode`, `limit`, `maxResults`, `sortBy`, `productCondition`, `stores`, `merchants`, `min_price`, `max_price`...).
- **Optional store offers.** Turn on `includeOffers` to open each product and get the stores Google lists first (store, price, shipping, availability, returns, store rating and the direct store URL) plus how many offers exist in total.

### Input example

```json
{
  "queries": ["wireless earbuds", "espresso machine"],
  "country": "us",
  "language": "en",
  "maxItems": 100,
  "sort": "price_low",
  "minPrice": 20,
  "maxPrice": 150,
  "itemCondition": "new",
  "onSaleOnly": false,
  "freeShippingOnly": false,
  "storeFilter": ["walmart", "best buy"],
  "includeOffers": false
}
```

Only `queries` matters to start. Everything else is optional.

#### Input fields

| Field | Type | What it does |
|---|---|---|
| `queries` | list of text | Products or keywords to search, one per line. Each term is searched separately. |
| `country` | text | Two-letter country code (Google's `gl`): `us`, `gb`, `de`, `fr`, `br`, `in`, `jp`... Sets stores and currency. Default `us`. |
| `language` | text | Interface language (Google's `hl`): `en`, `de`, `fr`, `pt-BR`, `ja`... Default `en`. |
| `maxItems` | number | Maximum unique products in the run, across all terms. Default 30. |
| `maxItemsPerQuery` | number | Optional cap per search term. |
| `maxPagesPerQuery` | number | Google pages per term (about 30 to 40 new products each). Default 10, max 30. |
| `sort` | select | `relevance` (Google's order), `price_low`, `price_high`, `rating`, `reviews`. |
| `minPrice`, `maxPrice` | number | Price range in the country's currency. |
| `itemCondition` | select | `any`, `new`, `used`, `refurbished`. |
| `minRating` | number | Minimum Google rating, 0 to 5. |
| `onSaleOnly` | yes/no | Only products with an old price or a deal badge. |
| `freeShippingOnly` | yes/no | Only products whose card says free delivery. |
| `storeFilter` | list of text | Only these stores (part of the name is enough). |
| `includeOffers` | yes/no | Adds store-by-store offers for each product (separate event, see pricing). |
| `productUrls` | list of text | Google Shopping product links (with `prds=`) or product IDs from a previous run, to get their store offers directly. |

### Output example (real run, "wireless earbuds", United States, 15 Sep 2026)

| Rank | Product | Price | Was | Store | Shipping | Rating | Reviews |
|---|---|---|---|---|---|---|---|
| 1 | JLab Go Air Pop True Wireless Earbuds | $19.99 | $25 | Target | Free delivery on $35+ | 4.3 | 31,000 |
| 2 | Jbl Vibe Flex 2 Earbuds | $39.88 | | Walmart | Free delivery | 3.8 | 456 |
| 3 | Sony WF-C510 Truly Wireless Earbuds | $69.99 | | Best Buy | Free delivery by Thu | 4.7 | 5,100 |
| 4 | Anker Soundcore P31i | $34.99 | $50 | soundcore US | Free delivery | 4.8 | 1,500 |
| 5 | Sennheiser ACCENTUM True Wireless Earbuds | $219.95 | | Sennheiser Consumer Audio US | Free delivery by Sat | 4.2 | 111 |

The same run in other countries (real rows from the same day):

| Country | Product | Price | Currency | Store |
|---|---|---|---|---|
| United Kingdom | Samsung Galaxy Buds3 FE | £89.00 | GBP | Very |
| Germany | Apple AirPods 4 | 44,91 € | EUR | eBay DE |
| Japan | Xiaomi REDMI Buds 8 Active | ￥2,780 | JPY | Amazon公式サイト |
| Brazil | Fone de Ouvido Philips Bluetooth | R$ 178,51 | BRL | Magalu |

One full row:

```json
{
  "position": 4,
  "title": "Anker Soundcore P31i",
  "price": 34.99,
  "priceText": "$34.99",
  "oldPrice": 50,
  "oldPriceText": "$50",
  "discountPercent": 30,
  "badge": "30% OFF",
  "currency": "USD",
  "store": "soundcore US",
  "moreStores": true,
  "shipping": "Free delivery",
  "freeShipping": true,
  "condition": "new",
  "rating": 4.8,
  "reviewCount": 1500,
  "imageUrl": "https://encrypted-tbn0.gstatic.com/shopping?q=tbn:ANd9GcQHiNmnc_...",
  "productId": "8351549705576353052",
  "catalogId": "8351549705576353052",
  "gpcid": "4423948571700959631",
  "offerDocId": "10564607306790038108",
  "productDocId": "11127797448468676590",
  "productUrl": "https://www.google.com/search?ibp=oshop&q=Anker+Soundcore+P31i&prds=catalogid%3A8351549705576353052%2C...&udm=28&hl=en&gl=us",
  "offers": null,
  "searchQuery": "wireless earbuds",
  "country": "us",
  "language": "en",
  "page": 1,
  "searchUrl": "https://www.google.com/search?q=wireless+earbuds&udm=28&hl=en&gl=us",
  "scrapedAt": "2026-09-15T18:21:44.329053+00:00",
  "errorCode": null
}
```

With `includeOffers` on (real run, "espresso machine", shortened):

```json
{
  "title": "De'Longhi Classic Espresso Machine",
  "price": 224.99,
  "currency": "USD",
  "store": "Best Buy",
  "offersCount": 5,
  "offersAvailable": 58,
  "typicalPriceText": "$225–$230",
  "offers": [
    { "store": "Best Buy", "price": 224.99, "availability": "In stock online", "shipping": "Free delivery by Thu", "returns": "15-day returns", "storeRating": 4.6, "url": "https://www.bestbuy.com/product/delonghi-classic-espresso-machine-stainless-steel/J7G8Z85C38/sku/6615146" },
    { "store": "Walmart - PRIME LIFE", "price": 225, "availability": "In stock online", "shipping": "Free delivery by Fri", "url": "https://www.walmart.com/ip/De-Longhi-Linea-Classic-Espresso-Machine/17106869078" },
    { "store": "De'Longhi", "price": 229.95, "shipping": "Free delivery", "returns": "14-day returns", "storeRating": 3.7, "url": "https://www.delonghi.com/en-us/p/de-longhi-classic-de-longhi-classic-espresso-machine/EM450M.html" },
    { "store": "Target", "price": 229.95, "shipping": "Free delivery between Sep 18 – 22", "returns": "90-day returns", "storeRating": 4.5, "url": "https://www.target.com/p/delonghi-linea-classic-espresso-machine/-/A-94266951" }
  ]
}
```

#### Output fields

| Field | Description |
|---|---|
| `position` | Rank of the product in Google's results for the search term (1 = first). |
| `sortedPosition` | Rank after your `sort` option, when it is not relevance. |
| `title` | Product title as shown by Google Shopping. |
| `price`, `priceText` | Current price as a number and as shown. |
| `oldPrice`, `oldPriceText` | Crossed-out price when the store shows one. |
| `discountPercent`, `badge` | Discount computed from the two prices, and Google's badge ("20% OFF", "LOW PRICE"). |
| `currency` | ISO currency code (USD, GBP, EUR, JPY, BRL...). |
| `store`, `moreStores` | Store shown on the card, and whether Google says "& more" stores sell it. |
| `shipping`, `freeShipping` | Delivery text and a true/false flag for free delivery. |
| `returns` | Return policy text when shown on the card. |
| `condition`, `conditionText` | `new`, `used` or `refurbished`, and Google's label ("Pre-owned", "Gebraucht"...). |
| `rating`, `reviewCount` | Google product rating (0 to 5) and number of reviews. |
| `imageUrl` | Product image. |
| `productId`, `catalogId`, `gpcid`, `offerDocId`, `productDocId` | Google Shopping identifiers. Use `productId` to track a product over time. |
| `productUrl` | Link to the product on Google Shopping (also accepted in `productUrls`). |
| `offers` | Store offers (with `includeOffers` or `productUrls`): store, merchantId, price, oldPrice, currency, offerTitle, availability, shipping, returns, storeRating, url, offerId. |
| `offersCount`, `offersAvailable`, `lowestOfferPrice` | Offers returned, offers Google says exist, and the lowest offer price. |
| `description`, `typicalPriceText` | Product description and Google's "Typically" price range (with offers). |
| `searchQuery`, `country`, `language`, `page`, `searchUrl` | What was searched and where the product was found. |
| `scrapedAt` | When the row was collected (UTC). |
| `errorCode`, `error` | Filled only on free rows: `NO_RESULTS`, `NO_MATCHING_PRODUCTS`, `BLOCKED`, `PRODUCT_NOT_FOUND`, `INVALID_PRODUCT`. |

### Pricing

**$2.50 per 1,000 products, no monthly fee, no start fee.**

| Event | Price | When it is charged |
|---|---|---|
| Google Shopping product delivered | $0.0025 | Once per unique product saved to the dataset. |
| Store offers loaded for a product | $0.02 | Only with `includeOffers` on or with `productUrls`, once per product that came back with at least one store offer. It needs one extra Google page per product. |

Store discounts by plan, on the product event:

| Apify plan | Price per product | Per 1,000 products |
|---|---|---|
| Free | $0.0025 | $2.50 |
| Bronze | $0.0023 | $2.30 |
| Silver | $0.0021 | $2.10 |
| Gold and above | $0.0020 | $2.00 |

Not charged: searches with no products, products outside your filters, duplicates, and blocked requests.

Examples at the Free plan price: 1,000 products from searches = $2.50. 100 products with store offers = $0.25 + $2.00 = $2.25.

How this compares with other Google Shopping Actors in the Apify Store (measured on 2026-09-15): search-result scrapers charge from $3.50 to $20 per 1,000 results on the Free plan, often with an extra fee per run, and offer-by-product scrapers charge $15 to $20 per 1,000 products.

You can set a maximum cost per run in Apify: the Actor stops when the limit is reached and keeps everything it already saved.

### How to use it

#### In Apify Console

1. Type your search terms, pick the country and how many products you need.
2. Click **Start**. Results appear in the **Products and prices** view and can be exported as JSON, CSV, Excel or HTML.
3. Use the **Store offers** view to see one row per store when offers are on.

#### Via API

```bash
curl -X POST "https://api.apify.com/v2/acts/scrapewise~google-shopping/run-sync-get-dataset-items?token=YOUR_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"queries": ["wireless earbuds"], "country": "us", "maxItems": 50}'
```

Python:

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_API_TOKEN")
run = client.actor("scrapewise/google-shopping").call(run_input={
    "queries": ["running shoes"],
    "country": "gb",
    "maxItems": 200,
    "sort": "price_low",
})
for product in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(product["title"], product["price"], product["currency"], product["store"])
```

#### Scheduling

Create a Task with your search terms and add a Schedule (for example every morning). Each run gives you a fresh dataset; join the rows by `productId` to build price history.

#### Integrations

Send results to Google Sheets, Slack, Airtable, a webhook, **n8n**, **Make** or **Zapier** with Apify's integrations. In n8n and Make, use the Apify node with the Actor ID `scrapewise/google-shopping`.

#### AI agents and MCP

The Actor works with the Apify MCP server, so Claude, ChatGPT, Cursor and other MCP clients can call it as a tool: "find the 20 cheapest espresso machines on Google Shopping in Germany". Add `scrapewise/google-shopping` to your Apify MCP server configuration (`https://mcp.apify.com/?actors=scrapewise/google-shopping`). Each call is billed per product like any other run.

### Limitations

- **Store offers:** Google loads "More stores" with JavaScript. The Actor returns the offers Google lists first on the product page (usually 3 to 5) and tells you the total in `offersAvailable`.
- **Sorting:** Google's own sort buttons are not available over HTTP. The `sort` option orders the products collected for each search term; use a higher `maxItems` if you want the cheapest products among more results.
- **Filters:** price and condition filters are also added to the search text in English (for example "under $30", "used"), which makes Google return more matching products. Every product is checked against your filters before it is saved, in any language.
- **Depth:** Google shows a limited number of pages per search, usually 150 to 250 unique products per term. For more, use several related terms (brand, model, category).
- **Shipping and rating** appear only when Google shows them on the card; in some countries shipping is not shown in results.
- Prices are what Google Shopping displays at the moment of the run. Stores can change them at any time.

If something breaks or a field is missing, open an issue on the Actor page. Issues are answered within a day.

### FAQ

**Is it legal to scrape Google Shopping?**
The Actor collects only public search result pages, without logging in. You are responsible for how you use the data and for complying with the laws and terms that apply to you. This Actor collects only public data and respects the site's terms.

**Which countries are supported?**
Any country where Google Shopping is available. Tested on 15 Sep 2026 in the United States, United Kingdom, Germany, France, India, Japan and Brazil, each with local stores and currency.

**Can I choose the currency?**
Google shows prices in the currency of the country you pick, so set `country` (for example `de` for EUR, `jp` for JPY). The `currency` field tells you the code for every row.

**How many products can I get per search term?**
Usually 150 to 250 unique products per term (about 30 to 40 new products per Google page). The run stops by itself when Google stops showing new products.

**Why did my run return fewer products than `maxItems`?**
Either Google ran out of products for that term, or your filters removed many of them. With narrow filters the Actor stops paging after a few pages that keep almost nothing, so you do not wait for pages full of products you would not use. Filtered-out products are never charged.

**Do I pay for duplicates or empty searches?**
No. A product is charged once per run even if it appears in several Google shelves, and a search with no products returns a free row with `errorCode: NO_RESULTS`.

**How do I get the price from every store?**
Turn on `includeOffers`, or paste product links or `catalogId` values in `productUrls`. Each product row gets an `offers` list with store, price, shipping, availability and the direct store link.

**How do I track prices over time?**
Schedule the same Task daily and match rows by `productId`. `price`, `oldPrice` and `discountPercent` show how the price moved.

**Does it work with n8n, Make, Zapier or Google Sheets?**
Yes, through Apify's integrations and the Apify nodes for n8n and Make. Results can also be read from the dataset API in JSON, CSV or Excel.

**Can an AI agent use it?**
Yes. Add it to the Apify MCP server and call it from Claude, ChatGPT, Cursor or any MCP client, or call the REST API from your own agent.

**I use another Google Shopping scraper. Do I need to change my input?**
Usually not. The Actor accepts common field names from other scrapers (`searchQuery`, `searchQueries`, `countryCode`, `languageCode`, `limit`, `sortBy`, `productCondition`, `stores`, `merchants`, `min_price`, `max_price`).

### Changelog

- **2026-09-15 (page):** page corrected to the live price of $2.50 per 1,000 products on the Free plan, with the Store discount ladder down to $2.00 on Gold and above; added the "At a glance" comparison with the most used Actor for this term, measured on the public Apify API that day, and a real output row in the first screen.
- **0.1 (15 Sep 2026):** first version. Search by keyword in any country, price, old price, discount, store, shipping, condition, rating, reviews, image and Google product IDs; price, condition, rating, sale, free-shipping and store filters; sorting; optional store offers with direct links; product links and IDs mode.

### Em português

Coleta resultados do Google Shopping de qualquer país: título, preço, preço antigo, desconto, moeda, loja, frete, condição, nota, avaliações, imagem, ID do produto e link, com ofertas por loja opcionais. Para monitoramento de preço, MAP e preço da concorrência.

- Monitorar preço todo dia pelo mesmo termo e acompanhar cada produto pelo `productId`.
- Conferir quais lojas anunciam abaixo do preço mínimo da marca (MAP).
- Comparar o preço da concorrência em qualquer país, na moeda local (`country: "br"` traz reais e lojas brasileiras).

Preço: **US$ 2,50 por 1.000 produtos no plano Free (US$ 2,00 no Gold), sem mensalidade e sem taxa por execução**. Ofertas por loja: US$ 0,02 por produto, só quando pedidas.

Keywords: google shopping scraper, google shopping api, google shopping prices, product prices google, price monitoring, competitor pricing, MAP monitoring, minimum advertised price, price tracker, ecommerce scraper, google shopping offers, product price comparison, merchant prices, retailer prices, shopping results scraper, google product search

# Actor input Schema

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

Products or keywords to search on Google Shopping, one per line (for example "wireless earbuds", "running shoes", a brand or a model name). Each term is searched separately. Also accepts 'searchQueries', 'searchQuery', 'query' or 'q' from other Google Shopping scrapers.

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

Two-letter country code (Google's gl), for example us, gb, de, fr, br, in, jp. It sets the stores and the currency Google shows: prices come in that country's currency (USD for us, EUR for de, JPY for jp...). 'countryCode' and 'gl' also work.

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

Interface language (Google's hl), for example en, de, fr, pt-BR, ja. Product titles stay as the stores wrote them. 'languageCode' and 'hl' also work.

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

Maximum number of unique products in this run, across all search terms. You pay per product delivered.

## `maxItemsPerQuery` (type: `integer`):

Cap for each term, so one term does not use the whole 'Maximum products'.

## `maxPagesPerQuery` (type: `integer`):

Each Google Shopping page brings about 30 to 40 new products. The Actor stops earlier when Google stops showing new products.

## `sort` (type: `string`):

Relevance keeps Google's own order ('position'). The other options sort the products collected for each search term before they are saved. 'sortBy' from other Google Shopping scrapers (LOWEST\_PRICE, price\_low, review\_score...) also works.

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

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

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

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

## `itemCondition` (type: `string`):

Filter by the condition Google shows on the product card. 'condition' and 'productCondition' from other scrapers (NEW, used, refurbished...) also work.

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

Only products with a Google rating at or above this (0 to 5). Products without rating are left out when set.

## `onSaleOnly` (type: `boolean`):

Only products with a crossed-out old price or a deal badge (20% OFF, LOW PRICE...).

## `freeShippingOnly` (type: `boolean`):

Only products whose card says free delivery or free shipping.

## `storeFilter` (type: `array`):

Only products sold by these stores (part of the name is enough, for example "walmart", "best buy", "amazon"). 'stores' and 'merchants' (list or comma-separated text) also work.

## `includeOffers` (type: `boolean`):

Opens each product and adds 'offers': store, price, shipping, availability, returns and the direct store link for the offers Google lists first (usually 3 to 5), plus 'offersAvailable' and the description. One extra Google page per product, charged as a separate event.

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

Get store offers for specific products: paste Google Shopping product links (the URL with 'prds=' you get when you open a product) or the numeric product IDs from a previous run ('catalogId'). One row per product with its offers.

## Actor input object example

```json
{
  "queries": [
    "wireless earbuds"
  ],
  "country": "us",
  "language": "en",
  "maxItems": 30,
  "maxPagesPerQuery": 10,
  "sort": "relevance",
  "itemCondition": "any",
  "onSaleOnly": false,
  "freeShippingOnly": false,
  "includeOffers": false
}
```

# Actor output Schema

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

No description

## `resultsCsv` (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"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapewise/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 earbuds"] }

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

```

## MCP server setup

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