# Google Shopping Ads Spy Scraper (`lurkapi/google-shopping-ads-spy-scraper`) Actor

Google Shopping ads spy tool. Scrape paid PLA listings from desktop or mobile Google SERP with titles, prices, merchants, landing pages, and screenshots.

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

## Pricing

from $17.00 / 1,000 ad scrapeds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

Google Shopping ads spy tool. Scrape paid PLA (Product Listing Ad) listings from desktop or mobile Google SERP with titles, prices, merchants, landing pages, and screenshots.

Unlike scrapers that only touch the organic `shopping.google.com` tab, this actor targets the **paid Shopping carousel** that appears at the top of a regular Google search. That's where the actual ad competition lives: the inventory, creative, and merchant pricing your competitors are spending on *right now*.

### 👀 Who this is for

**Performance marketers.** Your CPCs jumped 40% on Tuesday. Run this on your top 10 keywords. You see four new advertisers entered the auction this week, two are pushing aggressive sale labels, and you now know who you are bidding against and what their creative says.

**Pricing analysts.** You are launching a new $79 SKU. Run this on the competitor product. Five minutes later you know the price floor ($32), the ceiling ($120), and where the cluster sits ($45 to $65). You set the price with data instead of guessing.

**Ecommerce founders.** You are evaluating a new category before committing. One run on the lead keyword returns 38 sponsored products from 14 brands, with prices and landing pages. You compress a week of competitive research into one dataset.

**Agencies.** You report on competitive ad activity every month. Schedule this actor on the keyword set per client. The dataset lands in your spreadsheet or BI tool. No manual screenshotting, ever.

### 🚀 Quick start

1. Enter one or more **search queries**: `wireless headphones`, `running shoes`, whatever your competitors are bidding on.
2. Pick a **country** and **device** (mobile and desktop Google show different ad inventory).
3. Open the **Proxy** section and set the proxy country to match the country you picked in step 2. Residential is the default and works for every country.
4. Toggle the **add-ons** you want: ad screenshot. *(Landing page archive coming soon.)*
5. Click **Start** and collect the dataset.

### 🎯 What you get per ad

One row per unique sponsored product Google shows for your query. With the dataset you can:

- **Track competitor pricing live.** Pull every ad on your keyword set every Monday. Build a pricing tracker without touching merchant sites.
- **Audit your own ads against the live carousel.** Run on your brand keyword. See your actual position, who is between you and #1, and what their creative says.
- **Map a category before you launch.** Run on the category lead keyword. Get a full sweep of who is bidding, at what price, on what landing pages.
- **Catch new entrants in real time.** Schedule weekly. Diff the merchant list run-over-run. Spot the brands that just started bidding before they scale up.

Every row tells you:

- **The product.** Title, image, current price, original price, discount percent, currency.
- **The seller.** Brand name, storefront domain, star rating, review count.
- **The creative.** Free-shipping badge, sale label, price-drop label, top-quality-store badge, promotional copy.
- **The landing.** The real merchant URL the click goes to. Optionally: the full HTML snapshot of that page *(coming soon)*, plus a PNG screenshot of the rendered ad card.
- **Sanity check.** The city Google geolocated your session to. Confirms your targeting worked.

### 💰 Pricing (pay-per-event)

You pay only for what the actor delivers. **Product thumbnails and the landing page URL are included free on every row.** No flag to enable, no per-event charge.

| Event | Price |
|---|---|
| Ad scraped (base) | $20.00 per 1,000 |
| Landing page HTML archived (add-on) *(coming soon)* | $5.00 per 1,000 |
| Ad screenshot captured (add-on) | $5.00 per 1,000 |

Add-ons only bill when they actually deliver a result. If an ad-screenshot fails for an ad, you are not charged for that ad.

### ❓ FAQ

**How often does the data update?**
Every time you run it. There is no cache. The actor opens Google in real time and reads the current carousel. Run it again 5 minutes later and you may see different ads.

**Can I schedule it?**
Yes. Apify's built-in scheduler lets you run this actor on any cron expression. Most agencies schedule weekly per client; some run daily on the keywords they care most about.

**What countries and languages are supported?**
50 countries (every market where Google Shopping ads run, including US, UK, Japan, Germany, France, Brazil, and more) and 37 languages. The full list is in the input form.

**Do I need to configure a proxy?**
The actor ships with **Residential proxy as the default** and works for every supported country. You can pick Apify's datacenter proxy for `US` runs, or plug in your own custom proxies. The actor verifies before each scrape that the proxy is serving from the country you picked, and rotates the proxy session if it is not.

**Why did my query return no ads?**
Google's Shopping ad inventory changes by the minute. The same query can return 15 ads one minute and 3 the next. Two things to try:

1. **Re-run the same query.** Running 2 or 3 times and combining results gives you a far fuller picture than a single run.
2. **Use a fresh proxy session.** A specific proxy may have landed on a thin set of ads. Re-running picks a new proxy and usually brings the missing ads back.

If you still see 0 ads after 2 or 3 attempts, switch to a more shopping-intent keyword (a brand name or a specific product) or to a country with consistently high inventory like `US` or `GB`.

**Why do I sometimes see CAPTCHAs in the log?**
Google occasionally challenges a specific proxy session. The actor automatically retries with a fresh session up to 5 times per query, which usually clears it. If you see CAPTCHAs on most retries, double-check that your country and language match (for example, country `JP` with language `ja`).

### 💡 Good to know

- **Mobile and desktop show different ads.** Mobile Google Shopping often has richer carousels. Desktop shows fewer ads but with direct merchant links. Run both if you want full competitive coverage.
- **Inventory varies by country and query.** A query with 40 ads in the US may have 3 in Germany. Branded and product-specific queries pull more ads than generic ones.
- **Inventory is dynamic for the same query.** The same keyword can return 15 ads one minute and 3 the next, depending on which advertisers are actively bidding, your detected location, and Google's per-session audience sampling. Run the same query 2 or 3 times and merge the datasets before drawing conclusions. You will get a far more complete competitive picture than from a single run.
- `isSponsored` is always `true`. This actor only scrapes paid listings, never organic results.
- Add-on files (ad screenshots, plus the landing page HTML archive once that ships) are stored in the run's output storage. Retention follows your Apify plan.
- The `detectedLocation` field shows the city Google geolocated the session to. Useful for confirming your targeting worked.

### 📋 Output schema

Field names match what you see in the dataset.

| Field | Description |
|---|---|
| `searchQuery` | The query that produced this ad |
| `device` | `mobile` or `desktop` — the device profile used for this run |
| `position` | Rank inside the Shopping Ads carousel |
| `productTitle` | Ad headline |
| `productImage` | Product image URL (renderable) |
| `price` | Current price shown on the ad |
| `currency` | ISO currency code (USD, JPY, EUR, etc.) |
| `originalPrice` | Pre-sale price when a discount is shown |
| `discountPercent` | Discount percentage when shown |
| `merchant` | Seller brand name |
| `merchantDomain` | Seller's storefront domain |
| `rating` | Product star rating on the ad card (0 to 5) |
| `reviewCount` | Number of product reviews |
| `storeRating` | Merchant's store-level rating (0 to 5), shown on some cards instead of a per-product rating (e.g. Five Below). Independent of `rating`. |
| `freeShipping` | `true` when the ad shows a "Free shipping" badge |
| `saleLabel` | Sale label text ("Sale", "Limited time deal", etc.) |
| `priceDropLabel` | "Price drop" label text when shown |
| `promotionText` | Promo copy on the ad ("Spend $X get $Y", "Code: ABC", etc.) |
| `topQualityStoreBadge` | Google's "Top quality store" flag |
| `detectedLocation` | City Google geolocated this session to (sanity check your targeting) |
| `landingPage` | The real merchant URL behind the ad click. **Included free** |
| `thumbnailKvUrl` | Saved product thumbnail image. **Included free on every row** |
| `savedLandingPage` | Full landing page HTML snapshot saved to your run's storage (paid add-on) *(coming soon)* |
| `adScreenshotKvUrl` | PNG screenshot of the rendered ad card (paid add-on) |

### ⚙️ Advanced configuration

| Input | Description | Default |
|---|---|---|
| `searchQueries` | List of search terms to scrape (up to 500 per run) | required |
| `country` | Country code: `US`, `GB`, `JP`, `FR`, and 46 others (full list in the input form) | `US` |
| `language` | Language code matching the country: `en`, `ja`, `fr`, and 34 others | `en` |
| `device` | `mobile` or `desktop` | `mobile` |
| `maxAdsPerQuery` | Stop scrolling once this many ads have been collected | `20` |
| `proxyConfiguration` | Apify proxy. Residential is the default and required for any non-US country | Residential |
| `captureScreenshot` | Paid add-on: save a PNG screenshot of the rendered ad card | `false` |
| `outputPrice`, `outputMerchant`, `outputProductImage`, `outputRating`, `outputBadges` | Toggle field groups in the output rows | all `true` |

### ⚖️ Disclaimer

This tool is intended for competitive research and personal use. You are responsible for complying with Google's Terms of Service and applicable laws in your jurisdiction. Data availability depends on what Google serves at run time.

---

**Keywords:** google shopping ads spy, shopping ads scraper, competitor ads scraper, google ads intelligence, sponsored listings scraper, ecommerce competitive intelligence, shopping campaign research, product listing ads scraper.

# Actor input Schema

## `searchQueries` (type: `array`):

What you want to spy on. One keyword per entry, up to 500.
## `maxAdsPerQuery` (type: `integer`):

How many ads to collect per keyword before stopping. Higher = more data, longer run.
## `device` (type: `string`):

Mobile and desktop show different ads. Run both if you want full coverage.
## `country` (type: `string`):

The market you want to see ads for. Google Shopping inventory varies heavily by country. Make sure your proxy below matches this country.
## `language` (type: `string`):

The language Google serves the results in. Pick the language most ads in your target country are written in.
## `proxyConfiguration` (type: `object`):

Your proxy must match the country above, otherwise Google shows no ads. **Residential** is the default and works for every country. Datacenter only works for US. You can also plug in your own custom proxies.
## `captureScreenshot` (type: `boolean`):

Save a PNG of each rendered ad card so you can see the creative exactly as a shopper does. Great for screenshots in reports.
## `outputSearchQuery` (type: `boolean`):

searchQuery (the query that produced this ad)
## `outputPosition` (type: `boolean`):

position
## `outputProductTitle` (type: `boolean`):

productTitle
## `outputProductImage` (type: `boolean`):

productImage, thumbnailKvUrl
## `outputPrice` (type: `boolean`):

price, currency, originalPrice, discountPercent
## `outputMerchant` (type: `boolean`):

merchant, merchantDomain
## `outputLandingPage` (type: `boolean`):

landingPage (the real merchant URL behind the ad click)
## `outputRating` (type: `boolean`):

rating, reviewCount, storeRating
## `outputFreeShipping` (type: `boolean`):

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

saleLabel, priceDropLabel, promotionText
## `outputTopQualityStoreBadge` (type: `boolean`):

topQualityStoreBadge
## `outputDetectedLocation` (type: `boolean`):

detectedLocation (the city Google geolocated your session to)

## Actor input object example

```json
{
  "searchQueries": [
    "wireless headphones"
  ],
  "maxAdsPerQuery": 20,
  "device": "mobile",
  "country": "US",
  "language": "en",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  },
  "captureScreenshot": false,
  "outputSearchQuery": true,
  "outputPosition": true,
  "outputProductTitle": true,
  "outputProductImage": true,
  "outputPrice": true,
  "outputMerchant": true,
  "outputLandingPage": true,
  "outputRating": true,
  "outputFreeShipping": true,
  "outputSaleLabels": true,
  "outputTopQualityStoreBadge": true,
  "outputDetectedLocation": true
}
````

# Actor output Schema

## `dataset` (type: `string`):

One row per sponsored Shopping listing — title, price, merchant, rating, add-on URLs.

## `keyValueStore` (type: `string`):

Thumbnails, landing-page HTML archives, and ad screenshots (when add-ons are enabled).

# 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 = {
    "searchQueries": [
        "wireless headphones"
    ],
    "maxAdsPerQuery": 20,
    "device": "mobile",
    "country": "US",
    "language": "en",
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "US"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("lurkapi/google-shopping-ads-spy-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 = {
    "searchQueries": ["wireless headphones"],
    "maxAdsPerQuery": 20,
    "device": "mobile",
    "country": "US",
    "language": "en",
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "US",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("lurkapi/google-shopping-ads-spy-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "searchQueries": [
    "wireless headphones"
  ],
  "maxAdsPerQuery": 20,
  "device": "mobile",
  "country": "US",
  "language": "en",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}' |
apify call lurkapi/google-shopping-ads-spy-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Google Shopping Ads Spy Scraper",
        "description": "Google Shopping ads spy tool. Scrape paid PLA listings from desktop or mobile Google SERP with titles, prices, merchants, landing pages, and screenshots.",
        "version": "0.0",
        "x-build-id": "fQaUo11UFKMJ5gCDI"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/lurkapi~google-shopping-ads-spy-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-lurkapi-google-shopping-ads-spy-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/lurkapi~google-shopping-ads-spy-scraper/runs": {
            "post": {
                "operationId": "runs-sync-lurkapi-google-shopping-ads-spy-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/lurkapi~google-shopping-ads-spy-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-lurkapi-google-shopping-ads-spy-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "searchQueries",
                    "country"
                ],
                "properties": {
                    "searchQueries": {
                        "title": "Search queries",
                        "type": "array",
                        "description": "What you want to spy on. One keyword per entry, up to 500.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxAdsPerQuery": {
                        "title": "Max ads per query",
                        "minimum": 1,
                        "maximum": 200,
                        "type": "integer",
                        "description": "How many ads to collect per keyword before stopping. Higher = more data, longer run.",
                        "default": 20
                    },
                    "device": {
                        "title": "Device",
                        "enum": [
                            "mobile",
                            "desktop"
                        ],
                        "type": "string",
                        "description": "Mobile and desktop show different ads. Run both if you want full coverage.",
                        "default": "mobile"
                    },
                    "country": {
                        "title": "Country",
                        "enum": [
                            "US",
                            "CA",
                            "UK",
                            "IE",
                            "AU",
                            "NZ",
                            "DE",
                            "FR",
                            "ES",
                            "IT",
                            "NL",
                            "BE",
                            "SE",
                            "NO",
                            "DK",
                            "FI",
                            "PL",
                            "PT",
                            "AT",
                            "CH",
                            "JP",
                            "KR",
                            "IN",
                            "BR",
                            "MX",
                            "AR",
                            "ZA",
                            "SG",
                            "HK",
                            "AE",
                            "CL",
                            "CO",
                            "CZ",
                            "GR",
                            "HU",
                            "ID",
                            "IL",
                            "MY",
                            "PE",
                            "PH",
                            "RO",
                            "SA",
                            "SK",
                            "TW",
                            "TH",
                            "TR",
                            "VN",
                            "RU",
                            "BY",
                            "UA"
                        ],
                        "type": "string",
                        "description": "The market you want to see ads for. Google Shopping inventory varies heavily by country. Make sure your proxy below matches this country.",
                        "default": "US"
                    },
                    "language": {
                        "title": "Language",
                        "enum": [
                            "en",
                            "es",
                            "fr",
                            "de",
                            "it",
                            "pt",
                            "nl",
                            "sv",
                            "no",
                            "da",
                            "fi",
                            "pl",
                            "ja",
                            "ko",
                            "zh",
                            "ru",
                            "tr",
                            "ar",
                            "he",
                            "hi",
                            "th",
                            "vi",
                            "id",
                            "ms",
                            "cs",
                            "hu",
                            "ro",
                            "sk",
                            "el",
                            "uk",
                            "bg",
                            "hr",
                            "sr",
                            "sl",
                            "et",
                            "lv",
                            "lt"
                        ],
                        "type": "string",
                        "description": "The language Google serves the results in. Pick the language most ads in your target country are written in.",
                        "default": "en"
                    },
                    "proxyConfiguration": {
                        "title": "Proxy",
                        "type": "object",
                        "description": "Your proxy must match the country above, otherwise Google shows no ads. **Residential** is the default and works for every country. Datacenter only works for US. You can also plug in your own custom proxies.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ],
                            "apifyProxyCountry": "US"
                        }
                    },
                    "captureScreenshot": {
                        "title": "Screenshot the ad",
                        "type": "boolean",
                        "description": "Save a PNG of each rendered ad card so you can see the creative exactly as a shopper does. Great for screenshots in reports.",
                        "default": false
                    },
                    "outputSearchQuery": {
                        "title": "Search query",
                        "type": "boolean",
                        "description": "searchQuery (the query that produced this ad)",
                        "default": true
                    },
                    "outputPosition": {
                        "title": "Position",
                        "type": "boolean",
                        "description": "position",
                        "default": true
                    },
                    "outputProductTitle": {
                        "title": "Product title",
                        "type": "boolean",
                        "description": "productTitle",
                        "default": true
                    },
                    "outputProductImage": {
                        "title": "Product image",
                        "type": "boolean",
                        "description": "productImage, thumbnailKvUrl",
                        "default": true
                    },
                    "outputPrice": {
                        "title": "Price info",
                        "type": "boolean",
                        "description": "price, currency, originalPrice, discountPercent",
                        "default": true
                    },
                    "outputMerchant": {
                        "title": "Merchant",
                        "type": "boolean",
                        "description": "merchant, merchantDomain",
                        "default": true
                    },
                    "outputLandingPage": {
                        "title": "Landing page URL",
                        "type": "boolean",
                        "description": "landingPage (the real merchant URL behind the ad click)",
                        "default": true
                    },
                    "outputRating": {
                        "title": "Rating and reviews",
                        "type": "boolean",
                        "description": "rating, reviewCount, storeRating",
                        "default": true
                    },
                    "outputFreeShipping": {
                        "title": "Free shipping flag",
                        "type": "boolean",
                        "description": "freeShipping",
                        "default": true
                    },
                    "outputSaleLabels": {
                        "title": "Sale and promo labels",
                        "type": "boolean",
                        "description": "saleLabel, priceDropLabel, promotionText",
                        "default": true
                    },
                    "outputTopQualityStoreBadge": {
                        "title": "Top quality store badge",
                        "type": "boolean",
                        "description": "topQualityStoreBadge",
                        "default": true
                    },
                    "outputDetectedLocation": {
                        "title": "Detected location",
                        "type": "boolean",
                        "description": "detectedLocation (the city Google geolocated your session to)",
                        "default": true
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
