# Google Ads Scraper — Live Search Sponsored Ads (`khadinakbar/google-ads-scraper`) Actor

Scrape LIVE Google Search sponsored ads by keyword, location, and device. One row per paid ad. Not Transparency Center.

- **URL**: https://apify.com/khadinakbar/google-ads-scraper.md
- **Developed by:** [Khadin Akbar](https://apify.com/khadinakbar) (community)
- **Categories:** SEO tools, MCP servers, Marketing
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.00 / 1,000 sponsored ads

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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 — Live Search Sponsored Ads

**Scrape the LIVE sponsored (paid) ads that appear on Google Search** for any keyword, in any country, on desktop or mobile. You get **one row per ad**: advertiser, ad position, headline, ad copy, display URL, landing URL, and sitelinks. Built for **PPC competitive monitoring** — see exactly which advertisers are bidding on your keywords, what copy they run, and where they rank.

> **This is NOT a Google Ads Transparency Center scraper.** It reads the real-time Search results page, not the advertiser creative archive. If you want an advertiser's historical creative library (impressions, run dates), use a Transparency Center scraper instead. This actor answers a different question: *"What ads show right now for keyword X in location Y?"*

### What does Google Ads Scraper do?

It runs your keywords through [Google Search](https://www.google.com) using residential proxies, finds the **sponsored ad blocks** at the top and bottom of the results page, and extracts each ad as a structured record. Because it runs on the Apify platform you get API access, scheduling, proxy rotation, monitoring, and one-click export to JSON, CSV, or Excel.

Typical uses:

- **PPC competitive intelligence** — track which competitors bid on your money keywords and how their copy changes.
- **Ad copy research** — collect live headlines and descriptions before writing your own.
- **Share-of-voice monitoring** — count how often each advertiser appears across a keyword set.
- **Geo / device comparison** — see how ads differ between cities or between desktop and mobile.
- **Agency reporting** — schedule daily runs and feed ad data into dashboards.

### Why use Google Ads Scraper?

| Benefit | Detail |
|---|---|
| Ad-first output | Every row is one ad, not a generic SERP dump you have to filter. |
| Real-time | Reads the live results page — what searchers actually see today. |
| Geo + device targeting | Country (`gl`), language (`hl`), city (`uule`), desktop or mobile. |
| Cost control | Hard per-keyword ad cap; you see the max cost before the run starts. |
| MCP-ready | Designed to be called by AI agents (Claude, ChatGPT) via Apify MCP. |
| Reliable | SerpApi-backed engine handles Google's anti-bot for you; honest failure on block (no silent empty runs). Works out of the box — no key required. |

### How to use Google Ads Scraper

1. Open the actor and go to the **Input** tab.
2. Add your **keywords** (one per line), e.g. `car insurance`, `crm software`.
3. Pick a **country**, **language**, and optionally a **city** for local ad targeting.
4. Choose **desktop** or **mobile**.
5. Set **Max ads per keyword** to cap cost.
6. Click **Start**. Download results from the **Output** tab in JSON, CSV, or Excel.

### Input

| Field | Type | Description |
|---|---|---|
| `queries` | array | Keywords to search (required). |
| `countryCode` | enum | Two-letter country code (`gl`), default `us`. |
| `languageCode` | enum | Two-letter language code (`hl`), default `en`. |
| `locationName` | string | Optional `City,Region,Country` for city-level ad targeting. |
| `device` | enum | `desktop` or `mobile`. |
| `maxAdsPerQuery` | integer | Cost cap — max ads saved/billed per keyword (default 20). |
| `maxPagesPerQuery` | integer | Result pages per keyword (default 1). |
| `includeBottomAds` | boolean | Also capture bottom-of-page ads (default true). |
| `engine` | enum | `auto` (recommended), `serpapi`, or `browser`. Leave on `auto`. |
| `serpApiKey` | string | Optional — bring your own SerpApi key. Blank = built-in managed key. |

#### Input example

```json
{
  "queries": ["car insurance", "project management software"],
  "countryCode": "us",
  "languageCode": "en",
  "locationName": "New York,New York,United States",
  "device": "desktop",
  "maxAdsPerQuery": 20,
  "includeBottomAds": true
}
````

### Output

One record per sponsored ad. You can download the dataset in JSON, HTML, CSV, or Excel.

```json
{
  "query": "car insurance",
  "advertiser": "progressive.com",
  "title": "Progressive® Car Insurance — Get a Free Quote Online",
  "description": "Switch & save an average of $750. Get your fast, free quote today.",
  "displayUrl": "progressive.com/car-insurance",
  "finalUrl": "https://www.progressive.com/auto/",
  "position": "top",
  "rankInBlock": 1,
  "sitelinks": [
    { "title": "Get a Quote", "url": "https://www.progressive.com/auto/quote/" },
    { "title": "Bundle & Save", "url": "https://www.progressive.com/bundle/" }
  ],
  "extensions": [],
  "phone": null,
  "rating": null,
  "countryCode": "us",
  "languageCode": "en",
  "device": "desktop",
  "locationName": "New York,New York,United States",
  "page": 1,
  "searchUrl": "https://www.google.com/search?q=car+insurance&gl=us&hl=en",
  "scrapedAt": "2026-05-30T12:00:00.000Z"
}
```

### Data fields

| Field | Description |
|---|---|
| `query` | The keyword that produced this ad. |
| `advertiser` | Advertiser domain. |
| `title` | Ad headline. |
| `description` | Ad body copy. |
| `displayUrl` | The display (vanity) URL shown in the ad. |
| `finalUrl` | Resolved landing-page URL. |
| `position` | `top` or `bottom` ad block. |
| `rankInBlock` | 1-based rank within its block. |
| `sitelinks` | Array of `{title, url}` ad sitelinks. |
| `extensions` | Callout / structured-snippet extensions when present. |
| `phone` | Call-extension phone number, if shown. |
| `rating` | Seller rating, if shown. |
| `device`, `countryCode`, `languageCode`, `locationName` | Targeting context. |
| `scrapedAt` | ISO 8601 timestamp. |

### How much does it cost to scrape Google ads?

Pricing is **pay-per-event**:

- **$0.00005** per actor start.
- **$0.008** per sponsored ad extracted (capped per keyword by `maxAdsPerQuery`).

A typical Google SERP shows 3–7 ads, so one keyword usually costs **$0.024–$0.056**. Your **maximum** cost is always `keywords × maxAdsPerQuery × $0.008`, shown in the run status before billing begins. Both per-event and usage-based billing are available.

### Tips

- Lower `maxAdsPerQuery` to tighten cost; ads beyond the cap are skipped, not billed.
- Set `locationName` for local-intent keywords (`plumber near me`) — ads are highly geo-specific.
- Compare `device: desktop` vs `mobile` — ad counts and advertisers often differ.
- Schedule daily runs to track competitor ad-copy changes over time.

### FAQ, disclaimer, and support

**Does every keyword have ads?** No. Informational queries (e.g. "how does rain form") show zero ads, and even commercial keywords serve ads probabilistically — Google may show 6 ads on one scrape and 0 a minute later. The run always completes and reports which keywords had none; you are never billed for ads that did not appear.

**How does it stay reliable?** Google Search ads are rendered by JavaScript and Google aggressively blocks automated browsers. This actor uses a managed SerpApi engine that handles anti-bot for you, so it works out of the box with no setup. Advanced users can switch `engine` to `browser` (tries a stealth browser first, falls back to the API) or supply their own SerpApi key via `serpApiKey`.

**Legal:** This actor collects only publicly visible Google Search ad content. You are responsible for complying with Google's Terms of Service and applicable laws in your jurisdiction. Do not use the data for unlawful purposes.

**Support:** Found a parsing gap or a markup change? Open an issue on the actor's **Issues** tab. Custom field requests and higher-volume needs welcome.

***

### Related actors

- [Google Ads Transparency Scraper](https://apify.com/khadinakbar/google-ads-transparency-scraper) — Pull advertiser-level historical creatives and run dates from Google's Ad Transparency Center.
- [Meta Ad Library Scraper](https://apify.com/khadinakbar/meta-ad-library-scraper) — Capture Facebook and Instagram ad creatives and run dates for competitive analysis.
- [TikTok Ads Scraper](https://apify.com/khadinakbar/tiktok-ads-scraper) — Mine TikTok Creative Center's top-performing ads by region, industry, and objective.
- [Google SERP Scraper](https://apify.com/khadinakbar/scrape-google-serp) — Combine sponsored ad data with the full organic SERP for the same keywords.
- [Google Trends Scraper](https://apify.com/khadinakbar/google-trends-scraper) — Align ad coverage with search demand and trending queries.

# Actor input Schema

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

Keywords to search on Google. The scraper returns the SPONSORED (paid) ads shown for each keyword, one record per ad. Example: \['car insurance', 'crm software']. This is live SERP ad data, NOT Google Ads Transparency Center creatives — for advertiser creative history use a Transparency Center scraper instead.

## `countryCode` (type: `string`):

Two-letter ISO country code that geo-targets the Google search (the gl parameter), e.g. 'us', 'gb', 'de'. Ads are country-specific, so this strongly affects which advertisers appear. Defaults to 'us'. For city-level targeting also set locationName.

## `languageCode` (type: `string`):

Two-letter ISO language code for the Google interface and results (the hl parameter), e.g. 'en', 'de', 'fr'. Defaults to 'en'. Set this to the language advertisers in your target country actually bid in, not your own.

## `locationName` (type: `string`):

Optional canonical location for city-level ad targeting via Google's uule parameter, e.g. 'New York,New York,United States' or 'London,England,United Kingdom'. Use the exact 'City,Region,Country' form. Leave blank to target the whole country set by countryCode. NOT a latitude/longitude.

## `device` (type: `string`):

Whether to fetch the desktop or mobile Google results page. Mobile and desktop often show different ads and ad counts, so pick the surface you want to monitor. Defaults to 'desktop'.

## `maxAdsPerQuery` (type: `integer`):

Hard cap on how many ads are saved and billed per keyword. This is your cost control: total max cost = number of keywords x maxAdsPerQuery x $0.008. Defaults to 20. A typical SERP shows 3-7 ads, so 20 rarely truncates. Range 1-100.

## `maxPagesPerQuery` (type: `integer`):

How many Google result pages to fetch per keyword. Ads concentrate on page 1, so the default 1 is best for most users; raise it only to capture bottom-of-funnel ads on deeper pages. Range 1-5.

## `includeBottomAds` (type: `boolean`):

Whether to also capture sponsored ads shown at the BOTTOM of the results page, not just the top block. Bottom ads are usually lower-bid competitors. Defaults to true. Set false to monitor only premium top-of-page ad slots.

## `engine` (type: `string`):

How ads are fetched. 'auto' (recommended) uses the reliable SerpApi engine when a key is available (built in by default) and falls back to a stealth browser otherwise. 'serpapi' forces the API. 'browser' tries a stealth browser first and only falls back to SerpApi if Google blocks it. Most users should leave this on 'auto'.

## `serpApiKey` (type: `string`):

Optional: bring your own SerpApi key (serpapi.com) to use your own quota and rate limits. Leave blank to use the built-in managed key. Example: 'a1b2c3...'. This is a credential, not a search term — it is never stored in your output.

## Actor input object example

```json
{
  "queries": [
    "best vpn",
    "plumber near me"
  ],
  "countryCode": "us",
  "languageCode": "en",
  "locationName": "New York,New York,United States",
  "device": "desktop",
  "maxAdsPerQuery": 20,
  "maxPagesPerQuery": 1,
  "includeBottomAds": true,
  "engine": "auto"
}
```

# Actor output Schema

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

No description

## `runSummary` (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": [
        "car insurance",
        "project management software"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("khadinakbar/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 = { "queries": [
        "car insurance",
        "project management software",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("khadinakbar/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 '{
  "queries": [
    "car insurance",
    "project management software"
  ]
}' |
apify call khadinakbar/google-ads-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Google Ads Scraper — Live Search Sponsored Ads",
        "description": "Scrape LIVE Google Search sponsored ads by keyword, location, and device. One row per paid ad. Not Transparency Center.",
        "version": "1.0",
        "x-build-id": "lQPShBCslcY8whefk"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/khadinakbar~google-ads-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-khadinakbar-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/khadinakbar~google-ads-scraper/runs": {
            "post": {
                "operationId": "runs-sync-khadinakbar-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/khadinakbar~google-ads-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-khadinakbar-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": [
                    "queries"
                ],
                "properties": {
                    "queries": {
                        "title": "Search keywords",
                        "type": "array",
                        "description": "Keywords to search on Google. The scraper returns the SPONSORED (paid) ads shown for each keyword, one record per ad. Example: ['car insurance', 'crm software']. This is live SERP ad data, NOT Google Ads Transparency Center creatives — for advertiser creative history use a Transparency Center scraper instead.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "countryCode": {
                        "title": "Country",
                        "enum": [
                            "us",
                            "gb",
                            "ca",
                            "au",
                            "de",
                            "fr",
                            "es",
                            "it",
                            "nl",
                            "in",
                            "br",
                            "mx",
                            "jp",
                            "ae",
                            "sg",
                            "za"
                        ],
                        "type": "string",
                        "description": "Two-letter ISO country code that geo-targets the Google search (the gl parameter), e.g. 'us', 'gb', 'de'. Ads are country-specific, so this strongly affects which advertisers appear. Defaults to 'us'. For city-level targeting also set locationName.",
                        "default": "us"
                    },
                    "languageCode": {
                        "title": "Language",
                        "enum": [
                            "en",
                            "de",
                            "fr",
                            "es",
                            "it",
                            "nl",
                            "pt",
                            "ja",
                            "ar",
                            "hi"
                        ],
                        "type": "string",
                        "description": "Two-letter ISO language code for the Google interface and results (the hl parameter), e.g. 'en', 'de', 'fr'. Defaults to 'en'. Set this to the language advertisers in your target country actually bid in, not your own.",
                        "default": "en"
                    },
                    "locationName": {
                        "title": "City location (optional)",
                        "type": "string",
                        "description": "Optional canonical location for city-level ad targeting via Google's uule parameter, e.g. 'New York,New York,United States' or 'London,England,United Kingdom'. Use the exact 'City,Region,Country' form. Leave blank to target the whole country set by countryCode. NOT a latitude/longitude."
                    },
                    "device": {
                        "title": "Device",
                        "enum": [
                            "desktop",
                            "mobile"
                        ],
                        "type": "string",
                        "description": "Whether to fetch the desktop or mobile Google results page. Mobile and desktop often show different ads and ad counts, so pick the surface you want to monitor. Defaults to 'desktop'.",
                        "default": "desktop"
                    },
                    "maxAdsPerQuery": {
                        "title": "Max ads per keyword (cost cap)",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Hard cap on how many ads are saved and billed per keyword. This is your cost control: total max cost = number of keywords x maxAdsPerQuery x $0.008. Defaults to 20. A typical SERP shows 3-7 ads, so 20 rarely truncates. Range 1-100.",
                        "default": 20
                    },
                    "maxPagesPerQuery": {
                        "title": "Pages per keyword",
                        "minimum": 1,
                        "maximum": 5,
                        "type": "integer",
                        "description": "How many Google result pages to fetch per keyword. Ads concentrate on page 1, so the default 1 is best for most users; raise it only to capture bottom-of-funnel ads on deeper pages. Range 1-5.",
                        "default": 1
                    },
                    "includeBottomAds": {
                        "title": "Include bottom-of-page ads",
                        "type": "boolean",
                        "description": "Whether to also capture sponsored ads shown at the BOTTOM of the results page, not just the top block. Bottom ads are usually lower-bid competitors. Defaults to true. Set false to monitor only premium top-of-page ad slots.",
                        "default": true
                    },
                    "engine": {
                        "title": "Scraping engine",
                        "enum": [
                            "auto",
                            "serpapi",
                            "browser"
                        ],
                        "type": "string",
                        "description": "How ads are fetched. 'auto' (recommended) uses the reliable SerpApi engine when a key is available (built in by default) and falls back to a stealth browser otherwise. 'serpapi' forces the API. 'browser' tries a stealth browser first and only falls back to SerpApi if Google blocks it. Most users should leave this on 'auto'.",
                        "default": "auto"
                    },
                    "serpApiKey": {
                        "title": "SerpApi key (optional)",
                        "type": "string",
                        "description": "Optional: bring your own SerpApi key (serpapi.com) to use your own quota and rate limits. Leave blank to use the built-in managed key. Example: 'a1b2c3...'. This is a credential, not a search term — it is never stored in your output."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
