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

🔍 Google Ads Scraper collects search ads from Google SERPs — headlines, descriptions, display URLs, sitelinks & extensions — with geo & language targeting. 📊 Perfect for PPC research, competitor analysis, keyword insights & ad copy inspiration. ⚡ Fast, CSV/JSON export-ready.

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

## Pricing

$19.99/month + usage

To use this Actor, you pay a monthly rental fee to the developer. The rent is subtracted from your prepaid usage every month after the free trial period.You also pay for the Apify platform usage, which gets cheaper the higher Apify subscription plan you have.

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

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

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

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

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

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

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

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

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

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


# README

### Google Ads Scraper

Google Ads Scraper is a fast, reliable Google Ads scraping tool that collects structured creative data from the Google Ads Transparency portal for PPC research, competitor analysis, and campaign intelligence. It solves the manual effort of exploring advertiser libraries by programmatically extracting creatives, regions, and timestamps — ideal for marketers, developers, data analysts, and researchers. With this AdWords scraper, you can build a repeatable pipeline for Google Ads data extraction at scale and power your PPC ad scraper for Google workflows with clean, export-ready datasets.

### What data / output can you get?

Get clean, deduplicated creative-level JSON records with regional breakdowns, dates, and media previews. Export to JSON, CSV, or Excel directly from the Apify dataset.

| Data type | Description | Example value |
| --- | --- | --- |
| adLibraryUrl | Direct link to the ad creative in Google Ads Transparency | https://adstransparency.google.com/advertiser/AR04619580580634296321/creative/123456789 |
| advertiserId | Unique Google advertiser identifier | AR04619580580634296321 |
| advertiserName | Name of the advertising company | Example Advertising Company |
| creativeId | Unique ad creative identifier | 123456789 |
| creativeRegions | List of countries where the creative was shown (sorted) | ["Canada", "United Kingdom", "United States"] |
| firstShown | Earliest known date the creative was shown (YYYY-MM-DD) | 2024-01-15 |
| format | Creative format derived from source data | IMAGE |
| lastShown | Latest known timestamp the creative was shown (ISO 8601) | 2024-11-20T10:30:45Z |
| previewUrl | Direct URL to preview the creative (image/video/script URL when available) | https://example.com/ad-image.jpg |
| regionStats | Array of per-region stats with dates and impression ranges | See nested fields below |
| regionStats[].regionCode | ISO-like country code resolved from region IDs | US |
| regionStats[].regionName | Country / territory name | United States |
| regionStats[].firstShown | First date shown in this region | 2024-01-15 |
| regionStats[].lastShown | Last date shown in this region | 2024-11-20 |
| regionStats[].impressions.lowerBound | Lower bound for impressions (placeholder range) | 0 |
| regionStats[].impressions.upperBound | Upper bound for impressions (placeholder range) | 1000 |

Notes:
- Bonus metadata includes a normalized region list (creativeRegions) and per-region date ranges (regionStats).
- Export your dataset to JSON, CSV, or Excel from the Apify UI or via API.
- Some fields may be missing depending on the creative (e.g., previewUrl may be null); format may return UNKNOWN for unrecognized types.

### Key features

- ⚡️ Automatic proxy fallback
  Starts direct and seamlessly falls back to datacenter, then residential proxies on blocking for higher reliability in your Google Ads scraping API workflows.

- 📥 Live dataset saving
  Writes each extracted creative to the Apify dataset immediately to prevent data loss during long runs — great for continuous Google Ads data extraction.

- 🔁 Pagination with deduplication
  Handles paginated API responses and deduplicates by creativeId to deliver clean, consolidated outputs.

- 🌍 Region and date controls via URL
  Respect region=... (e.g., US or anywhere) and preset-date parameters in advertiser URLs to scope data by geography and timeframe.

- 🧩 Structured JSON output
  Returns standardized fields (adLibraryUrl, advertiserId, advertiserName, creativeId, regions, dates, format, previewUrl, regionStats) ready for downstream analysis or integration into a Google Ads competitor analysis tool.

- 🧪 Production-grade logging
  Detailed progress logs, error handling, and dataset verification at the end of the run for reliable operations.

- 🛡️ No login required
  Works with publicly available Google Ads Transparency endpoints — no cookies or authenticated sessions.

- 👩‍💻 Developer-friendly
  Built with the Apify Python SDK and aiohttp for easy orchestration in pipelines. Ideal if you need a Google Ads spy tool alternative with structured outputs.

### How to use Google Ads Scraper - step by step

1. Create or log in to your Apify account at https://console.apify.com.
2. Open the Apify Store, search for “google-ads-scraper”, and navigate to the actor.
3. Click Run or Create task to configure inputs.
4. In startUrls, add one or more:
   - Full advertiser URLs: https://adstransparency.google.com/advertiser/AR04619580580634296321
   - Advertiser IDs: AR04619580580634296321
   - Optional URL parameters for scope:
     - ?region=US (or region=anywhere)
     - &preset-date=Last+30+days (supported: Last+7+days, Last+30+days, Last+90+days, Last+365+days)
5. Set maxItems (1–1000) for per-advertiser creative limits.
6. Optional: Configure proxyConfiguration or leave defaults; the actor automatically falls back to proxies if needed.
7. Start the run. Monitor real-time logs for page fetches, counts, and pagination progress.
8. When finished, open the Dataset tab to preview results and export to JSON, CSV, or Excel.

Pro Tip: Append region and preset-date directly in advertiser URLs within startUrls to instantly scope extractions without changing any other settings. This is helpful for workflows akin to a SERP ad extractor or ad copy scraper for Google Ads where you need time-bound slices.

### Use cases

| Use case name | Description |
| --- | --- |
| PPC teams – ad creative benchmarking | Analyze competitors’ creatives across regions and date ranges to improve copy and creative strategy using a PPC ad scraper for Google. |
| Market researchers – trend tracking | Track how messaging and formats evolve over time with exportable datasets, ideal for longitudinal analysis. |
| Competitive intelligence – advertiser mapping | Map advertiser libraries and regions to discover expansion patterns and campaign footprints with a Google Ads competitor analysis tool. |
| Data analysts – performance proxies | Use regionStats date coverage and impression ranges as directional signals for campaign activity. |
| API pipelines – automated exports | Trigger runs via Apify API and ship JSON to your warehouse/BI for recurring dashboards and alerts. |
| Academic research – advertising transparency | Collect public ad transparency data for studies on regional messaging variations and platform use. |
| Creative studios – inspiration boards | Curate examples by format and region to guide creative ideation with a Google ads extractor workflow. |
| QA & brand integrity – monitoring | Monitor brand presence and potential misuse across regions using structured outputs. |

### Why choose Google Ads Scraper?

Delivering precision, automation, and reliability for transparency data — purpose-built for structured, repeatable extraction.

- 🎯 Accurate, structured output: Clean fields and deduped creatives ready for analysis or enrichment.
- 🌐 Regional and time scoping: Respect region and preset-date parameters embedded in advertiser URLs for scoped pulls.
- 📈 Scalable & resilient: Handles pagination, retries, and automatic proxy fallback without manual tuning.
- 👩‍💻 Developer access: Integrate with the Apify platform and SDK for automated pipelines and programmatic exports.
- 🔒 Ethical by design: Uses public Google Ads Transparency endpoints; no login or private data access.
- 💸 Cost-effective ops: Run in the cloud and export to the formats you need; avoid brittle browser extensions and manual copy-paste.
- 🔗 Integration-ready: Results ship as JSON in an Apify dataset; export to CSV/Excel or pull via API to BI, CRM, or notebooks.

In short, this is a production-ready alternative to fragile tools — a best Google Ads scraper option when you need consistent, structured transparency data.

### Is it legal / ethical to use Google Ads Scraper?

Yes — when done responsibly. This actor collects publicly available data from the Google Ads Transparency portal and does not access private or authenticated content.

Guidelines for compliant use:
- Use data sourced from public endpoints only and avoid scraping private resources.
- Respect applicable regulations (e.g., GDPR, CCPA) and platform terms.
- Use outputs for research, analysis, or transparency purposes — not for spam or misuse.
- Consult your legal team for specific use cases or regional requirements.

### Input parameters & output format

Example JSON input
```json
{
  "startUrls": [
    "https://adstransparency.google.com/advertiser/AR04619580580634296321?region=anywhere",
    "AR04619580580634296321",
    "https://adstransparency.google.com/advertiser/AR04619580580634296321?preset-date=Last+30+days&region=US"
  ],
  "maxItems": 100,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
````

Input fields

| Field | Type | Required | Description | Default |
| --- | --- | --- | --- | --- |
| startUrls | array of strings | Yes | One or more Google Ads Transparency advertiser URLs (e.g., https://adstransparency.google.com/advertiser/AR...), advertiser IDs (e.g., AR04619580580634296321), or keywords. Notes: keywords present in startUrls are currently skipped by the implementation; use advertiser URLs or IDs. You can append region and preset-date query params to URLs (e.g., ?region=US, \&preset-date=Last+30+days). | — |
| maxItems | integer | No | Maximum number of ad creatives to scrape per advertiser (1–1000). | 100 |
| proxyConfiguration | object | No | Proxy settings for reliable scraping. If blocked, the actor automatically falls back to datacenter then residential proxies. | {"useApifyProxy": false} |

Example JSON output

```json
{
  "adLibraryUrl": "https://adstransparency.google.com/advertiser/AR04619580580634296321/creative/123456789",
  "advertiserId": "AR04619580580634296321",
  "advertiserName": "Example Advertising Company",
  "creativeId": "123456789",
  "creativeRegions": [
    "Canada",
    "United Kingdom",
    "United States"
  ],
  "firstShown": "2024-01-15",
  "format": "IMAGE",
  "lastShown": "2024-11-20T10:30:45Z",
  "previewUrl": "https://example.com/ad-image.jpg",
  "regionStats": [
    {
      "regionCode": "US",
      "regionName": "United States",
      "firstShown": "2024-01-15",
      "lastShown": "2024-11-20",
      "impressions": {
        "lowerBound": 0,
        "upperBound": 1000
      }
    }
  ]
}
```

Notes:

- format may return UNKNOWN for unrecognized types.
- previewUrl may be null when the source doesn’t expose a preview link.
- firstShown/lastShown values depend on availability in the transparency data.

### FAQ

#### Does this scrape Google SERP or Shopping ads?

No. This actor targets the Google Ads Transparency portal and returns creative-level transparency data. If you’re evaluating a Google SERP ads scraper or Google Shopping ads scraper, this tool provides complementary transparency records useful for competitor analysis and ad copy research.

#### Can I filter by region or date range?

Yes. Add query parameters to your advertiser URLs in startUrls. Use region=US (or region=anywhere) and preset-date values like Last+7+days, Last+30+days, Last+90+days, or Last+365+days. The actor parses these and scopes the request accordingly.

#### Do I need to log in or provide cookies?

No. The scraper works without login and collects data from public transparency endpoints. It does not access authenticated resources.

#### How many creatives can I extract per advertiser?

Set maxItems between 1 and 1000. The actor paginates results, deduplicates by creativeId, and stops when it reaches your limit or the source has no more items.

#### Are keywords supported in startUrls?

Not currently. While the input description mentions keywords, the current implementation skips keyword entries and only processes advertiser URLs or AR… IDs. Include full advertiser URLs or IDs for successful runs.

#### What formats can I export to?

Results are saved to an Apify dataset. You can export to JSON, CSV, or Excel directly from the Apify UI or pull data via the Apify API for integration into your workflows.

#### How does the proxy work?

The run starts without a proxy and automatically falls back to a datacenter proxy and then to residential proxies if blocking is detected. This improves reliability for large or repeated extractions.

#### Is there a free trial or subscription?

A time-limited trial is available (120 trial minutes). Ongoing access is provided via a monthly plan on the Apify Store. Check the actor’s Apify listing for current pricing and details.

### Closing CTA / Final thoughts

Google Ads Scraper is built for structured, reliable extraction of public transparency data from advertiser libraries. It delivers clean JSON with creatives, regions, dates, and previews — perfect for marketers, analysts, developers, and researchers running Google Ads competitor analysis or building a Google Ads landing page scraper pipeline. Export to JSON/CSV/Excel, or integrate via the Apify API for scheduled runs and automated reporting. Start extracting smarter insights from the Google Ads Transparency portal and power your next wave of PPC research.

# Actor input Schema

## `startUrls` (type: `array`):

List one or more Google Ads transparency URLs (e.g., https://adstransparency.google.com/advertiser/AR04619580580634296321), advertiser IDs (e.g., AR04619580580634296321), or keywords for searching advertisers.

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

Maximum number of ad creatives to scrape per advertiser (1-1000)

## `proxyConfiguration` (type: `object`):

Configure proxy settings for reliable scraping. If blocked, the actor will automatically fallback to datacenter then residential proxies.

## Actor input object example

```json
{
  "startUrls": [
    "https://adstransparency.google.com/advertiser/AR04619580580634296321",
    "AR04619580580634296321",
    "advertising",
    "marketing"
  ],
  "maxItems": 100,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# 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 = {
    "startUrls": [
        "https://adstransparency.google.com/advertiser/AR04619580580634296321"
    ],
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapium/google-ads-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "startUrls": ["https://adstransparency.google.com/advertiser/AR04619580580634296321"],
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("scrapium/google-ads-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "startUrls": [
    "https://adstransparency.google.com/advertiser/AR04619580580634296321"
  ],
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call scrapium/google-ads-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Google Ads Scraper",
        "description": "🔍 Google Ads Scraper collects search ads from Google SERPs — headlines, descriptions, display URLs, sitelinks & extensions — with geo & language targeting. 📊 Perfect for PPC research, competitor analysis, keyword insights & ad copy inspiration. ⚡ Fast, CSV/JSON export-ready.",
        "version": "0.1",
        "x-build-id": "0agDuv6M41haYZrnm"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapium~google-ads-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapium-google-ads-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/scrapium~google-ads-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scrapium-google-ads-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/scrapium~google-ads-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scrapium-google-ads-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "startUrls"
                ],
                "properties": {
                    "startUrls": {
                        "title": "Google Ads URLs/IDs/Keywords",
                        "type": "array",
                        "description": "List one or more Google Ads transparency URLs (e.g., https://adstransparency.google.com/advertiser/AR04619580580634296321), advertiser IDs (e.g., AR04619580580634296321), or keywords for searching advertisers.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxItems": {
                        "title": "Maximum Items to Scrape",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum number of ad creatives to scrape per advertiser (1-1000)",
                        "default": 100
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Configure proxy settings for reliable scraping. If blocked, the actor will automatically fallback to datacenter then residential proxies."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
