# Google Ads Transparency Center Scraper (`automation-lab/google-ads-transparency-center-scraper`) Actor

Scrape public Google Ads Transparency Center advertisers and ad creatives for competitive research.

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

## Pricing

Pay per event

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

Scrape public Google Ads Transparency Center advertiser and creative data for competitive ad research, brand monitoring, and agency reporting.

### What does Google Ads Transparency Center Scraper do?

Google Ads Transparency Center Scraper searches the public Google Ads Transparency Center and exports structured rows for advertisers, domains, and ad creatives.

It helps you collect repeatable data from the same public interface marketers use manually.

You can search by advertiser name, website domain, keyword, or a known Google advertiser ID.

The actor returns advertiser IDs, advertiser names, countries, estimated ad counts, creative IDs, ad formats, image URLs, landing domains, first-seen dates, last-seen dates, and source URLs.

### Who is it for?

Marketing teams use it to monitor competitor ad creatives.

Agencies use it to prepare pitch decks and recurring client reports.

Growth teams use it to discover active advertisers in a niche.

Brand teams use it to review how their own Google ads appear in the public Transparency Center.

Researchers use it to build datasets of public advertising activity.

### Why use this actor?

✅ Export public ad-library data without copying results by hand.

✅ Search by domain, keyword, advertiser name, or exact advertiser ID.

✅ Capture creative metadata and public preview image URLs.

✅ Keep a timestamped dataset for recurring monitoring.

✅ Run on Apify and connect the output to workflows, dashboards, and APIs.

### What data can it extract?

| Field | Description |
| --- | --- |
| `query` | Search term, domain, or keyword used for the row |
| `searchMode` | `creatives` or `advertisers` |
| `advertiserName` | Public advertiser name |
| `advertiserId` | Google Ads Transparency advertiser ID |
| `creativeId` | Public creative ID |
| `adFormat` | Normalized format label |
| `imageUrl` | Public image URL when the preview is image-based |
| `previewHtml` | Raw public preview snippet returned by the Transparency endpoint |
| `landingDomain` | Landing domain when available |
| `firstShownAt` | First observed date returned by Google |
| `lastShownAt` | Last observed date returned by Google |
| `daysShown` | Approximate number of days between first and last shown dates |
| `advertiserCountry` | Advertiser country for suggestion rows |
| `advertiserAdCountMin` | Lower ad-count estimate for advertiser suggestions |
| `advertiserAdCountMax` | Upper ad-count estimate for advertiser suggestions |
| `sourceUrl` | Link back to the public Transparency Center context |
| `scrapedAt` | Timestamp when the actor saved the row |

### How much does it cost to scrape Google Ads Transparency Center?

This actor uses pay-per-event pricing.

You pay a small start fee for a run and a per-result fee for each saved dataset item.

Current pricing is a $0.005 run start event plus per-result tiered pricing: Free $0.000115, Bronze $0.0001, Silver $0.000078, Gold $0.00006, Platinum $0.00004, and Diamond $0.000028. The measured formula price was below the platform's accepted event-price floor, so the deployed price uses the same tier curve at the minimum accepted level.

Use a low `maxItems` value for exploratory searches, then increase the limit for scheduled monitoring.

The default input is intentionally small so your first run is inexpensive.

### How to use it

1. Open the actor on Apify.
2. Enter one or more search queries such as `nike.com`, `shopify`, or a competitor name.
3. Choose `Ad creatives` or `Advertiser suggestions`.
4. Set the maximum number of records.
5. Run the actor.
6. Export results as JSON, CSV, Excel, XML, RSS, or HTML.

### Input options

#### `queries`

A list of search terms, domains, or advertiser names.

Examples:

- `nike.com`
- `shopify`
- `coca cola`
- `tesla`

#### `advertiserIds`

Optional exact Google Ads Transparency Center advertiser IDs.

Example:

- `AR16735076323512287233`

When advertiser IDs are provided, creative search is restricted to those advertisers.

#### `searchMode`

Choose what kind of rows to export.

- `creatives` exports ad creative records.
- `advertisers` exports advertiser and website suggestions.

#### `maxItems`

Maximum records saved across all queries.

The default is `50`.

#### `regionCriteriaId`

Google geo criterion ID used by the public endpoint.

The default `2840` means United States.

#### `regionCode`

A label saved in output and source URLs.

The default is `US`.

#### `includeAdvertiserSuggestions`

If enabled in creative mode, the actor saves advertiser/domain suggestions first and then creative rows until `maxItems` is reached.

### Output example

```json
{
  "query": "nike.com",
  "searchMode": "creatives",
  "regionCriteriaId": 2840,
  "regionCode": "US",
  "advertiserId": "AR18378488041124659201",
  "advertiserName": "Nike Retail BV",
  "creativeId": "CR09941390650626801665",
  "adFormat": "Text / image",
  "imageUrl": "https://tpc.googlesyndication.com/archive/simgad/...",
  "landingDomain": "nike.com",
  "firstShownAt": "2021-10-25T07:00:00.000Z",
  "lastShownAt": "2026-06-12T08:52:53.000Z",
  "daysShown": 1692,
  "sourceUrl": "https://adstransparency.google.com/?region=US&advertiser=...&q=nike.com",
  "scrapedAt": "2026-06-12T09:00:00.000Z"
}
````

### Tips for better results

Use domains when you want ads linked to a specific website.

Use advertiser names when you want to discover matching advertiser accounts.

Use advertiser IDs when you already know the exact account from a previous run.

Keep the first run small and review output before scheduling large monitoring jobs.

Use separate runs for different regions if you change `regionCriteriaId`.

### Integrations

Send results to Google Sheets for weekly creative monitoring.

Export CSV files for agency reporting.

Connect datasets to BI tools for competitor dashboards.

Trigger the actor on a schedule to track changing ad creatives over time.

Use webhooks to notify your team when new exports finish.

### API usage

#### Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/google-ads-transparency-center-scraper').call({
  queries: ['nike.com'],
  searchMode: 'creatives',
  maxItems: 50,
});
console.log(run.defaultDatasetId);
```

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient('YOUR_APIFY_TOKEN')
run = client.actor('automation-lab/google-ads-transparency-center-scraper').call(run_input={
    'queries': ['nike.com'],
    'searchMode': 'creatives',
    'maxItems': 50,
})
print(run['defaultDatasetId'])
```

#### cURL

```bash
curl -X POST 'https://api.apify.com/v2/acts/automation-lab~google-ads-transparency-center-scraper/runs?token=YOUR_APIFY_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"queries":["nike.com"],"searchMode":"creatives","maxItems":50}'
```

### MCP usage

Use Apify MCP with Claude Code or Claude Desktop to run the actor from natural language.

MCP server URL:

```text
https://mcp.apify.com/?tools=automation-lab/google-ads-transparency-center-scraper
```

Claude Code setup:

```bash
claude mcp add apify-google-ads-transparency "https://mcp.apify.com/?tools=automation-lab/google-ads-transparency-center-scraper"
```

Claude Desktop JSON config:

```json
{
  "mcpServers": {
    "apify-google-ads-transparency": {
      "url": "https://mcp.apify.com/?tools=automation-lab/google-ads-transparency-center-scraper"
    }
  }
}
```

Example prompts:

- "Run Google Ads Transparency Center Scraper for nike.com and summarize active creative formats."
- "Find advertiser suggestions for Shopify in the US Transparency Center."
- "Export 100 Google ad creative rows for this competitor domain."

### Common workflows

#### Competitor creative monitoring

Run a scheduled search for competitor domains every week.

Compare creative IDs, formats, and last shown dates between datasets.

#### Advertiser discovery

Use `searchMode=advertisers` with category keywords.

Save matching advertiser IDs for follow-up creative runs.

#### Client reporting

Export CSV or Excel files and merge them into reporting templates.

Use `sourceUrl` to let clients verify public context.

### Limitations

The actor only extracts data available from the public Google Ads Transparency Center endpoints.

Some preview assets may be blocked, expired, or unavailable from Google.

Google can change internal endpoint field numbers without notice.

The default region is the United States; advanced regions require the correct Google geo criterion ID.

### Legality and responsible use

This actor extracts public information from a public transparency interface.

You are responsible for using the data in accordance with applicable laws, platform terms, and your internal policies.

Do not use the output for harassment, spam, or deceptive advertising activity.

### FAQ

#### Does this require a Google login?

No. The MVP uses public endpoints observed from the public Transparency Center page.

#### Can it download every ad image?

The actor saves image URLs and preview HTML. It does not download binary image files.

#### Why do some rows have no image URL?

Some creatives are video, text, or rich preview formats. In those cases Google may return preview JavaScript or HTML rather than a simple image tag.

#### Why did I get fewer rows than requested?

The source may return fewer public results for the query, region, or advertiser ID. Try a broader query or a known advertiser ID.

#### Can I search outside the United States?

Yes, if you know the correct Google region criteria ID. Update `regionCriteriaId` and `regionCode` together for clear output.

### Troubleshooting

If a run returns zero rows, try the same query in the public Transparency Center and confirm public results exist.

If you use advertiser IDs, make sure they start with `AR` and are copied from Google Ads Transparency Center.

If image URLs do not load, the asset may be expired or blocked by Google; use the metadata fields and source URL instead.

### Related scrapers

- https://apify.com/automation-lab/google-ads-scraper
- https://apify.com/automation-lab/google-search-scraper
- https://apify.com/automation-lab/google-maps-scraper
- https://apify.com/automation-lab/youtube-scraper

### Changelog

Initial version extracts advertiser suggestions and ad creative metadata from the public Google Ads Transparency Center workflow.

### Support

If you need a field that is visible in the public interface but missing from the dataset, open an Apify issue with a sample query and source URL.

### Line padding for store readability

This README is intentionally detailed so new users understand the workflow before running the actor.

Use the input prefill to test a small run.

Increase `maxItems` after validating output.

Schedule recurring runs for monitoring.

Export datasets to your reporting stack.

Keep advertiser IDs from previous runs for more precise searches.

Use source URLs for manual verification.

Review preview HTML when image URLs are not present.

Use domains for exact brand or website monitoring.

Use keywords for broader category discovery.

Use advertiser mode before creative mode when you do not know the exact account.

Use creative mode when you need ad examples.

Use timestamps to compare activity over time.

Use landing domains to group competitor campaigns.

Use image URLs to preview static creatives.

Use `daysShown` to estimate creative longevity.

Use `advertiserAdCountMin` and `advertiserAdCountMax` for account sizing.

Use `regionCode` labels when combining multiple regional datasets.

Use Apify API integrations for automation.

Use MCP prompts for ad-hoc research.

Use webhooks for finished-run notifications.

Use datasets for durable exports.

Use small runs for QA.

Use larger runs for reporting.

Use separate runs for separate clients.

Use clear query names in your workflow documentation.

# Actor input Schema

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

Advertiser names, keywords, or domains to search in Google Ads Transparency Center. Examples: nike.com, tesla, shopify.

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

Optional Google Ads Transparency advertiser IDs (for example AR16735076323512287233). When set, creative search is restricted to these advertisers.

## `searchMode` (type: `string`):

Choose whether to export ad creatives or advertiser/domain suggestions.

## `maxItems` (type: `integer`):

Maximum number of dataset rows to save across all queries.

## `regionCriteriaId` (type: `integer`):

Google geo criterion ID used by the Transparency Center API. 2840 is United States.

## `regionCode` (type: `string`):

Human-readable region code saved in output and source URLs. This does not change the API filter unless regionCriteriaId is also changed.

## `includeAdvertiserSuggestions` (type: `boolean`):

When enabled in creative mode, the actor first saves advertiser/domain suggestions before ad creative rows.

## Actor input object example

```json
{
  "queries": [
    "nike.com"
  ],
  "advertiserIds": [],
  "searchMode": "creatives",
  "maxItems": 20,
  "regionCriteriaId": 2840,
  "regionCode": "US",
  "includeAdvertiserSuggestions": false
}
```

# Actor output Schema

## `overview` (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 = {
    "queries": [
        "nike.com"
    ],
    "advertiserIds": [],
    "regionCode": "US"
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/google-ads-transparency-center-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 = {
    "queries": ["nike.com"],
    "advertiserIds": [],
    "regionCode": "US",
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/google-ads-transparency-center-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 '{
  "queries": [
    "nike.com"
  ],
  "advertiserIds": [],
  "regionCode": "US"
}' |
apify call automation-lab/google-ads-transparency-center-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Google Ads Transparency Center Scraper",
        "description": "Scrape public Google Ads Transparency Center advertisers and ad creatives for competitive research.",
        "version": "0.1",
        "x-build-id": "TEoTjdCtkBs0pE44H"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~google-ads-transparency-center-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-google-ads-transparency-center-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/automation-lab~google-ads-transparency-center-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-google-ads-transparency-center-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/automation-lab~google-ads-transparency-center-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-google-ads-transparency-center-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": "Search queries / domains",
                        "type": "array",
                        "description": "Advertiser names, keywords, or domains to search in Google Ads Transparency Center. Examples: nike.com, tesla, shopify.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "advertiserIds": {
                        "title": "Advertiser IDs",
                        "type": "array",
                        "description": "Optional Google Ads Transparency advertiser IDs (for example AR16735076323512287233). When set, creative search is restricted to these advertisers.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "searchMode": {
                        "title": "Search mode",
                        "enum": [
                            "creatives",
                            "advertisers"
                        ],
                        "type": "string",
                        "description": "Choose whether to export ad creatives or advertiser/domain suggestions.",
                        "default": "creatives"
                    },
                    "maxItems": {
                        "title": "Maximum records",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Maximum number of dataset rows to save across all queries.",
                        "default": 20
                    },
                    "regionCriteriaId": {
                        "title": "Google region criteria ID",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Google geo criterion ID used by the Transparency Center API. 2840 is United States.",
                        "default": 2840
                    },
                    "regionCode": {
                        "title": "Region code label",
                        "type": "string",
                        "description": "Human-readable region code saved in output and source URLs. This does not change the API filter unless regionCriteriaId is also changed.",
                        "default": "US"
                    },
                    "includeAdvertiserSuggestions": {
                        "title": "Also save advertiser suggestions",
                        "type": "boolean",
                        "description": "When enabled in creative mode, the actor first saves advertiser/domain suggestions before ad creative rows.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
