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

Extract public Google advertiser creatives with advertiser IDs, creative IDs, first and last shown dates, formats, preview assets, and available ad text.

- **URL**: https://apify.com/trovevault/google-ads-transparency-scraper.md
- **Developed by:** [Trove Vault](https://apify.com/trovevault) (community)
- **Categories:** E-commerce, SEO tools, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.85 / 1,000 ads

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

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

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

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

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

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

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

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

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

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

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


# README

## Google Ads Transparency Scraper

Extract public advertiser creatives from the Google Ads Transparency Center for competitor monitoring, ad research, and campaign tracking. The actor resolves advertiser names, websites, or Google advertiser IDs, then returns creative rows with advertiser details, creative IDs, first and last shown dates, format, preview links, assets, and available ad text.

Use it when you want repeatable Google ads data for brands such as Nike, Shopify, Temu, or a client competitor list without manual Ads Transparency Center searches.

### Why use Google Ads Transparency Scraper?

- Monitor new and recently shown Google ads by advertiser.
- Build competitor creative swipe files from public ad previews.
- Track first shown and last shown dates across recurring runs.
- Collect stable advertiser and creative IDs for deduplication.
- Export image/display assets and product-style creative text when the preview exposes it.
- Feed ad intelligence dashboards, agency reports, or downstream analyzers.

### What data does Google Ads Transparency Scraper extract?

For each public creative found, the actor can return:

| Field group | Fields |
|---|---|
| Search context | `target`, `country`, `countryName`, `runId` |
| Advertiser identity | `advertiserName`, `advertiserCountry`, `advertiserId` |
| Creative identity | `creativeId`, `format`, `adDetailsUrl` |
| Timing | `firstShownDate`, `lastShownDate` |
| Assets | `assetUrl`, `imageUrl`, `imageUrls`, `previewUrl` |
| Copy | `headline`, `description`, `callToAction`, `creativeText` |
| Variations | `variationCount`, `variations` with preview, image, and text fields |

The actor uses public web endpoints behind the Ads Transparency Center. It does not require a Google login for the tested public advertiser search path.

### Who uses Google Ads Transparency Scraper?

**PPC and growth teams** can monitor competing advertisers and export current display or shopping-style creative examples.

**Agencies** can run scheduled competitor checks for client reports and compare which advertisers are still active over time.

**E-commerce teams** can inspect product-oriented ads, asset URLs, and first/last shown dates for brands in the same category.

**Researchers and journalists** can build public ad datasets by advertiser and country, with direct ad detail links for review.

### What input does Google Ads Transparency Scraper accept?

```json
{
  "targets": ["Nike", "nike.com", "AR16735076323512287233"],
  "country": "US",
  "maxAds": 40,
  "shownSince": "2026-07-01",
  "firstShownAfter": "2026-01-01"
}
````

| Input | Required | Description |
|---|---:|---|
| `targets` | Yes | Advertiser names, website domains, or Google advertiser IDs. Examples: `Nike`, `nike.com`, `AR16735076323512287233`. Names and domains are resolved to the most likely advertiser in the selected country. |
| `country` | Yes | ISO-style country selector for the public ad library region. Supported values: `US`, `CA`, `GB`, `AU`, `BR`, `DE`, `ES`, `FR`, `IT`, `NL`, `PT`. Default: `US`. |
| `maxAds` | No | Maximum creatives to return per target. Use small values for quick checks and larger values for deep monitoring. Default: `40`; maximum: `1000`. |
| `shownSince` | No | Keep ads last shown on or after this `YYYY-MM-DD` date. Leave empty to keep all returned last-shown dates. |
| `firstShownAfter` | No | Keep ads first shown on or after this `YYYY-MM-DD` date. Leave empty to keep all returned first-shown dates. |
| `datasetId` | No | Existing Apify dataset ID for pipeline runs. When provided, rows are appended there in addition to the default run dataset. |
| `runId` | No | External workflow ID copied to output rows and `RUN_SUMMARY` for joins across scheduled runs. |

### What output does Google Ads Transparency Scraper return?

Example row:

```json
{
  "target": "Nike",
  "country": "US",
  "advertiserName": "Nike, Inc.",
  "advertiserCountry": "US",
  "advertiserId": "AR16735076323512287233",
  "creativeId": "CR17388216613009883137",
  "format": "Graphic",
  "firstShownDate": "2026-04-28",
  "lastShownDate": "2026-07-14",
  "adDetailsUrl": "https://adstransparency.google.com/advertiser/AR16735076323512287233/creative/CR17388216613009883137?region=US",
  "imageUrl": "https://encrypted-tbn2.gstatic.com/shopping?q=tbn:...",
  "imageUrls": ["https://encrypted-tbn2.gstatic.com/shopping?q=tbn:..."],
  "previewUrl": "https://displayads-formats.googleusercontent.com/ads/preview/content.js?...",
  "headline": "Nike Men's Air Force 1 Flyknit 2.0 Shoes in Black, Size: 10.5 | AV3042-001",
  "creativeText": "Nike Men's Air Force 1 Flyknit 2.0 Shoes in Black, Size: 10.5 | AV3042-001",
  "variationCount": 3,
  "variations": [
    {
      "variationIndex": 1,
      "previewUrl": "https://displayads-formats.googleusercontent.com/ads/preview/content.js?...",
      "imageUrl": "https://encrypted-tbn2.gstatic.com/shopping?q=tbn:...",
      "headline": "Nike Men's Air Force 1 Flyknit 2.0 Shoes in Black, Size: 10.5 | AV3042-001"
    }
  ]
}
```

Image creatives often include `assetUrl`, `imageUrl`, or `imageUrls`. Product or dynamic creatives can include `headline`, `description`, `callToAction`, `creativeText`, and `variations`. If the public preview does not expose readable copy, the actor omits those fields rather than guessing.

### How do I run Google Ads Transparency Scraper?

1. Add one or more advertiser names, domains, or advertiser IDs.
2. Choose a country.
3. Set `maxAds` based on how deep you want the run to go.
4. Optionally add date filters for monitoring new or recently shown ads.
5. Run the actor and download the dataset as JSON, CSV, Excel, or through the Apify API.

### How can I use Google Ads Transparency Scraper through the API?

```bash
curl "https://api.apify.com/v2/acts/YOUR_USERNAME~google-ads-transparency-scraper/runs" \
  -X POST \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $APIFY_TOKEN" \
  -d '{
    "targets": ["Nike"],
    "country": "US",
    "maxAds": 40
  }'
```

Fetch dataset items:

```bash
curl "https://api.apify.com/v2/datasets/DATASET_ID/items?clean=true" \
  -H "Authorization: Bearer $APIFY_TOKEN"
```

### How can I monitor advertisers over time?

For recurring monitoring, schedule the actor daily or weekly with the same targets. Use `advertiserId` and `creativeId` to deduplicate rows in your warehouse. Use `firstShownDate` and `lastShownDate` to identify fresh or still-active creatives.

### What are the limits of Google Ads Transparency Scraper?

- The actor returns data visible through the public Ads Transparency Center path tested for advertiser search.
- It does not claim complete global ad coverage.
- It does not return spend, impressions, targeting criteria, keywords, or auction data unless those fields become publicly exposed.
- Creative copy is best-effort. Image-only previews may only expose image assets.
- Google can change internal public endpoints or payload shapes. The actor records failures in `RUN_SUMMARY` rather than inventing rows.
- Very large advertisers can have thousands of public ads; use `maxAds` to control run size and cost.

### How do I troubleshoot Google Ads Transparency Scraper?

| Issue | Likely cause | Solution |
|---|---|---|
| The actor picked the wrong advertiser | A broad brand name matched another advertiser in the selected country | Use a website domain or a known Google advertiser ID such as `AR16735076323512287233`. |
| No rows were returned | The advertiser has no public ads in that country, or date filters removed all rows | Try the advertiser ID, change `country`, or remove `shownSince` and `firstShownAfter`. |
| Some rows do not have creative text | The public preview exposed only an image, frame, or asset URL | Use `imageUrl`, `imageUrls`, `assetUrl`, `previewUrl`, and keep nullable copy fields optional. |
| A run is slower for some targets | Dynamic preview enrichment requires extra public preview requests | Lower `maxAds` for quick checks or split large advertiser lists across runs. |

### What changed in the current version?

#### 0.1

- Initial version with advertiser resolution, public creative pagination, first/last shown dates, asset links, preview links, and best-effort creative text extraction.

### How can I get support?

Open an issue on the actor page with the target, country, run ID, and a short description of what looked wrong. Include whether the problem was advertiser resolution, missing rows, date filtering, or preview extraction.

# Actor input Schema

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

Advertiser names, website domains, or Google advertiser IDs to resolve in the selected country. Examples: Nike, nike.com, AR16735076323512287233. Use a direct advertiser ID for the most stable scheduled runs.

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

Country whose public Ads Transparency Center results should be checked. Supported values include US, GB, DE, FR, PT, and more. Default: US.

## `maxAds` (type: `integer`):

Maximum number of ad creatives to return per target. Use 5-50 for quick checks and higher values for deeper monitoring. Default: 40; maximum: 1000.

## `shownSince` (type: `string`):

Only keep ads last shown on or after this date. Use YYYY-MM-DD, for example 2026-07-01. Leave empty to keep all returned last-shown dates.

## `firstShownAfter` (type: `string`):

Only keep ads first shown on or after this date. Use YYYY-MM-DD, for example 2026-01-01. Leave empty to keep all returned first-shown dates.

## `datasetId` (type: `string`):

Optional existing Apify dataset ID for pipeline runs. When provided, rows are appended there in addition to the default run dataset. Leave empty for normal one-off runs.

## `runId` (type: `string`):

Optional external run or workflow ID to include in output rows and RUN\_SUMMARY. Use it to join scheduled runs with your own monitoring jobs; leave empty when not needed.

## Actor input object example

```json
{
  "targets": [
    "Nike"
  ],
  "country": "US",
  "maxAds": 40
}
```

# Actor output Schema

## `datasetUrl` (type: `string`):

No description

## `runSummaryUrl` (type: `string`):

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "targets": [
        "Nike"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("trovevault/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 = { "targets": ["Nike"] }

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Google Ads Transparency Scraper",
        "description": "Extract public Google advertiser creatives with advertiser IDs, creative IDs, first and last shown dates, formats, preview assets, and available ad text.",
        "version": "0.1",
        "x-build-id": "EIBhK7Odqp3QRcsj3"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/trovevault~google-ads-transparency-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-trovevault-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/trovevault~google-ads-transparency-scraper/runs": {
            "post": {
                "operationId": "runs-sync-trovevault-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/trovevault~google-ads-transparency-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-trovevault-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",
                "required": [
                    "targets",
                    "country"
                ],
                "properties": {
                    "targets": {
                        "title": "Advertisers or Websites",
                        "type": "array",
                        "description": "Advertiser names, website domains, or Google advertiser IDs to resolve in the selected country. Examples: Nike, nike.com, AR16735076323512287233. Use a direct advertiser ID for the most stable scheduled runs.",
                        "items": {
                            "type": "string"
                        },
                        "default": [
                            "Nike"
                        ]
                    },
                    "country": {
                        "title": "Country",
                        "enum": [
                            "US",
                            "CA",
                            "GB",
                            "AU",
                            "BR",
                            "DE",
                            "ES",
                            "FR",
                            "IT",
                            "NL",
                            "PT"
                        ],
                        "type": "string",
                        "description": "Country whose public Ads Transparency Center results should be checked. Supported values include US, GB, DE, FR, PT, and more. Default: US.",
                        "default": "US"
                    },
                    "maxAds": {
                        "title": "Maximum Ads",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum number of ad creatives to return per target. Use 5-50 for quick checks and higher values for deeper monitoring. Default: 40; maximum: 1000.",
                        "default": 40
                    },
                    "shownSince": {
                        "title": "Shown Since",
                        "type": "string",
                        "description": "Only keep ads last shown on or after this date. Use YYYY-MM-DD, for example 2026-07-01. Leave empty to keep all returned last-shown dates."
                    },
                    "firstShownAfter": {
                        "title": "First Shown After",
                        "type": "string",
                        "description": "Only keep ads first shown on or after this date. Use YYYY-MM-DD, for example 2026-01-01. Leave empty to keep all returned first-shown dates."
                    },
                    "datasetId": {
                        "title": "Dataset ID",
                        "type": "string",
                        "description": "Optional existing Apify dataset ID for pipeline runs. When provided, rows are appended there in addition to the default run dataset. Leave empty for normal one-off runs."
                    },
                    "runId": {
                        "title": "Run ID",
                        "type": "string",
                        "description": "Optional external run or workflow ID to include in output rows and RUN_SUMMARY. Use it to join scheduled runs with your own monitoring jobs; leave empty when not needed."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
