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

Google Ads Scraper - Extract Ads from Google Ads Transparency Center, Extract comprehensive data from Google Ads including text, image, and video advertisements directly from the official Google Ads Transparency Center. Perfect for competitive intelligence, ad research, and market analysis.

- **URL**: https://apify.com/happitap/google-ads-scraper.md
- **Developed by:** [HappiTap](https://apify.com/happitap) (community)
- **Categories:** Developer tools, Agents, Automation
- **Stats:** 8 total users, 1 monthly users, 100.0% runs succeeded, 2 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.01 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

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

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

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

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

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

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

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

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

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


# README

## Google Ads Scraper - Extract Ads from Google Ads Transparency Center

Extract comprehensive data from Google Ads including text, image, and video advertisements directly from the official Google Ads Transparency Center. Perfect for competitive intelligence, ad research, and market analysis.

### 🚀 Key Features

- **All Ad Formats**: Extract text, image, and video ads
- **Comprehensive Data**: Get ad details, impressions, targeting info, and media assets
- **Regional Insights**: Track ad performance across different regions and platforms
- **Ad Variations**: Capture all A/B test variations of each ad
- **Targeting Data**: Understand audience demographics and geographic targeting
- **Fast & Reliable**: Optimized scraping with proxy support
- **Easy Integration**: Export to JSON, CSV, Excel, or integrate with Clay, n8n, ChatGPT

### 📊 What Data Can You Extract?

#### Core Ad Details
- Ad format (text, image, video)
- Full ad library URL
- Preview image/video URL
- Creative ID and advertiser information
- First seen and last seen dates
- Number of days served

#### Reach & Performance Metrics
- Geographic regions where ads are displayed
- Impression counts (with breakdown by region)
- Platform distribution (YouTube, Google Search, Display Network)
- Date ranges for ad activity

#### Targeting Information
- Demographics targeting
- Geographic targeting
- Contextual targeting
- Advertiser list targeting

#### Media Assets
- High-resolution image URLs
- Video URLs for video ads
- All ad variations with different headlines, descriptions, and CTAs

### 🎯 Use Cases

- **Competitive Analysis**: Monitor competitor advertising strategies
- **Market Research**: Understand industry advertising trends
- **Ad Intelligence**: Track ad creative approaches and messaging
- **Performance Tracking**: Analyze ad longevity and regional performance
- **Creative Inspiration**: Discover successful ad formats and copy
- **Compliance Monitoring**: Track advertiser transparency and disclosures

### 📖 How to Use

#### Step 1: Get Your Start URL

You need a Google Ads Transparency Center URL for the advertiser you want to scrape:

**Option 1 - From Ad Search:**
1. Go to [Google Ads Transparency Center](https://adstransparency.google.com/)
2. Search for ads from your target advertiser
3. Click the advertiser's name at the bottom of any ad card
4. Copy the browser URL (should start with `https://adstransparency.google.com/advertiser/AR...`)

**Option 2 - Direct Advertiser Search:**
1. Go to [Google Ads Transparency Center](https://adstransparency.google.com/)
2. Search for the advertiser or domain name
3. Select a single advertiser from the dropdown (not "multiple advertiser accounts")
4. Copy the browser URL

**Example URL:**
````

https://adstransparency.google.com/advertiser/AR08888592736429539329?region=US\&preset-date=Last+30+days

````

#### Step 2: Configure Input

```json
{
  "startUrls": [
    {
      "url": "https://adstransparency.google.com/advertiser/AR08888592736429539329"
    }
  ],
  "maxAds": 500,
  "includeRegionStats": true,
  "includeTargeting": true,
  "includeVariations": true,
  "adFormats": []
}
````

#### Step 3: Run & Export

Click "Save & Start" and wait for the scraper to complete. Export your data in JSON, CSV, Excel, or integrate directly with your tools.

### 📥 Input Parameters

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `startUrls` | Array | Required | Google Ads Transparency Center advertiser URLs |
| `maxAds` | Integer | 500 | Maximum ads to extract per advertiser (0 = unlimited) |
| `includeRegionStats` | Boolean | true | Include regional impression statistics |
| `includeTargeting` | Boolean | true | Include targeting information |
| `includeVariations` | Boolean | true | Include all ad variations |
| `adFormats` | Array | \[] | Filter by format: TEXT, IMAGE, VIDEO (empty = all) |
| `proxyConfiguration` | Object | Apify Proxy | Proxy settings for reliable scraping |

### 📤 Output Format

Each extracted ad contains:

```json
{
  "adLibraryUrl": "https://adstransparency.google.com/advertiser/AR.../creative/CR...",
  "advertiserId": "AR08888592736429539329",
  "advertiserName": "Company Name",
  "creativeId": "CR08436770543486631937",
  "format": "IMAGE",
  "firstShown": "2023-07-04",
  "lastShown": "2024-05-17",
  "numServedDays": 191,
  "previewUrl": "https://tpc.googlesyndication.com/...",
  "regionStats": [
    {
      "regionCode": "US",
      "regionName": "United States",
      "impressions": {
        "lowerBound": 10000,
        "upperBound": 20000
      },
      "surfaceServingStats": [
        {
          "surfaceCode": "YOUTUBE",
          "surfaceName": "YouTube",
          "impressions": {
            "lowerBound": 5000,
            "upperBound": 10000
          }
        }
      ]
    }
  ],
  "targeting": {
    "demographics": {...},
    "geography": {...},
    "contextual": {...}
  },
  "variations": [
    {
      "clickUrl": "https://example.com/product",
      "cta": "LEARN_MORE",
      "description": "Ad description text",
      "headline": "Ad headline",
      "imageUrl": "https://..."
    }
  ]
}
```

### 💡 Tips for Best Results

1. **Use Proxies**: Always enable Apify Proxy for reliable scraping
2. **Set Reasonable Limits**: Use `maxAds` to control runtime and costs
3. **Filter Formats**: Use `adFormats` to focus on specific ad types
4. **Monitor Large Advertisers**: Some advertisers have thousands of ads - set appropriate limits
5. **Export Regularly**: Download data periodically for large scraping jobs

### 🔗 Integration Options

- **Clay**: Enrich your lead lists with competitor ad data
- **n8n**: Automate ad monitoring workflows
- **ChatGPT**: Analyze ad copy and creative strategies
- **Google Sheets**: Export directly for analysis
- **Zapier**: Trigger actions based on new ads
- **Make (Integromat)**: Build complex automation workflows

### ⚡ Performance & Pricing

- **Speed**: ~50-80 ads per minute
- **Pricing Model**: Pay-per-event ($0.001 per ad extracted)
- **Cost Example**: 1,000 ads = $1.00 + compute costs
- **Transparent Billing**: Only pay for successfully extracted ads
- **Reliability**: Built-in retry logic and error handling
- **Scalability**: Handle advertisers with thousands of ads

#### Pricing Details

This Actor uses a **pay-per-event** pricing model. You are charged $0.001 (0.1 cents) for each ad successfully extracted, plus standard Apify compute costs. This ensures you only pay for the data you receive.

**Example Costs:**

- 100 ads: $0.10 + compute (~$0.05) = **~$0.15 total**
- 500 ads: $0.50 + compute (~$0.15) = **~$0.65 total**
- 1,000 ads: $1.00 + compute (~$0.25) = **~$1.25 total**

*Note: Compute costs depend on memory allocation and runtime. Using proxy adds additional proxy costs.*

### 🛡️ Legal & Compliance

This scraper extracts data from Google's **public** Ads Transparency Center, which is designed for public access and transparency. The data is publicly available and intended for research and analysis purposes.

**Important Notes:**

- Only scrapes publicly available data
- Respects Google's rate limits
- Uses official Google Ads Transparency Center
- No authentication required
- Complies with Google's Terms of Service for public data

### ❓ FAQ

#### How many ads can I scrape?

You can scrape as many ads as available for an advertiser. Use the `maxAds` parameter to control limits. Most advertisers have 50-5,000 ads.

#### What ad formats are supported?

All formats: TEXT (text ads), IMAGE (display/banner ads), and VIDEO (YouTube and video ads).

#### Can I scrape multiple advertisers?

Yes! Add multiple URLs to the `startUrls` array. Each advertiser will be scraped separately.

#### How often is the data updated?

Google updates the Ads Transparency Center regularly. Run the scraper periodically to get the latest ads.

#### Why are some ads missing data?

Some fields (like targeting or regional stats) may not be available for all ads, depending on Google's data availability.

#### Can I filter by date range?

Yes, include date parameters in your start URL (e.g., `preset-date=Last+30+days`).

#### Is this faster than the reference scraper?

Yes! This implementation is optimized for speed and efficiency with better concurrency handling.

### 🆘 Support

Need help? Have questions?

- Check the [Apify Documentation](https://docs.apify.com)
- Review the input schema for parameter details
- Contact support for custom requirements

### 🔄 Updates & Changelog

**Version 1.0.0**

- Initial release
- Support for all ad formats
- Regional statistics
- Targeting data
- Ad variations
- Optimized performance

### 📝 Related Scrapers

- **Google Maps Lead Extractor**: Extract business leads from Google Maps
- **LinkedIn Ads Scraper**: Scrape LinkedIn advertising data
- **Facebook Ads Library Scraper**: Extract Facebook ad data
- **TikTok Ads Scraper**: Monitor TikTok advertising

***

**Keywords**: Google Ads scraper, ad intelligence, competitive analysis, ad transparency, Google Ads API, ad library scraper, advertising research, ad monitoring, competitor ads, ad creative analysis, Google Ads data extraction, ad performance tracking, advertising intelligence tool

# Actor input Schema

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

List of Google Ads Transparency Center URLs to scrape. Each URL must be from an advertiser page starting with https://adstransparency.google.com/advertiser/AR\<advertiser\_id>/. You can find these URLs by: (1) Searching for ads on Google Ads Transparency Center and clicking an advertiser name, or (2) Searching for an advertiser/domain name directly. Example: https://adstransparency.google.com/advertiser/AR08888592736429539329?region=US\&preset-date=Last+30+days. Format: Array of URL objects. Required to specify which advertisers to scrape ads from.

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

Maximum number of ads to extract from each advertiser URL. This limits how many ads the scraper will collect to control runtime and costs. For example, setting this to 100 will extract up to 100 ads from each advertiser. Set to 0 for unlimited ads (not recommended for large advertisers). Default: 500. Format: Positive integer. Why needed: Prevents excessive scraping and helps manage Actor runtime costs, especially for advertisers with thousands of ads.

## `includeRegionStats` (type: `boolean`):

Whether to include detailed regional impression statistics for each ad. When enabled, extracts data about impressions by region, platform (YouTube, Search, etc.), and date ranges. This provides deeper insights but increases data size. Default: true. Format: Boolean (true/false). Why needed: Regional stats show where ads are performing best, helping with geographic targeting analysis and competitive intelligence.

## `includeTargeting` (type: `boolean`):

Whether to include ad targeting data such as demographics, geography, contextual targeting, and advertiser lists. This shows how advertisers are targeting their audiences. Default: true. Format: Boolean (true/false). Why needed: Targeting data reveals advertiser strategies and helps understand audience segmentation approaches.

## `includeVariations` (type: `boolean`):

Whether to include all variations of each ad (different headlines, descriptions, images, CTAs). Ads often have multiple versions tested simultaneously. When disabled, only the primary variation is included. Default: true. Format: Boolean (true/false). Why needed: Ad variations show A/B testing strategies and creative approaches used by advertisers.

## `adFormats` (type: `array`):

Filter which ad formats to extract. Options: TEXT (text-only ads), IMAGE (display/banner ads), VIDEO (video ads including YouTube). Leave empty to extract all formats. Default: All formats. Format: Array of strings. Why needed: Allows focusing on specific ad types relevant to your analysis, reducing data volume and processing time.

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

Proxy settings to avoid IP blocking and rate limiting. Enable Apify residential proxies if you experience blocking or rate limiting. Disabled by default to reduce costs. Format: Proxy configuration object. Why needed: Ensures reliable scraping without getting blocked by Google's anti-bot systems when enabled.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://adstransparency.google.com/advertiser/AR08888592736429539329?region=US"
    }
  ],
  "maxAds": 500,
  "includeRegionStats": true,
  "includeTargeting": true,
  "includeVariations": true,
  "adFormats": [],
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `ads` (type: `string`):

Complete dataset of all extracted ads with full details

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

Quick overview of ads with key metrics

## `detailed` (type: `string`):

Detailed ad data including targeting and variations

# 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": [
        {
            "url": "https://adstransparency.google.com/advertiser/AR08888592736429539329?region=US"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("happitap/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": [{ "url": "https://adstransparency.google.com/advertiser/AR08888592736429539329?region=US" }] }

# Run the Actor and wait for it to finish
run = client.actor("happitap/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": [
    {
      "url": "https://adstransparency.google.com/advertiser/AR08888592736429539329?region=US"
    }
  ]
}' |
apify call happitap/google-ads-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=happitap/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 - Extract Ads from Google Ads Transparency Center, Extract comprehensive data from Google Ads including text, image, and video advertisements directly from the official Google Ads Transparency Center. Perfect for competitive intelligence, ad research, and market analysis.",
        "version": "0.0",
        "x-build-id": "3sUu2Zj4pqk7PBvDR"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/happitap~google-ads-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-happitap-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/happitap~google-ads-scraper/runs": {
            "post": {
                "operationId": "runs-sync-happitap-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/happitap~google-ads-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-happitap-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": "Start URLs",
                        "type": "array",
                        "description": "List of Google Ads Transparency Center URLs to scrape. Each URL must be from an advertiser page starting with https://adstransparency.google.com/advertiser/AR<advertiser_id>/. You can find these URLs by: (1) Searching for ads on Google Ads Transparency Center and clicking an advertiser name, or (2) Searching for an advertiser/domain name directly. Example: https://adstransparency.google.com/advertiser/AR08888592736429539329?region=US&preset-date=Last+30+days. Format: Array of URL objects. Required to specify which advertisers to scrape ads from.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxAds": {
                        "title": "Maximum Ads per Advertiser",
                        "minimum": 0,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of ads to extract from each advertiser URL. This limits how many ads the scraper will collect to control runtime and costs. For example, setting this to 100 will extract up to 100 ads from each advertiser. Set to 0 for unlimited ads (not recommended for large advertisers). Default: 500. Format: Positive integer. Why needed: Prevents excessive scraping and helps manage Actor runtime costs, especially for advertisers with thousands of ads.",
                        "default": 500
                    },
                    "includeRegionStats": {
                        "title": "Include Region Statistics",
                        "type": "boolean",
                        "description": "Whether to include detailed regional impression statistics for each ad. When enabled, extracts data about impressions by region, platform (YouTube, Search, etc.), and date ranges. This provides deeper insights but increases data size. Default: true. Format: Boolean (true/false). Why needed: Regional stats show where ads are performing best, helping with geographic targeting analysis and competitive intelligence.",
                        "default": true
                    },
                    "includeTargeting": {
                        "title": "Include Targeting Information",
                        "type": "boolean",
                        "description": "Whether to include ad targeting data such as demographics, geography, contextual targeting, and advertiser lists. This shows how advertisers are targeting their audiences. Default: true. Format: Boolean (true/false). Why needed: Targeting data reveals advertiser strategies and helps understand audience segmentation approaches.",
                        "default": true
                    },
                    "includeVariations": {
                        "title": "Include Ad Variations",
                        "type": "boolean",
                        "description": "Whether to include all variations of each ad (different headlines, descriptions, images, CTAs). Ads often have multiple versions tested simultaneously. When disabled, only the primary variation is included. Default: true. Format: Boolean (true/false). Why needed: Ad variations show A/B testing strategies and creative approaches used by advertisers.",
                        "default": true
                    },
                    "adFormats": {
                        "title": "Ad Formats to Extract",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Filter which ad formats to extract. Options: TEXT (text-only ads), IMAGE (display/banner ads), VIDEO (video ads including YouTube). Leave empty to extract all formats. Default: All formats. Format: Array of strings. Why needed: Allows focusing on specific ad types relevant to your analysis, reducing data volume and processing time.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "TEXT",
                                "IMAGE",
                                "VIDEO"
                            ]
                        },
                        "default": []
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Proxy settings to avoid IP blocking and rate limiting. Enable Apify residential proxies if you experience blocking or rate limiting. Disabled by default to reduce costs. Format: Proxy configuration object. Why needed: Ensures reliable scraping without getting blocked by Google's anti-bot systems when enabled.",
                        "default": {
                            "useApifyProxy": 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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
