# Advertising Marketing Agencies Email Scraper (`scraperoka/advertising-marketing-agencies-email-scraper`) Actor

📩 Advertising Marketing Agencies Email Scraper extracts targeted agency email contacts from advertising/marketing directories & sites. 🚀 Fast, accurate lead lists for B2B outreach, sales, and campaigns. 🔎 Boost deliverability with verified data—start prospecting today!

- **URL**: https://apify.com/scraperoka/advertising-marketing-agencies-email-scraper.md
- **Developed by:** [Scraperoka](https://apify.com/scraperoka) (community)
- **Categories:** Lead generation, Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.01 / 1,000 results

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

### Advertising Marketing Agencies Email Scraper 🎯

Manually visiting business listings to collect emails wastes hours you don’t have. **Advertising Marketing Agencies Email Scraper** helps you automatically scrape advertising and marketing agencies and extract their contact information—ideal for marketers, recruiters, and growth teams. This **Advertising Marketing Agencies Email Scraper** (also useful as an advertising marketing agencies email scraper, B2B marketing email list scraper, and targeted outreach email scraper) can help you build an agency prospecting email scraper dataset with thousands of leads in a single run.

---

### What You Get: Sample Output

Here's a sample record from a single run:

```json
{
  "name": "Brightside Creative Advertising",
  "website": "https://www.brightsidecreative.com",
  "phone": "+1 (212) 555-0134",
  "full_address": "125 Madison Ave New York NY 10016 US",
  "city": "New York",
  "state": "NY",
  "zip": "10016",
  "country_code": "US",
  "scraped_emails": [],
  "scraped_phones": ["+1 (212) 555-0134", "+1 (212) 555-0199"],
  "scraped_social_media": ["https://www.linkedin.com/company/brightside-creative/"],
  "emails_found": 0,
  "pages_scraped": 0,
  "avg_rating": 4.6,
  "total_reviews": 312,
  "lat": 40.7506,
  "long": -73.9935,
  "place_id": "ChIJN1t_tDeuEmsRUsoyG83frY4",
  "scrape_status": "failed",
  "email_found": ""
}
````

**Output Fields**

| Field | Type | What It Tells You |
|---|---|---|
| `name` | string | The business name you can reference in outreach |
| `website` | string | The business website URL used as the contact source |
| `phone` | string | A phone value associated with the business record |
| `full_address` | string | One-line address for quick CRM enrichment and verification |
| `city` | string | City for filtering and targeted outreach email campaigns |
| `state` | string | State/region for regional segmentation |
| `zip` | string | Postal code for deduping and lead routing |
| `country_code` | string | Country code to keep your list geographically consistent |
| `scraped_emails` | array | Emails discovered on the business website (before flattening per email in the dataset flow) |
| `scraped_phones` | array | Phone numbers found during website scraping |
| `scraped_social_media` | array | Social links found during website scraping |
| `emails_found` | number | Count of scraped emails for the business |
| `pages_scraped` | number | How many pages were processed when scraping the website |
| `avg_rating` | number | Rating value from the business record |
| `total_reviews` | number | Review count to gauge business presence and credibility |
| `scrape_status` | string | Whether the business scraping succeeded, failed, or had no website (`no_website`, `success`, `failed`, `error`) |
| `email_found` | string | The single email value for flattened rows (empty string when no emails are saved) |

Export your dataset as JSON, CSV, or Excel — straight from the Apify dashboard.

***

### Why Advertising Marketing Agencies Email Scraper?

There are a lot of ways to pull contact data from public web sources — here’s what sets Advertising Marketing Agencies Email Scraper apart.

#### Targeted agency lead discovery

You set `googleMapsSearchTerm` and one or more `googleMapsLocation` values, and the actor focuses on advertising marketing agencies email scraper results for those areas—so your email scraping for marketing agencies stays relevant.

#### Website-driven contact extraction

After it finds businesses, it scrapes business websites to extract emails, phone numbers, and social media profiles, turning an initial list into a usable advertising lead generation email scraper dataset.

#### Clean, structured dataset output

Results are saved with consistent fields like `scraped_emails`, `scraped_phones`, `scraped_social_media`, plus enrichment fields such as address and coordinates—helpful for marketing email database scraper workflows.

#### Built-in resilience and failure-state clarity

If a business has no website or scraping fails, the actor still writes a record with clear status values such as `no_website` or `failed`, so you can filter what’s usable without guessing.

***

### Configuring Your Run

Drop this into your `input.json` to get started:

```json
{
  "googleMapsSearchTerm": "Advertising Marketing Agencies",
  "googleMapsLocation": ["New York"],
  "maxBusinesses": 5,
  "scrapeMaxBusinessesPerLocation": false,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

**Input Fields**

| Parameter | Required | What It Does |
|---|---|---|
| `googleMapsSearchTerm` | ✅ | The business type or niche you want to scrape emails for (example given: `coffee shops`, `dentists`). Defaults to `Advertising Marketing Agencies`. |
| `googleMapsLocation` | ✅ | One or more target locations (example given: `Miami, Florida`), provided as a list (example prefill: `New York`). |
| `maxBusinesses` | ⬜ | Caps how many businesses you want to target for the run (range: 1–1000). The scraper stops when the target is reached. |
| `scrapeMaxBusinessesPerLocation` | ⬜ | If enabled, the actor aims for up to `maxBusinesses` results per location; if disabled, it combines locations under a single total limit up to `maxBusinesses`. |
| `proxyConfiguration` | ⬜ | Proxy settings for scraping (recommended for larger runs). Using proxies helps avoid IP blocks and rate limits. |
| ↳ `proxyConfiguration.proxy support` | ⬜ | When prefilled, routes requests through Apify Proxy for better reliability. |

***

### Core Capabilities

#### Agency-focused discovery via input controls

Advertising Marketing Agencies Email Scraper is driven by `googleMapsSearchTerm` and `googleMapsLocation`, so you can target exactly the advertising marketing agencies you care about without building your own discovery workflow.

#### Email, phone, and social extraction from websites

For each business with a `website`, the actor scrapes that site to collect `scraped_emails`, `scraped_phones`, and `scraped_social_media`, supporting use cases like targeted outreach email scraper and agency prospecting email scraper pipelines.

#### Resilient scraping with clear outcomes

If a business cannot be scraped as expected, the dataset reflects that with `scrape_status` and related fields such as `pages_scraped` and `emails_found`. This makes it easy to spot what to retry, what to enrich, and what to discard.

#### Flexible output limits for controlled lead volumes

Use `maxBusinesses` and `scrapeMaxBusinessesPerLocation` to control list size—useful for bulk email finder for agencies workflows, testing new outreach angles, or building marketing email database scraper lists in controlled batches.

#### Built-in proxy support for reliability

ProxyConfiguration helps keep scraping reliable, especially when you’re running larger jobs or multiple locations—ideal for B2B marketing email list scraper operations.

***

### Who Gets the Most Out of This

Here's how different teams put Advertising Marketing Agencies Email Scraper to work:

**Demand Gen and Performance Marketers** use it to build a ready-to-import targeted outreach email scraper list of advertising and marketing agencies by city/state, then enrich leads with `emails_found`, `avg_rating`, and review counts to prioritize outreach.

**Sales Development Teams** use it to turn a niche like advertising lead generation email scraper targets into an agency prospecting email scraper dataset, using website-driven extraction so the emails are tied to the business domain.

**Recruiters and Talent Sourcers** use the same workflow to find relevant agency contacts and compile structured datasets that include phone and social profiles for faster verification and personalization.

**Data Analysts and Researchers** benefit from the consistent dataset structure (addresses, coordinates, and scrape metrics like `pages_scraped`), making it easier to deduplicate and analyze lead coverage by location.

**Automation Specialists / Developers** can integrate this Advertising Marketing Agencies Email Scraper into larger data pipelines, consuming the dataset from Apify and pushing it downstream for CRM updates or enrichment.

***

### Step-by-Step: How to Use It

No coding needed. Here's how to run Advertising Marketing Agencies Email Scraper from start to finish:

1. **Open the actor on Apify** — go to [console.apify.com](https://console.apify.com) and open Advertising Marketing Agencies Email Scraper.
2. **Enter your inputs** — set `googleMapsSearchTerm` and `googleMapsLocation`, then optionally adjust `maxBusinesses` and `scrapeMaxBusinessesPerLocation`.
3. **Configure proxy settings** — in `proxyConfiguration`, enable Apify Proxy for better reliability on larger runs.
4. **Hit Run and watch the live log** — monitor progress and scraping steps as the actor processes locations and websites.
5. **View results in the dataset tab** — the dataset updates as records are pushed, with `scrape_status`, `emails_found`, and contact fields.
6. **Export as JSON, CSV, or Excel** — download from the dataset tab and import into your CRM or spreadsheet.

The whole process takes under 5 minutes to set up.

***

### Integrations & Export Options

Once your data is collected, Advertising Marketing Agencies Email Scraper plugs directly into your existing workflow.

You can download your results from the Apify dataset tab in common formats like **JSON, CSV, and Excel**, making it easy to use this advertising marketing agencies email scraper output in CRMs and dashboards.

You can also connect the actor to automation tools (such as Zapier or Make) and use Apify API access to pull results programmatically; for deeper options like webhooks and scheduled runs, refer to the Apify documentation at https://apify.com/docs/api.

***

### Pricing & Free Trial

Advertising Marketing Agencies Email Scraper runs on the Apify platform, which offers a **free tier** — no credit card required to get started.

Apify uses a pay-as-you-go model billed per Actor compute unit (CU), so you can run test batches first and scale when you’re ready. For heavy or recurring workloads, check Apify’s subscription plans on the pricing page. Start for free at [apify.com](https://apify.com) and scale when you’re ready.

***

### Reliability & Performance

| What We Handle | How |
|---|---|
| Rate-limit resilience | Uses retry and fallback behavior so runs are less likely to fail mid-way |
| Reliability at scale | Includes proxy support to reduce the chance of scraping interruptions |
| Data freshness | Pulls results from publicly available sources and enriches them by scraping each business website when present |
| Clear error outcomes | Saves records with `scrape_status` and `emails_found` so you can filter failures quickly |
| Controlled list sizing | Uses `maxBusinesses` and location handling rules to manage total output |

Limitations: The actor collects from publicly available data and depends on each business having accessible contact information on its website. If no website is available for a business, the dataset will reflect that with `scrape_status` such as `no_website`.

For enterprise-scale runs, contact us to discuss custom configurations.

***

### Frequently Asked Questions

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

Yes. Apify offers a free tier, which is enough for several test runs depending on your usage. After that, runs are billed based on Apify platform compute.

#### Do I need to log in to Advertising Marketing Agencies Email Scraper to use it?

No. You provide inputs like `googleMapsSearchTerm` and `googleMapsLocation`, and the actor processes publicly available business and website information. No additional login is required for you to run the actor.

#### How accurate is the data?

Accuracy depends on what the businesses publish on their websites and public pages. The actor extracts emails, phone numbers, and social media profiles into fields like `scraped_emails`, `scraped_phones`, and `scraped_social_media`, and reports `emails_found` and `scrape_status` so you can evaluate coverage.

#### How many results can I get per run?

You can cap results using `maxBusinesses` (range 1–1000). If you enable `scrapeMaxBusinessesPerLocation`, the actor targets up to `maxBusinesses` per location; otherwise it combines locations under a single total limit.

#### How often is the data updated / how fresh is it?

Data freshness corresponds to when you run the actor. Each run pulls current publicly available information and then scrapes websites to extract contacts, so the dataset reflects “as of run time” conditions.

#### Is this legal? Does it comply with GDPR / CCPA?

The actor uses **publicly available data**. You should review your use case for GDPR/CCPA and follow applicable laws and platform Terms of Service in your jurisdiction. It’s your responsibility to ensure the data is processed and used lawfully.

#### Can I export results to Google Sheets or Excel?

Yes. You can export from the Apify dashboard as JSON, CSV, or Excel. From there, you can import into Google Sheets or other tools in your workflow.

#### Can I run this on a schedule automatically?

Yes. Apify supports scheduled runs so you can automate recurring scraping jobs. Configure scheduling via Apify’s scheduling features as described in Apify documentation.

#### Can I access this via API?

Yes. You can trigger and pull results via Apify API access. See https://apify.com/docs/api for details.

#### What happens if the actor hits an error?

If website scraping fails for a business, the actor still records output with `scrape_status` (such as `failed` or `error`) and the relevant counters like `emails_found` and `pages_scraped`. That way, you can filter incomplete rows without losing the entire run.

***

### Need Help or Have a Request?

Got a question about Advertising Marketing Agencies Email Scraper or want a new feature added? Reach out at <dataforleads@gmail.com>. We actively maintain this actor and respond to feedback—feature ideas like webhook notifications on completion and additional lead-format options are especially welcome.

***

### Disclaimer & Responsible Use

*Advertising Marketing Agencies Email Scraper is the fastest, most reliable way to build an agency contact dataset—start your free run today.*

This actor collects **publicly available data** from business listings and businesses’ websites. It does not access private accounts, login-gated content, or password-protected pages. You are responsible for compliance with GDPR, CCPA, platform Terms of Service, and any applicable local regulations when using and storing the extracted data. If you need data removal assistance, contact <dataforleads@gmail.com>. Use responsibly, ethically, and only for lawful purposes.

# Actor input Schema

## `googleMapsSearchTerm` (type: `string`):

Enter the business type or niche for email scraper (e.g., 'coffee shops', 'dentists').

## `googleMapsLocation` (type: `array`):

Target geographic location for the email scraper (e.g., 'Miami, Florida').

## `maxBusinesses` (type: `integer`):

Target number of businesses to find (1-1000). The scraper will stop when this target is reached.

## `scrapeMaxBusinessesPerLocation` (type: `boolean`):

If enabled, the scraper will collect up to `maxBusinesses` results per location. If disabled, it combines all locations up to a single total limit.

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

Proxy settings for scraping. Recommended for large-scale scraping.

## Actor input object example

```json
{
  "googleMapsSearchTerm": "Advertising Marketing Agencies",
  "googleMapsLocation": [
    "New York"
  ],
  "maxBusinesses": 5,
  "scrapeMaxBusinessesPerLocation": false,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# 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 = {
    "googleMapsSearchTerm": "Advertising Marketing Agencies",
    "googleMapsLocation": [
        "New York"
    ],
    "maxBusinesses": 5,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("scraperoka/advertising-marketing-agencies-email-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 = {
    "googleMapsSearchTerm": "Advertising Marketing Agencies",
    "googleMapsLocation": ["New York"],
    "maxBusinesses": 5,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("scraperoka/advertising-marketing-agencies-email-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 '{
  "googleMapsSearchTerm": "Advertising Marketing Agencies",
  "googleMapsLocation": [
    "New York"
  ],
  "maxBusinesses": 5,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call scraperoka/advertising-marketing-agencies-email-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=scraperoka/advertising-marketing-agencies-email-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Advertising Marketing Agencies Email Scraper",
        "description": "📩 Advertising Marketing Agencies Email Scraper extracts targeted agency email contacts from advertising/marketing directories & sites. 🚀 Fast, accurate lead lists for B2B outreach, sales, and campaigns. 🔎 Boost deliverability with verified data—start prospecting today!",
        "version": "1.0",
        "x-build-id": "mxdwpWgW7B9fwR7iL"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scraperoka~advertising-marketing-agencies-email-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scraperoka-advertising-marketing-agencies-email-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/scraperoka~advertising-marketing-agencies-email-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scraperoka-advertising-marketing-agencies-email-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/scraperoka~advertising-marketing-agencies-email-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scraperoka-advertising-marketing-agencies-email-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": [
                    "googleMapsLocation",
                    "googleMapsSearchTerm"
                ],
                "properties": {
                    "googleMapsSearchTerm": {
                        "title": "Search Term",
                        "type": "string",
                        "description": "Enter the business type or niche for email scraper (e.g., 'coffee shops', 'dentists').",
                        "default": "Advertising Marketing Agencies"
                    },
                    "googleMapsLocation": {
                        "title": "Location",
                        "type": "array",
                        "description": "Target geographic location for the email scraper (e.g., 'Miami, Florida').",
                        "default": [
                            "New York"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxBusinesses": {
                        "title": "Maximum Businesses With Emails",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Target number of businesses to find (1-1000). The scraper will stop when this target is reached.",
                        "default": 5
                    },
                    "scrapeMaxBusinessesPerLocation": {
                        "title": "Scrape Max Businesses Per Location",
                        "type": "boolean",
                        "description": "If enabled, the scraper will collect up to `maxBusinesses` results per location. If disabled, it combines all locations up to a single total limit.",
                        "default": false
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Proxy settings for scraping. Recommended for large-scale scraping."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
