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

Scrape Google Shopping prices, stores and offers by keyword, product link or EAN/UPC barcode in any country. Price, old price, store, shipping, rating, reviews, product ID and the retailer's direct link. Every store's offer per product, price filters, price tracking between runs. 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
- **Features:** Limited permissions
- **Stats:** 61 total users, 17 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.66 / 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, Offers & EAN Lookup

**Returns the products Google Shopping 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, from the 3 to 5 stores Google shows first up to every store it has (`maxStores`). It also looks up products by barcode (EAN, GTIN, UPC), and with `compareWithPreviousRun` every row carries the previous price, the change and whether it is the lowest price seen, so a daily schedule becomes a price monitor.**

For e-commerce teams and price monitoring tools, brands enforcing MAP, and agencies and analysts that need product price data. AI agents can call it through the Apify MCP server.

### Google Shopping scraper pricing at a glance

| Event | Free plan | Gold and above |
|---|---|---|
| Product delivered | $3.50 per 1,000 | $2.66 per 1,000 |
| Store offers loaded for a product (and each extra page of 10 stores) | $0.02 | $0.02 |
| Actor start | $0.005 per run | $0.005 per run |

Bronze pays $3.33 and Silver $2.99 per 1,000 products. No monthly fee. A product found in several Google shelves is charged once. Not charged: searches with no products, products outside your filters, duplicates, blocked requests, barcodes that could not be matched, and unchanged products with `onlyChanged`. A barcode with offers is one store offers event; a barcode found without offers is one product event. Free plan: up to 100 products per run.

Examples on the Free plan: 1,000 products from searches = $3.51; 100 products with store offers = $2.36; one product with all 207 stores (21 pages) = $0.42.

### What the Google Shopping scraper fixes

| You need | Input | What comes back |
|---|---|---|
| The retailer's own link, not a Google link | `"includeStoreLink": true` | `storeUrl` (for example `https://www.bestbuy.com/product/...`), and the direct `url` on every store offer |
| Exactly one result per search term | `"maxItemsPerQuery": 1`, `maxItems` = number of terms | One row per term, the product Google ranks first |
| Barcodes in, products and offers out | `"gtins": ["0885909950805"]` | One row per code, double-checked so a store's wrong code is not returned as the product |
| Every store, not just the first five | `"maxStores": 300` | The full "More stores" list, same fields per store |
| Price history without a database | `"compareWithPreviousRun": true` | `previousPrice`, `priceChange`, `priceChangePct`, `isNewLowest` on every row |
| Runs that survive Google hiccups | nothing | Several retries; a search that still fails is a free `BLOCKED` row and the run goes on |

The Actor runs with Apify's limited permissions: it writes only to its own run storages and, with `compareWithPreviousRun`, to the one price-history store it creates. A 30-product run takes about 10 seconds.

Not available: **sponsored (paid) Shopping ads**. Google shows no ads to automated requests (checked on 8 Oct 2026 on 9 result pages in the US and UK), so every row is an organic listing in Google's order.

### Google Shopping scraper input examples

The input form describes each field. Minimal input:

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

Filters and sort, two terms:

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

A daily price or MAP monitor that only reports what moved (save it as a Task with a daily Schedule):

```json
{
  "queries": ["Sony WH-1000XM5", "Bose QuietComfort Ultra"],
  "country": "us",
  "maxItems": 100,
  "compareWithPreviousRun": true,
  "onlyChanged": true
}
```

Day 1 saves the prices and delivers every product as new. From day 2, only products that appeared or changed price are delivered and charged; unchanged products are checked for free. Products are matched by Google's `productId`, and the history keeps a product for 90 days after it stops appearing.

Barcode lookup:

```json
{ "gtins": ["049000028911", "012000161155"], "country": "us" }
```

### EAN, UPC and GTIN barcode lookup

Give a list of barcodes in `gtins` (EAN-8, EAN-13, UPC-A or GTIN-14) and get, per code, the Google Shopping product, its price and, with `includeOffers` and `maxStores`, every store selling it with price, shipping and a direct store link. Each code is double-checked, so a listing that cites the wrong code is not returned as the product (`GTIN_AMBIGUOUS` lists the candidates instead, free). Codes Google does not know come back as `GTIN_NOT_FOUND`, also free. A code Google did not know is remembered for 7 days, so a daily list does not search it again (`recheckMissingGtins` searches every code now).

Four codes are looked up at a time: 80 barcodes with up to 15 stores each take about 35 minutes in the Netherlands. Typical uses: price comparison across retailers for a product list, MAP and reseller monitoring, catalog enrichment from a supplier's EAN list.

### Switching from another Google Shopping scraper? Your existing input works

| Your field | Read as |
|---|---|
| `query`, `queries`, `searchQuery`, `searchQueries`, `q`, `keyword`, `keywords` | Search terms, each searched separately |
| `num` (+ `max_pages`) | Products per term = `num` x `max_pages` |
| `max_pages`, `maxPages` | Google pages per term |
| `page`, `startPage` | First results page to read |
| `limit`, `maxResults`, `maxTotalProducts` | Maximum products in the run |
| `countryCode`, `gl` / `languageCode`, `hl` | Country and language |
| `sortBy`: `BEST_MATCH`, `LOWEST_PRICE`, `HIGHEST_PRICE`, `TOP_RATED` | `relevance`, `price_low`, `price_high`, `rating` |
| `productCondition`: `ANY`, `NEW`, `USED`, `REFURBISHED` | `itemCondition` |
| `stores` (comma separated), `merchants` | `storeFilter` |
| `min_price`, `max_price`, `freeShipping`, `onSale`, `freeReturns` | Same filters |
| `eans`, `upcs`, `barcodes` | `gtins` |
| `more_stores: true` | `maxStores: 15` |
| `date_range`, `sponsored` | Accepted and ignored with a log line (Shopping listings have no date; Google shows no ads) |

### Google Shopping data: output example

A real row, "wireless earbuds", United States, 15 Sep 2026 (long Google identifiers shortened):

```json
{
  "position": 4,
  "title": "Anker Soundcore P31i",
  "price": 34.99,
  "priceText": "$34.99",
  "oldPrice": 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,
  "productId": "8351549705576353052",
  "productUrl": "https://www.google.com/search?ibp=oshop&q=Anker+Soundcore+P31i&prds=catalogid%3A8351549705576353052...",
  "searchQuery": "wireless earbuds",
  "country": "us",
  "scrapedAt": "2026-09-15T18:21:44.329053+00:00",
  "errorCode": null
}
```

With `includeOffers` ("espresso machine", shortened):

```json
{
  "title": "De'Longhi Classic Espresso Machine",
  "price": 224.99,
  "store": "Best Buy",
  "offersCount": 5,
  "offersAvailable": 58,
  "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": "Target", "price": 229.95, "returns": "90-day returns", "url": "https://www.target.com/p/delonghi-linea-classic-espresso-machine/-/A-94266951" }
  ]
}
```

### Google Shopping scraper output fields

| Field | Description |
|---|---|
| `position`, `sortedPosition` | Rank in Google's results, and after your `sort` |
| `title`, `price`, `priceText`, `currency` | Product and current price (number, text, ISO code) |
| `oldPrice`, `discountPercent`, `badge` | Crossed-out price, computed discount, Google's badge |
| `store`, `moreStores`, `shipping`, `freeShipping`, `returns`, `freeReturns` | What the card shows |
| `condition`, `rating`, `reviewCount`, `imageUrl` | `new`, `used` or `refurbished`; Google rating 0 to 5 |
| `productId`, `productUrl` | Google's product ID (use it to track over time) and its Shopping page |
| `offers`, `offersCount`, `offersAvailable`, `lowestOfferPrice` | Store offers: store, price, availability, shipping, returns, `returnDays`, storeRating, url |
| `storeUrl`, `storeUrlStore`, `storeUrlPrice` | With `includeStoreLink`: the retailer's own product link |
| `gtin`, `gtinMatches`, `gtinAlternatives` | On barcode rows: the code, listings citing it, other titles |
| `previousPrice`, `priceChange`, `priceChangePct`, `isNewProduct`, `isNewLowest`, `lowestSeenPrice`, `firstSeenAt` | With `compareWithPreviousRun` |
| `images`, `variants`, `relatedProducts`, `discussions`, `attributes`, `typicalPriceLow`, `typicalPriceHigh` | With `includeDetails` |
| `searchQuery`, `country`, `language`, `searchUrl` | What was searched and where |

The Console has three views: **Products and prices**, **Store offers** and **Price changes**.

### Google Shopping scraper errors (free rows)

`errorCode` is filled only on rows that are not charged: `NO_RESULTS`, `NO_MATCHING_PRODUCTS`, `NO_PRICE_CHANGES` (nothing moved with `onlyChanged`), `NOT_REACHED` (run limit before this term), `BLOCKED`, `PRODUCT_NOT_FOUND`, `INVALID_PRODUCT`, `INVALID_GTIN`, `GTIN_NOT_FOUND`, `GTIN_AMBIGUOUS` (listings disagree with the web; candidates included instead of a guess), `STOPPED_LOW_YIELD` (most barcodes in the list had no product; the codes not searched are listed in `gtinsNotChecked`).

### Use it from code and AI agents

```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", "sort": "price_low"})
for product in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(product["title"], product["price"], product["currency"], product["store"])
```

The same works from the HTTP API (`run-sync-get-dataset-items`), n8n, Make, Zapier and Google Sheets. For AI agents: `https://mcp.apify.com/?actors=scrapewise/google-shopping`.

Video guides from Apify: [how to schedule an Actor](https://www.youtube.com/watch?v=1jI7WcVQmwM) and [how to connect it to other apps](https://www.youtube.com/watch?v=bNACk1_S_6w).

Requests an agent can pass straight through:

- "Find the cheapest store for EAN 0885909950805 in Germany" -> `{"gtins": ["0885909950805"], "country": "de", "includeOffers": true, "maxStores": 30}`
- "Compare prices for wireless earbuds under $50 in the US" -> `{"queries": ["wireless earbuds"], "country": "us", "maxPrice": 50, "sort": "price_low"}`
- "Tell me which of these products got cheaper since yesterday" -> same input as yesterday plus `{"compareWithPreviousRun": true, "onlyChanged": true}`

### Google Shopping scraper FAQ

**Is there an official Google Shopping API?**
Not for search results. Google's Merchant API (formerly Content API for Shopping) manages your own products in Merchant Center; it does not return what Google Shopping ranks for a keyword or other stores' prices. This Actor reads the public Shopping results, so you get ranked products, prices and store offers for any term or barcode.

**Which countries?** Any country with Google Shopping, with local stores and currency; tested in the US, UK, Germany, France, India, Japan and Brazil.

**How many products per term?** Usually 150 to 250 unique products. For more, use several related terms.

**Why fewer products than `maxItems`?** Google ran out of products, or your filters removed many; with narrow filters the Actor stops paging early. Filtered products are free.

**Why can results differ from my browser?** Your browser adds personalization. The Actor opens the Shopping tab for your `country` and `language`, without personalization, and checks that prices come back in the right currency.

**Does it return GTIN or MPN for search results?** No: Google does not show them on the search results. `gtin` is filled only on barcode lookup rows.

### Google Shopping scraper limitations

- Store offers default to the 3 to 5 Google shows first; `maxStores` gets the rest, in pages of 10.
- `sort` orders the products collected for each term; Google's own sort buttons are not available.
- Price and condition filters are also added to the search text in English, and every product is checked against them before it is saved.
- Shipping, rating and return policy appear only when Google shows them on the card.
- Review texts are not collected; `rating` and `reviewCount` come from the card.
- Prices are what Google shows at the moment of the run.

Something broke or a field is missing? Open an issue on the Issues tab.

### Related scrapers

- [Target Scraper](https://apify.com/scrapewise/target-scraper): Target products, prices, stock, UPC and ratings.
- [AliExpress Scraper](https://apify.com/scrapewise/aliexpress-scraper): AliExpress products, sold counts and 40 fields.
- [Shopee Scraper](https://apify.com/scrapewise/shopee-scraper): Shopee products, prices and shops in 8 countries.
- [Etsy Scraper](https://apify.com/scrapewise/etsy-scraper): Etsy bestsellers, in-cart counts and shop sales.
- [Mercado Livre Scraper](https://apify.com/scrapewise/mercadolivre-scraper): Mercado Livre prices, sales and sellers in Brazil.

### Changelog

- **2026-11-09:** barcode lists that return almost nothing stop early with `STOPPED_LOW_YIELD` (free) instead of searching every code.

- **2026-10-22:** barcodes with no product are remembered for 7 days and skipped (free); `recheckMissingGtins` searches them again.

- **2026-10-19:** barcode lookup runs 4 codes at a time (about 4x faster, same results and cost per code).

- **2026-10-08:** `includeStoreLink`; store offers carry the retailer URL instead of Google's redirect; input of other Google Shopping actors understood; more retries, so fewer `BLOCKED` rows.

- **2026-10-05:** `maxStores` returns the full "More stores" list; new `attributes` field.

- **2026-10-01:** price tracking with `compareWithPreviousRun` and `onlyChanged`; `freeReturns`, `returnDays` and the `freeReturnsOnly` filter.

# 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 and every row says which term it came from ('searchQuery'). There is no limit on terms per run. 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. Set 1 to get exactly one product per term (the top-ranked one). With many terms, set 'Maximum products' to terms x this number so every term is searched. 'num', 'resultsPerPage' and 'maxResultsPerQuery' also work.

## `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.

## `freeReturnsOnly` (type: `boolean`):

Only products whose Google card says returns are free (for example "Free 60-day returns"). Google shows the return policy on about one card in six, so this filter keeps few products; every product also gets a 'freeReturns' flag and the store offers get 'freeReturns' and 'returnDays' without this filter.

## `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.

## `includeStoreLink` (type: `boolean`):

Adds 'storeUrl': the retailer's own product page (walmart.com, bestbuy.com, the brand's shop...), not a Google link, plus 'storeUrlStore', 'storeUrlPrice' and 'storeUrlMatch' (same offer as the product card, same store, or the cheapest store). Google only puts the store link on the product page, so this opens it once per product: it turns on the store offers and is charged as the same 'Store offers loaded' event, nothing more.

## `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. Turn on 'Include product details' too to get the photos, variants, related products and forum threads of that same page at no extra cost.

## `includeDetails` (type: `boolean`):

Opens each product page and adds 'images' (the photo gallery, usually 10 to 15), 'variants' (colors or models with their photo), 'relatedProducts' (similar and cheaper options with price, store and rating), 'discussions' (Reddit and forum threads Google links to the product: title, site, age, link), 'attributes' (the product attributes Google lists, such as battery life, color, size or impedance) and 'typicalPriceLow'/'typicalPriceHigh'. It is the same page as the store offers, so it turns them on too and costs the same single event: no extra charge on top of the offers. Full review texts are not in that page and are not collected.

## `maxStores` (type: `integer`):

Get the full 'More stores' list instead of the 3 to 5 stores Google shows first. Leave empty or 0 to keep the default. With 25, each product comes with up to 25 stores; with 300, every store Google has for it (popular products have 100 to 200+). Stores come in pages of 10 and each extra page that brings at least one new store is charged as one more 'Store offers loaded' event ($0.02, about $2 per 1,000 stores). The run stops when Google has no more stores, so you never pay for empty pages. Turns on the store offers and adds 'attributes'. Free plan: up to 30 stores per product.

## `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.

## `gtins` (type: `array`):

Look up products by barcode, one code per line (UPC-A such as 049000028911, EAN-13, EAN-8 or GTIN-14). Each code returns one row: the product Google Shopping matches to that barcode, with its store offers (store, price, shipping, availability, direct link) already loaded. A barcode with no product in the chosen country returns a free row with errorCode GTIN_NOT_FOUND. Also accepts 'eans', 'upcs' and 'barcodes'.

## `recheckMissingGtins` (type: `boolean`):

A barcode that had no product on Google Shopping in this country is remembered for 7 days (in a key-value store on your account) and comes back as a free GTIN_NOT_FOUND row without searching again. Tick this to search every barcode now.

## `compareWithPreviousRun` (type: `boolean`):

Keeps the last price of every product in a key-value store on your account (named after this input, or after 'Snapshot name') and adds to each row: previousPrice, priceChange, priceChangePct, isNewProduct, isNewLowest (lowest price ever seen for that product), lowestSeenPrice, firstSeenAt and previousSeenAt. On the first run every product is new. Schedule the same Task daily to get price history and alerts.

## `onlyChanged` (type: `boolean`):

With 'Compare prices with the previous run' on: rows whose price did not move since the previous run are not saved and not charged. 'Maximum products' still counts the products checked, so a daily run costs the same Google pages and you pay only for the rows you get. A search where nothing changed returns one free row with errorCode NO_PRICE_CHANGES.

## `snapshotName` (type: `string`):

Name of the price history to compare with. Leave empty to derive it from the search terms, barcodes, links and country of this input (the same input always compares with itself). Set it to share one history between different inputs, for example one per brand.

## Actor input object example

```json
{
  "queries": [
    "wireless earbuds"
  ],
  "country": "us",
  "language": "en",
  "maxItems": 30,
  "maxPagesPerQuery": 10,
  "sort": "relevance",
  "itemCondition": "any",
  "onSaleOnly": false,
  "freeShippingOnly": false,
  "freeReturnsOnly": false,
  "includeStoreLink": false,
  "includeOffers": false,
  "includeDetails": false,
  "recheckMissingGtins": false,
  "compareWithPreviousRun": false,
  "onlyChanged": 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/1BMBcL4ENdFl6jG6w/openapi.json