# Google Shopping Ads Scraper (`maximedupre/google-shopping-ads-scraper`) Actor

Get live paid Google Shopping ads from Google Search. Export product titles, prices, merchants, landing pages, ranks, and market data for your keyword list.

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

## Pricing

from $14.00 / 1,000 shopping 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.

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 Scraper

Google Shopping Ads Scraper gets live paid product ads from [Google Search](https://www.google.com/). Give it shopping keywords like `wireless headphones`, pick a market, and export the sponsored product cards Google shows on the search page.

Use it to see which products, prices, stores, and landing pages show up for the keywords you care about. Each run gives you clean rows you can open in Apify, download as CSV or JSON, send to an API, or schedule for repeat checks.

### What You Can Use It For

- Track Google Shopping ads for your product keywords.
- Compare live prices across stores and brands.
- Watch which merchants enter or leave a search result.
- Save landing pages for paid Shopping ads.
- Build weekly ad and price reports for ecommerce clients.
- Check whether your own product ads show up near the top.

This actor is for **live paid Shopping ads on Google Search**. It is not a Google Ads Transparency Center scraper and it does not scrape organic Google Shopping tab results.

### What Data You Get

Each dataset row is one sponsored Shopping product listing. Rows can include:

- Search keyword and device.
- Ad position on the Google Search page.
- Product title.
- Current price, numeric price, currency, and original price when shown.
- Discount percent when an original price is shown.
- Merchant name and merchant domain.
- Review count and rating when Google shows them.
- Sale label and delivery text when shown.
- Merchant landing page.
- Google ad click URL.
- Market, language, result page URL, scrape time, and dedupe key.

Some fields can be empty because Google does not show every field on every ad card.

### Quick Start

1. Add one or more shopping keywords, such as `wireless headphones`.
2. Pick the Google market and language.
3. Pick `desktop` for the safest first run.
4. Set the ad limit per keyword.
5. Start the actor and open the dataset.

For a small first run, use one keyword, market `US`, language `en`, device `desktop`, and an ad limit of `25`.

### Input

#### Search Keywords

Enter product or category searches that are likely to show Shopping ads. Good examples:

- `wireless headphones`
- `running shoes`
- `coffee maker`
- `standing desk`

Broad informational searches may return few or no Shopping ads.

#### Market And Language

The market changes which ads Google shows. For example, the same keyword can return different ads in the United States, Germany, Japan, or Brazil.

The actor handles source access for the selected market. You do not need to add Google cookies, a Google Ads account, or a Google API key.

#### Devices

Google can show different ads on desktop and mobile. Desktop is the best first run. Mobile is available, but Google ad inventory and access can vary more, so some mobile runs may return fewer rows.

#### Limits

Use `maxAdsPerQuery` to cap rows for each keyword and device. Use `maxTotalAds` when you want a hard cap for the whole run.

### Output Example

```json
{
  "searchQuery": "wireless headphones",
  "device": "desktop",
  "position": 1,
  "productTitle": "Beats Solo Buds True Wireless Bluetooth Earbuds",
  "price": "$69.99",
  "priceValue": 69.99,
  "currency": "USD",
  "merchant": "Target",
  "merchantDomain": "www.target.com",
  "reviewCount": 4000,
  "landingPage": "https://www.target.com/...",
  "country": "US",
  "language": "en",
  "scrapedAt": "2026-05-18T22:42:56.958Z"
}
````

### Pricing

This actor uses pay-per-event pricing.

- Actor start: `$0.001` per run.
- Shopping ad scraped: `$14.00 per 1,000 saved ad rows`.

You pay for saved Shopping ad rows, not for empty searches.

### Notes And Limits

Google Shopping ad inventory changes often. A keyword may show 20 ads now and fewer ads later. Results can also change by market, language, device, and time of day.

If a run returns no rows, try a more product-focused keyword, a larger market such as `US`, or a desktop run.

### FAQ

#### Does this scrape Google Ads Transparency Center?

No. This actor scrapes live paid Shopping product listings from Google Search. Google Ads Transparency Center is a different source and a different use case.

#### Does this scrape organic Google Shopping results?

No. The actor is built for paid Shopping ads shown on the main Google Search results page.

#### Do I need Google login, cookies, or an API key?

No. You only need your Apify account.

#### Can I schedule it?

Yes. Use Apify schedules to run the same keyword list daily, weekly, or monthly. This is useful for price and ad tracking.

#### Why did a keyword return no ads?

Google may not show Shopping ads for that query, market, device, or moment. Try a more buyer-focused product keyword or run it again later.

### Support

Have a bug or feature request? Open an issue from the actor page in Apify Console.

# Actor input Schema

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

Enter product or category searches that can show Shopping ads. Good examples: wireless headphones, running shoes, coffee maker.

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

Choose the Google market to check. The same keyword can show different Shopping ads in different countries.

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

Choose the Google page language for the run.

## `devices` (type: `array`):

Pick the result page type. Desktop is the safest first run. Mobile can show different ads, but may return fewer rows.

## `maxAdsPerQuery` (type: `integer`):

Maximum Shopping ads to save for each keyword and device.

## `maxTotalAds` (type: `integer`):

Optional cap for the whole run. Leave empty to use the per-keyword and device limit only.

## `deduplicateResults` (type: `boolean`):

Skip the same product, merchant, landing page, price, market, and device when it appears again in the same run.

## Actor input object example

```json
{
  "searchQueries": [
    "wireless headphones"
  ],
  "country": "US",
  "language": "en",
  "devices": [
    "mobile",
    "desktop"
  ],
  "maxAdsPerQuery": 25,
  "deduplicateResults": true
}
```

# Actor output Schema

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

Open the dataset with Google Shopping ad products, prices, merchants, landing pages, markets, devices, and ranks.

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

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

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Google Shopping Ads Scraper",
        "description": "Get live paid Google Shopping ads from Google Search. Export product titles, prices, merchants, landing pages, ranks, and market data for your keyword list.",
        "version": "0.0",
        "x-build-id": "WRwF0dTkQ0PMfhQGG"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/maximedupre~google-shopping-ads-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-maximedupre-google-shopping-ads-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/maximedupre~google-shopping-ads-scraper/runs": {
            "post": {
                "operationId": "runs-sync-maximedupre-google-shopping-ads-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/maximedupre~google-shopping-ads-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-maximedupre-google-shopping-ads-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"
                ],
                "properties": {
                    "searchQueries": {
                        "title": "Search keywords",
                        "minItems": 1,
                        "maxItems": 500,
                        "type": "array",
                        "description": "Enter product or category searches that can show Shopping ads. Good examples: wireless headphones, running shoes, coffee maker.",
                        "items": {
                            "type": "string",
                            "minLength": 1
                        }
                    },
                    "country": {
                        "title": "Market",
                        "enum": [
                            "US",
                            "CA",
                            "GB",
                            "AU",
                            "DE",
                            "FR",
                            "ES",
                            "IT",
                            "NL",
                            "JP",
                            "BR",
                            "MX"
                        ],
                        "type": "string",
                        "description": "Choose the Google market to check. The same keyword can show different Shopping ads in different countries.",
                        "default": "US"
                    },
                    "language": {
                        "title": "Language",
                        "enum": [
                            "en",
                            "de",
                            "fr",
                            "es",
                            "it",
                            "nl",
                            "ja",
                            "pt"
                        ],
                        "type": "string",
                        "description": "Choose the Google page language for the run.",
                        "default": "en"
                    },
                    "devices": {
                        "title": "Devices",
                        "minItems": 1,
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Pick the result page type. Desktop is the safest first run. Mobile can show different ads, but may return fewer rows.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "mobile",
                                "desktop"
                            ],
                            "enumTitles": [
                                "Mobile",
                                "Desktop"
                            ]
                        },
                        "default": [
                            "mobile",
                            "desktop"
                        ]
                    },
                    "maxAdsPerQuery": {
                        "title": "Ad limit per keyword and device",
                        "minimum": 1,
                        "maximum": 200,
                        "type": "integer",
                        "description": "Maximum Shopping ads to save for each keyword and device.",
                        "default": 25
                    },
                    "maxTotalAds": {
                        "title": "Total ad limit",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Optional cap for the whole run. Leave empty to use the per-keyword and device limit only."
                    },
                    "deduplicateResults": {
                        "title": "Deduplicate repeated ads",
                        "type": "boolean",
                        "description": "Skip the same product, merchant, landing page, price, market, and device when it appears again in the same run.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
