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

Scrape Google Ads Transparency Center creatives from domains, keywords, advertiser IDs, or URLs. Export dates, formats, media URLs, copy, targeting, impressions, and platform filters for competitor research.

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

## Pricing

from $0.70 / 1,000 scraped ads

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 Ads scraper for Transparency Center creatives

Google Ads Scraper extracts public ad creatives from the [Google Ads Transparency Center](https://adstransparency.google.com/). Add a domain, keyword, advertiser ID, creative ID, or Google Ads Transparency Center URL, then export advertiser IDs, creative IDs, formats, first and last shown dates, media URLs, source URLs, and optional full ad details.

Use it for competitor ad monitoring, PPC research, creative libraries, agency reporting, and recurring checks on brands or advertiser IDs. The Actor is built for the public Transparency Center archive, so you do not need a Google Ads account, Google login, cookies, or a user-provided API key.

For a representative first run, keep the default `nike.com` target, region `US`, and `Data to return` set to `Base rows`. Lower `Maximum ads` for a smaller test run, or switch to `Full ad details` when you need ad copy, media arrays, variants, targeting, impression ranges, and region or platform breakdowns when Google exposes them.

### ✅ What this Actor does

- Searches Google Ads Transparency Center by domain, keyword, advertiser ID, creative ID, source search URL, advertiser URL, or direct creative URL.
- Saves one dataset item per matched ad creative.
- Returns base monitoring fields by default: advertiser identity, creative identity, format, dates shown, days shown, source URL, and media or preview URLs when available.
- Can enrich each creative with source-extractable copy, image URLs, video URLs, variants, targeting flags, impression bounds, region stats, and platform stats when available.
- Supports filters for region, Google platform, ad format, date range, and maximum ads.
- Supports Google Search, YouTube, Google Shopping, Google Maps, and Google Play platform filters.
- Can optionally save ad images and videos to Apify storage. This is off by default, so normal runs keep source media URLs only.
- Works with Apify dataset exports, API access, schedules, webhooks, and integrations.

This Actor scrapes public ad data. It does not access private Google Ads account metrics, campaign spend, bids, clicks, conversion data, audience lists, account settings, or Merchant Center feeds.

### 📦 Data you can export

Each dataset item represents one Google Ads creative. Base rows and full-detail rows use the same shape, so downstream systems can read one stable schema.

Common fields include:

- `submittedTarget`
- `advertiserId`
- `advertiserName`
- `advertiserLegalName`
- `advertiserRegionCode`
- `creativeId`
- `format`
- `adUrl`
- `creativePreviewUrl`
- `firstShown`
- `lastShown`
- `totalDaysShown`
- `headline`
- `body`
- `displayUrl`
- `destinationUrl`
- `imageUrls`
- `videoUrls`
- `storedMedia`
- `impressions`
- `targeting`
- `regionStats`
- `platformStats`
- `variants`

Some fields can be `null` or an empty array because Google does not expose every detail for every ad. The Actor keeps those values empty instead of inventing data.

### 🎯 Common use cases

- Monitor competitor ads by domain or advertiser ID.
- Build a searchable archive of ad creatives and media URLs.
- Track when new ads first appear and when old ads stop showing.
- Compare creative formats across Search, YouTube, Shopping, Maps, and Play.
- Export ad rows to spreadsheets, BI tools, CRM workflows, or internal dashboards.
- Feed clean creative rows into your own scoring, alerting, or reporting system.
- Refresh details for a known creative from an advertiser ID and creative ID pair.

### ▶️ How to run it

1. Add one or more values in **Targets**. You can use domains such as `nike.com`, keywords, advertiser IDs, creative IDs with advertiser IDs, or Google Ads Transparency Center URLs.
2. Set **Maximum ads** to cap the total number of saved rows across all targets.
3. Choose a **Region** or leave it worldwide.
4. Optionally choose a **Platform**, **Ad format**, **Start date**, or **End date**.
5. Keep **Data to return** set to **Base rows** for broad monitoring, or switch to **Full ad details** when you need copy, media, targeting, impressions, and variants.
6. Leave **Save media files** off unless you need Apify-hosted copies of images or videos.
7. Run the Actor and export the dataset as JSON, CSV, Excel, XML, RSS, HTML, or through the Apify API.

### ⚙️ Input options

**Targets** is the only required input. Accepted values include:

```json
[
  "nike.com",
  "AR16735076323512287233",
  "AR16735076323512287233 CR03144551174665928705",
  "https://adstransparency.google.com/?region=US&domain=nike.com"
]
````

**Maximum ads** limits the number of creative rows saved across the whole run.

**Region** filters ads by where Google reports they were shown. The default is `US`, and worldwide is also available.

**Platform** filters the source results to all platforms, Google Search, YouTube, Google Shopping, Google Maps, or Google Play.

**Ad format** filters results to text, image, video, or shopping formats when the source distinguishes them.

**Start date** and **End date** keep ads whose shown date range overlaps your selected window.

**Data to return** controls cost and detail. Base rows are cheaper and faster for monitoring. Full ad details add an extra enrichment charge per creative.

**Save media files** stores discovered ad images and videos in Apify storage and returns stored links in `storedMedia`. Keep it off when source URLs are enough.

### 🧾 Output example

```json
{
  "submittedTarget": "nike.com",
  "advertiserId": "AR16735076323512287233",
  "advertiserName": "Nike, Inc.",
  "advertiserLegalName": "Nike, Inc.",
  "advertiserRegionCode": "US",
  "creativeId": "CR06922336513384513537",
  "format": "video",
  "adUrl": "https://adstransparency.google.com/advertiser/AR16735076323512287233/creative/CR06922336513384513537",
  "creativePreviewUrl": "https://displayads-formats.googleusercontent.com/ads/preview/content.html",
  "firstShown": "2026-04-10",
  "lastShown": "2026-06-17",
  "totalDaysShown": 69,
  "headline": "Nike summer running shoes",
  "body": "Built for warm-weather miles.",
  "displayUrl": "nike.com",
  "destinationUrl": "https://www.nike.com/running",
  "imageUrls": ["https://tpc.googlesyndication.com/archive/simgad/123456789"],
  "videoUrls": ["https://www.youtube.com/embed/example"],
  "storedMedia": [],
  "impressions": {
    "lowerBound": 1000,
    "upperBound": 2000
  },
  "targeting": null,
  "regionStats": [],
  "platformStats": [],
  "variants": []
}
```

### 💸 Pricing

This Actor uses pay-per-event pricing.

- **Scraped ad**: charged for each Google Ads creative saved to the dataset.
- **Added ad detail**: charged only when **Data to return** is set to **Full ad details** and enrichment is added for a creative.

Base rows are meant for broad, low-cost monitoring. Full details are best when you need deeper analysis fields such as copy, media arrays, targeting, impressions, and variants.

### ⚠️ Limits and caveats

Google Ads Transparency Center does not expose every field for every creative. Text copy, destination URLs, impression bounds, targeting, region stats, platform stats, and media links can be missing on some ads.

Media URLs can expire or change. Keep the advertiser ID, creative ID, and ad URL from each row so you can re-run the Actor later and refresh the details. Enable **Save media files** only when you need Apify-hosted files from the current run.

Platform and format filters use Google Ads Transparency Center's public source filters. If Google returns no rows for a narrow filter combination, the run can finish successfully with no ads found.

### ❓ FAQ

**Do I need a Google Ads account?**

No. The Actor works with public Google Ads Transparency Center data and does not need a Google Ads account, cookies, or a Google API key.

**Can I search by advertiser ID?**

Yes. Add an advertiser ID such as `AR16735076323512287233` to **Targets**. You can also add a direct creative target when you know both advertiser ID and creative ID.

**What is the difference between base rows and full ad details?**

Base rows return monitoring fields such as IDs, advertiser name, format, shown dates, source URL, and preview or media URLs when available. Full ad details also try to add source-extractable copy, richer media arrays, variants, targeting, impressions, and region or platform stats.

**Are media files saved by default?**

No. By default, the Actor returns source media URLs. Turn on **Save media files** only when you want images or videos stored in Apify storage for the run.

**Can it scrape live Google Search ads?**

No. This Actor scrapes the Google Ads Transparency Center archive. For live Shopping ads on Google Search result pages, use Google Shopping Ads Scraper from the related actors below.

### 📝 Changelog

- 0.1: Initial release.

### 🆘 Support

For issues, questions, or feature requests, [file a ticket](https://console.apify.com/actors/maximedupre~google-ads-scraper/issues) and I'll fix or implement it in less than 24h 🫡

### 🔗 Other actors

- [Google Shopping Ads Scraper ↗](https://apify.com/maximedupre/google-shopping-ads-scraper) - Scrape live paid Shopping ads from Google Search results.
- [Google Play Store Scraper ↗](https://apify.com/maximedupre/google-play-store-scraper) - Extract app listings, ratings, installs, developers, and store metadata.
- [YouTube Channel Search Scraper ↗](https://apify.com/maximedupre/youtube-channel-search-scraper) - Find public YouTube channels from search keywords for creator and competitor research.
- [Web Images Scraper ↗](https://apify.com/maximedupre/web-images-scraper) - Extract image URLs and optional saved image files from public webpages.
- [Website URL Crawler ↗](https://apify.com/maximedupre/website-url-crawler) - Crawl rendered websites and export discovered links for audits and monitoring.

**Made with ❤️ by Maxime Dupré**

# Actor input Schema

## `targets` (type: `array`):

Enter domains, keywords, advertiser IDs, creative IDs, or Google Ads Transparency Center URLs.

## `maxResults` (type: `integer`):

Limit the number of ad rows returned across all targets.

## `region` (type: `string`):

Filter ads shown in a country or use worldwide results.

## `platform` (type: `string`):

Collect ads from all Google platforms or one platform.

## `adFormat` (type: `string`):

Collect all formats or focus on one creative format.

## `dateFrom` (type: `string`):

Return ads shown on or after this date.

## `dateTo` (type: `string`):

Return ads shown on or before this date.

## `detailLevel` (type: `string`):

Choose base monitoring rows or full ad details with copy, media, targeting, and impression fields.

## `downloadMedia` (type: `boolean`):

Store ad images and videos in Apify storage and return stored asset links.

## Actor input object example

```json
{
  "targets": [
    "nike.com"
  ],
  "maxResults": 1000,
  "region": "US",
  "platform": "",
  "adFormat": "",
  "detailLevel": "base",
  "downloadMedia": false
}
```

# Actor output Schema

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

Dataset of Google Ads creative rows. Base rows include advertiser IDs, creative IDs, dates, formats, and source URLs. Full-detail rows also include copy, media arrays, variants, targeting, and impression data when available.

# 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 = {
    "targets": [
        "nike.com"
    ],
    "maxResults": 1000,
    "region": "US"
};

// Run the Actor and wait for it to finish
const run = await client.actor("maximedupre/google-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 = {
    "targets": ["nike.com"],
    "maxResults": 1000,
    "region": "US",
}

# Run the Actor and wait for it to finish
run = client.actor("maximedupre/google-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 '{
  "targets": [
    "nike.com"
  ],
  "maxResults": 1000,
  "region": "US"
}' |
apify call maximedupre/google-ads-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Google Ads Scraper",
        "description": "Scrape Google Ads Transparency Center creatives from domains, keywords, advertiser IDs, or URLs. Export dates, formats, media URLs, copy, targeting, impressions, and platform filters for competitor research.",
        "version": "0.1",
        "x-build-id": "r3ES4obD1TnDibTp6"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/maximedupre~google-ads-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-maximedupre-google-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-ads-scraper/runs": {
            "post": {
                "operationId": "runs-sync-maximedupre-google-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-ads-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-maximedupre-google-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": [
                    "targets"
                ],
                "properties": {
                    "targets": {
                        "title": "Targets",
                        "type": "array",
                        "description": "Enter domains, keywords, advertiser IDs, creative IDs, or Google Ads Transparency Center URLs.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxResults": {
                        "title": "Maximum ads",
                        "minimum": 1,
                        "maximum": 2500,
                        "type": "integer",
                        "description": "Limit the number of ad rows returned across all targets.",
                        "default": 1000
                    },
                    "region": {
                        "title": "Region",
                        "type": "string",
                        "description": "Filter ads shown in a country or use worldwide results.",
                        "default": "US"
                    },
                    "platform": {
                        "title": "Platform",
                        "enum": [
                            "",
                            "google_search",
                            "youtube",
                            "google_shopping",
                            "google_maps",
                            "google_play"
                        ],
                        "type": "string",
                        "description": "Collect ads from all Google platforms or one platform.",
                        "default": ""
                    },
                    "adFormat": {
                        "title": "Ad format",
                        "enum": [
                            "",
                            "text",
                            "image",
                            "video",
                            "shopping"
                        ],
                        "type": "string",
                        "description": "Collect all formats or focus on one creative format.",
                        "default": ""
                    },
                    "dateFrom": {
                        "title": "Start date",
                        "pattern": "^(\\d{4})-(0[1-9]|1[0-2])-(0[1-9]|[12]\\d|3[01])$",
                        "type": "string",
                        "description": "Return ads shown on or after this date."
                    },
                    "dateTo": {
                        "title": "End date",
                        "pattern": "^(\\d{4})-(0[1-9]|1[0-2])-(0[1-9]|[12]\\d|3[01])$",
                        "type": "string",
                        "description": "Return ads shown on or before this date."
                    },
                    "detailLevel": {
                        "title": "Data to return",
                        "enum": [
                            "base",
                            "details"
                        ],
                        "type": "string",
                        "description": "Choose base monitoring rows or full ad details with copy, media, targeting, and impression fields.",
                        "default": "base"
                    },
                    "downloadMedia": {
                        "title": "Save media files",
                        "type": "boolean",
                        "description": "Store ad images and videos in Apify storage and return stored asset links.",
                        "default": false
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```