# Google Ads Transparency Scraper (`automly/google-ads-transparency-scraper`) Actor

Scrape Google Ads Transparency Center for competitor ad creatives, advertiser IDs, ad archive data, preview URLs, regions, and first/last shown dates.

- **URL**: https://apify.com/automly/google-ads-transparency-scraper.md
- **Developed by:** [Automly](https://apify.com/automly) (community)
- **Categories:** SEO tools, Lead generation, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.99 / 1,000 results

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 Transparency Scraper

Google Ads Transparency Scraper extracts public ad creatives from the Google Ads Transparency Center so you can research competitor ads, monitor PPC campaigns, analyze brand messaging, and build a searchable Google ad library from advertiser names, domains, advertiser IDs, or Transparency Center URLs.

Use this actor when you need structured Google Ads Transparency Center data in JSON, CSV, Excel, or API workflows without manually clicking through advertiser pages.

### Why use this Google Ads Transparency Center scraper?

Google's Ads Transparency Center is useful for competitor research, but it is slow to review manually. This actor turns public advertiser pages and ad creatives into clean dataset rows that are easy to filter, export, enrich, and track over time.

Common searches this actor is designed for:

- Google Ads Transparency scraper
- Google Ads Transparency Center scraper
- Google Ads competitor ads scraper
- Google ad library scraper
- Google ads creative scraper
- PPC competitor research tool
- Advertiser ad archive scraper
- Google ad intelligence dataset

### What you can scrape

- Advertiser search results by brand name, website, domain, or keyword
- Google Ads Transparency advertiser IDs
- Public ad creative IDs
- Google Ads Transparency creative URLs
- Advertiser name, country, and verification status
- Estimated advertiser ad volume ranges when available
- First shown and last shown dates
- Creative preview URLs
- Image ad preview URLs
- Script/display creative preview URLs
- Region/country filters
- Raw creative fragments, optionally, for custom internal analysis

### Popular use cases

#### Competitor ad research
Find which ads competitors are running on Google, how many creatives they have, and when those creatives were first or last shown.

#### PPC and paid media audits
Export Google ad creatives for clients, competitors, or target accounts into CSV/JSON for agency reports and internal review.

#### Ecommerce ad monitoring
Track ad creative changes for ecommerce brands, product campaigns, seasonal promotions, and landing page tests.

#### SaaS and B2B market intelligence
Research positioning, messaging, offers, and ad volume for SaaS companies, B2B tools, and high-intent advertisers.

#### Build an internal ad library
Create a searchable Google ad archive for your team by collecting advertiser names, creative IDs, image previews, and date ranges.

### Key features

- Search by advertiser name, brand keyword, or domain
- Use direct Google Ads Transparency advertiser IDs
- Use Google Ads Transparency Center URLs as input
- Scrape up to thousands of ad creative records per advertiser
- Supports country/region filters such as `US`, `GB`, `CA`, `AU`, `DE`, `FR`, and `JP`
- Exports clean JSON/CSV-ready rows
- Optional Apify Proxy support
- Structured run summary with record counts and failures
- Tested on high-volume advertisers such as Nike and Adidas

### Input example: search by competitor brand

```json
{
  "queries": ["nike"],
  "regions": ["US"],
  "maxAdvertisersPerQuery": 1,
  "maxAdsPerAdvertiser": 2000,
  "includeHtmlCreative": false,
  "includeRawData": false,
  "useApifyProxy": true,
  "proxyGroups": []
}
````

### Input example: direct advertiser ID

```json
{
  "queries": [],
  "advertiserIds": ["AR16735076323512287233"],
  "regions": ["US"],
  "maxAdsPerAdvertiser": 1000,
  "includeHtmlCreative": false,
  "includeRawData": false,
  "useApifyProxy": false,
  "proxyGroups": []
}
```

### Input fields

- `queries`: Brand names, domains, websites, or keywords to search in Google Ads Transparency Center. Examples: `nike`, `adidas.com`, `notion`.
- `advertiserIds`: Direct Google Ads Transparency advertiser IDs, for example `AR16735076323512287233`.
- `transparencyUrls`: Google Ads Transparency Center advertiser URLs. The actor extracts advertiser IDs automatically.
- `regions`: ISO country codes to query, such as `US`, `GB`, `CA`, `AU`, `DE`, `FR`, `JP`.
- `maxAdsPerAdvertiser`: Maximum ad creative records to export per advertiser.
- `maxAdvertisersPerQuery`: Maximum advertiser matches to process for each search query.
- `includeRawData`: Include raw source fragments for advanced custom analysis.
- `includeHtmlCreative`: Include creative HTML/script snippets when available.
- `useApifyProxy`: Use Apify Proxy when available.
- `proxyGroups`: Optional Apify Proxy groups. Leave empty for the default datacenter pool.

### Output example

```json
{
  "query": "nike",
  "advertiserId": "AR16735076323512287233",
  "advertiserName": "Nike, Inc.",
  "advertiserLocation": "US",
  "advertiserVerified": true,
  "estimatedAdsLower": 10000,
  "estimatedAdsUpper": 20000,
  "adId": "CR10275134769444421633",
  "adTransparencyUrl": "https://adstransparency.google.com/advertiser/AR16735076323512287233/creative/CR10275134769444421633",
  "adFormat": "image",
  "platforms": [],
  "regions": ["US"],
  "firstShownAt": "2026-02-20T00:32:11+00:00",
  "lastShownAt": "2026-06-24T17:13:39+00:00",
  "creativePreviewUrl": "https://tpc.googlesyndication.com/archive/simgad/...",
  "imageUrls": ["https://tpc.googlesyndication.com/archive/simgad/..."],
  "videoUrls": [],
  "thumbnailUrls": ["https://tpc.googlesyndication.com/archive/simgad/..."],
  "landingPageUrl": null,
  "headline": null,
  "bodyText": null,
  "scrapedAt": "2026-06-24T17:36:01.688561+00:00"
}
```

### Output fields

- `query`: Original search query or input source.
- `advertiserId`: Google Ads Transparency advertiser ID.
- `advertiserName`: Advertiser name.
- `advertiserLocation`: Advertiser country/location when available.
- `advertiserVerified`: Whether Google marks the advertiser as verified.
- `estimatedAdsLower` / `estimatedAdsUpper`: Approximate ad volume range when available.
- `adId`: Google Ads Transparency creative ID.
- `adTransparencyUrl`: Direct URL to the public creative page.
- `adFormat`: Inferred ad format, such as image or script/display creative.
- `regions`: Regions used for the query.
- `firstShownAt`: First observed date/time for the ad creative.
- `lastShownAt`: Last observed date/time for the ad creative.
- `creativePreviewUrl`: Preview or media URL when available.
- `imageUrls`: Image creative preview URLs when available.
- `videoUrls`: Video URLs when available.
- `thumbnailUrls`: Thumbnail/preview URLs when available.
- `landingPageUrl`: Landing page URL when exposed by public data.
- `headline`: Ad headline when exposed by public data.
- `bodyText`: Ad body text when exposed by public data.
- `scrapedAt`: Time the record was collected.

### Tips for better results

- Start with a brand name or domain, such as `nike`, `adidas`, `shopify`, or `notion`.
- Use `maxAdvertisersPerQuery: 1` when you only want the best matching advertiser.
- Increase `maxAdsPerAdvertiser` for large brands with thousands of ads.
- Use direct `advertiserIds` when you already know the exact Google Ads Transparency advertiser.
- Use regions to compare country-specific advertiser activity.

### Notes and limitations

- This actor extracts public data from Google's Ads Transparency Center.
- Some advertisers have limited public data or no active ads for a selected region.
- Some creative detail fields are not available for every ad.
- Landing page URLs, headlines, and body text are included only when exposed in public creative data.
- Media files are not downloaded; the actor exports preview/media URLs when available.
- Very broad advertisers can have thousands of ads; use `maxAdsPerAdvertiser` to control run size.

### Pricing

This private build currently has no pricing configured. If published later, the natural paid unit is one exported Google ad creative record.

### FAQ

#### Is this a Google Ads Transparency Center scraper?

Yes. It is built to export structured advertiser and creative records from the public Google Ads Transparency Center.

#### Can I scrape competitor Google ads?

Yes. Enter a competitor brand, advertiser name, or domain in `queries` to find advertiser matches and export their public Google ad creatives.

#### Can I search by domain?

Yes. Add a domain such as `nike.com`, `adidas.com`, or `shopify.com` to `queries`.

#### Can I use a known advertiser ID?

Yes. Add advertiser IDs such as `AR16735076323512287233` to `advertiserIds`.

#### Can I export the data to CSV or Excel?

Yes. Apify datasets can be downloaded as JSON, CSV, Excel, XML, RSS, or HTML.

#### Does it download media files?

No. It exports media, image, thumbnail, and preview URLs when they are available.

#### Does it include ad copy and landing pages?

Only when those fields are exposed in the public creative data. Many records provide creative IDs, preview assets, and dates but not full ad copy or landing page URLs.

#### Can it scrape thousands of ads?

Yes. It has been verified with high-volume runs, including 1,000 and 2,000 unique ad records from major advertisers.

# Actor input Schema

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

Brand names, domains, or keywords to search in Google Ads Transparency Center.

## `advertiserIds` (type: `array`):

Direct Google Ads Transparency advertiser IDs, for example AR14017378248766259201.

## `transparencyUrls` (type: `array`):

Google Ads Transparency Center advertiser URLs. Advertiser IDs are extracted from these URLs.

## `regions` (type: `array`):

ISO country codes to query. Currently common countries are mapped directly; unsupported codes fall back to US.

## `maxAdsPerAdvertiser` (type: `integer`):

Maximum ad creative records to export per advertiser.

## `maxAdvertisersPerQuery` (type: `integer`):

Maximum advertiser suggestions to process for each search query.

## `includeRawData` (type: `boolean`):

Include raw Google response fragments for debugging and custom parsing.

## `includeHtmlCreative` (type: `boolean`):

Include sanitized HTML creative snippet when Google returns one.

## `useApifyProxy` (type: `boolean`):

Use the Apify Proxy if proxy credentials are available in the run environment.

## `proxyGroups` (type: `array`):

Optional Apify Proxy groups. Leave empty for default/datacenter proxy pool.

## Actor input object example

```json
{
  "queries": [
    "adidas"
  ],
  "advertiserIds": [],
  "transparencyUrls": [],
  "regions": [
    "US"
  ],
  "maxAdsPerAdvertiser": 100,
  "maxAdvertisersPerQuery": 3,
  "includeRawData": false,
  "includeHtmlCreative": true,
  "useApifyProxy": false,
  "proxyGroups": []
}
```

# Actor output Schema

## `records` (type: `string`):

All Google Ads Transparency creative records produced by this run.

## `overview` (type: `string`):

Dataset presented using the dataset schema overview view.

# 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 = {};

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

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Google Ads Transparency Scraper",
        "description": "Scrape Google Ads Transparency Center for competitor ad creatives, advertiser IDs, ad archive data, preview URLs, regions, and first/last shown dates.",
        "version": "1.0",
        "x-build-id": "8PWCavDRZEMbWKNvt"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automly~google-ads-transparency-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automly-google-ads-transparency-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/automly~google-ads-transparency-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automly-google-ads-transparency-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/automly~google-ads-transparency-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automly-google-ads-transparency-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",
                "properties": {
                    "queries": {
                        "title": "Advertiser search queries",
                        "type": "array",
                        "description": "Brand names, domains, or keywords to search in Google Ads Transparency Center.",
                        "default": [
                            "adidas"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "advertiserIds": {
                        "title": "Advertiser IDs",
                        "type": "array",
                        "description": "Direct Google Ads Transparency advertiser IDs, for example AR14017378248766259201.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "transparencyUrls": {
                        "title": "Transparency URLs",
                        "type": "array",
                        "description": "Google Ads Transparency Center advertiser URLs. Advertiser IDs are extracted from these URLs.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "regions": {
                        "title": "Regions",
                        "type": "array",
                        "description": "ISO country codes to query. Currently common countries are mapped directly; unsupported codes fall back to US.",
                        "default": [
                            "US"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxAdsPerAdvertiser": {
                        "title": "Max ads per advertiser",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Maximum ad creative records to export per advertiser.",
                        "default": 100
                    },
                    "maxAdvertisersPerQuery": {
                        "title": "Max advertisers per query",
                        "minimum": 1,
                        "maximum": 20,
                        "type": "integer",
                        "description": "Maximum advertiser suggestions to process for each search query.",
                        "default": 3
                    },
                    "includeRawData": {
                        "title": "Include raw data",
                        "type": "boolean",
                        "description": "Include raw Google response fragments for debugging and custom parsing.",
                        "default": false
                    },
                    "includeHtmlCreative": {
                        "title": "Include HTML creative",
                        "type": "boolean",
                        "description": "Include sanitized HTML creative snippet when Google returns one.",
                        "default": true
                    },
                    "useApifyProxy": {
                        "title": "Use Apify Proxy",
                        "type": "boolean",
                        "description": "Use the Apify Proxy if proxy credentials are available in the run environment.",
                        "default": false
                    },
                    "proxyGroups": {
                        "title": "Proxy groups",
                        "type": "array",
                        "description": "Optional Apify Proxy groups. Leave empty for default/datacenter proxy pool.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```