# Car Dealer Email Scraper (`scraperoka/car-dealer-email-scraper`) Actor

🚗 Car Dealer Email Scraper extracts verified dealer emails from car dealership sites, helping you build targeted B2B lists fast. 📩 Perfect for lead gen, outreach, and sales pipelines. ⚡ Save time, boost conversions, and stay compliant.

- **URL**: https://apify.com/scraperoka/car-dealer-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

### Car Dealer Email Scraper 🎯 — Find Car Dealership Contact Emails at Scale

Manually visiting car dealership websites to collect emails wastes hours you don’t have. **Car Dealer Email Scraper** automatically searches for dealerships and extracts contact information including emails, phone numbers, and social media profiles. This **car dealer email scraper tool** turns publicly available web data into a structured lead list for marketers, recruiters, and growth teams—at the scale of thousands of records in minutes.

---

### What You Get: Sample Output

Here’s a sample record from a single run:

```json
{
  "name": "Midtown Auto Group",
  "website": "https://www.midtownautogroup.com",
  "phone": "+1 (212) 555-0199",
  "full_address": "500 W 34th St New York NY 10001 US",
  "city": "New York",
  "state": "NY",
  "zip": "10001",
  "country_code": "US",
  "email_found": "sales@midtownautogroup.com",
  "scraped_phones": ["+12125550199", "+12125550100"],
  "scraped_social_media": ["https://www.facebook.com/midtownauto", "https://www.linkedin.com/company/midtown-auto-group/"],
  "emails_found": 3,
  "pages_scraped": 7,
  "avg_rating": 4.6,
  "total_reviews": 238,
  "lat": 40.7557,
  "long": -73.9902,
  "place_id": "ChIJyWEHu9kAwokR7pGgW9fVw2g",
  "scrape_status": "success"
}
````

| Field | Type | What It Tells You |
|---|---|---|
| `name` | string | The dealership’s business name so you can identify the lead instantly |
| `website` | string | The official website you can use to verify the business and route leads |
| `phone` | string | A primary phone value associated with the dealership entry |
| `full_address` | string | A ready-to-use address string for CRM enrichment and filtering |
| `city` | string | Helps you segment outreach by geography (useful for used car dealer email scraper workflows) |
| `state` | string | State-level targeting for campaigns and reporting |
| `zip` | string | ZIP code for local lead lists and market coverage analysis |
| `country_code` | string | Country indicator for multi-region operations |
| `email_found` | string | One extracted email address saved for that row (flattened per email) |
| `scraped_phones` | array | Additional phone numbers found while scraping dealership pages |
| `scraped_social_media` | array | Social profiles discovered on or linked from the dealership site |
| `emails_found` | number | How many emails were found for the dealership website in this run |
| `pages_scraped` | number | How many pages were processed for that dealership website |
| `avg_rating` | number | Star rating value that can help prioritize higher-quality leads |
| `total_reviews` | number | Total reviews count for context and lead scoring |
| `place_id` | string | A deduplication-friendly identifier for the dealership listing |
| `scrape_status` | string | A status label such as success / no\_website / failed / error depending on outcomes |

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

***

### Why Car Dealer Email Scraper?

There are a lot of ways to pull data from the web for automotive lead generation—here’s what sets **Car Dealer Email Scraper** apart.

#### Built for Email-First Automotive Leads

You use `googleMapsSearchTerm` and `googleMapsLocation` inputs to target dealerships, then the actor extracts contact information including emails, phone numbers, and social media profiles—perfect for car dealership lead email scraper use cases.

#### Clean, Dataset-Friendly Output

Results are written into a single Apify dataset in a consistent format, including `email_found`, phone and social arrays, and useful metadata like `avg_rating` and `total_reviews`.

#### Stops at the Target You Set

Use `maxBusinesses` to control the “maximum businesses with emails” target. The run will stop when that target is reached, so you don’t over-collect.

#### Built-In Proxy Support for More Reliable Scraping

For larger-scale runs, you can enable `proxyConfiguration` (recommended) to help keep scraping reliable and avoid common access issues.

***

### Configuring Your Run

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

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

| Parameter | Required | What It Does |
|---|---|---|
| `googleMapsSearchTerm` | ✅ | The business type or niche to look for when building your dealership leads (example: `car dealer`, `auto dealership`). |
| `googleMapsLocation` | ✅ | A list of geographic locations to target (example: `New York`). |
| `maxBusinesses` | ⬜ | Sets the target number of businesses with emails (range: 1–1000). The scraper stops when this target is reached. |
| `scrapeMaxBusinessesPerLocation` | ⬜ | If enabled, it collects up to `maxBusinesses` results per location; if disabled, it combines all locations into a single total limit up to `maxBusinesses`. |
| `proxyConfiguration` | ⬜ | Proxy settings for scraping (recommended for larger-scale scraping). |
| ↳ `proxyConfiguration.proxy support` | ⬜ | When set to `true`, routes scraping through Apify Proxy for reliability. |

***

### Core Capabilities

#### Dealership Discovery + Contact Enrichment

Car Dealer Email Scraper searches for car dealerships based on your `googleMapsSearchTerm` and `googleMapsLocation`, then enriches each business with contact information including emails, phone numbers, and social media profiles.

#### Flexible Location Handling (Per-Location or Global Caps)

Whether you need a used car dealer email scraper list per city or a single combined dealer email database email export across multiple areas, `scrapeMaxBusinessesPerLocation` gives you control over how results are capped.

#### Resilience for Real-World Web Content

The actor includes practical resilience around scraping and continues working in the face of missing or unavailable website data, producing a clear `scrape_status` per record (for example, `no_website` when a website isn’t available).

#### Output Complete for Outreach Workflows

The dataset includes everything you need for B2B car dealer email outreach: `email_found`, `scraped_phones`, `scraped_social_media`, and business context (`avg_rating`, `total_reviews`, `full_address`).

#### Proxy Support for Larger Runs

Built-in proxy support helps keep runs reliable when you’re scraping at scale, which is especially helpful for dealer email finder workflows and automotive lead generation email scraping.

***

### Who Gets the Most Out of This

**Sales Development Representatives** use Car Dealer Email Scraper to turn dealership discovery into an actionable outreach list, saving time on manual verification and speeding up first-touch email campaigns.

**Marketing Managers** use it to build dealership contact email lists by city and state, then export dealer emails CSV-ready so campaigns stay targeted and measurable.

**Recruiters & Partnerships Teams** use the extracted phone and social media profiles alongside emails to qualify leads faster and improve response rates.

**Data Analysts** use the structured dataset fields (like `place_id`, `avg_rating`, `total_reviews`, and coordinates `lat`/`long`) to analyze coverage, prioritize markets, and track pipeline health over time.

**Automation Specialists (technical)** integrate this car dealership contact email scraper into workflows by triggering runs and pushing results into their existing systems for downstream enrichment and segmentation—without rebuilding the extraction pipeline.

***

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

No coding needed. Here's how to run Car Dealer Email Scraper from start to finish:

1. **Open the actor on Apify** — visit [console.apify.com](https://console.apify.com) and open **Car Dealer Email Scraper** to start a new run.
2. **Enter your inputs** — set `googleMapsSearchTerm` and `googleMapsLocation` (and optionally `maxBusinesses` and `scrapeMaxBusinessesPerLocation`).
3. **Configure proxy settings** — enable `proxyConfiguration` if you’re running larger jobs to improve reliability.
4. **Hit Run and watch the live log** — monitor progress and outcomes in real time.
5. **View results in the dataset tab** — emails are saved as dataset records with fields like `email_found` and `scrape_status`.
6. **Export your data** — download as JSON, CSV, or Excel from the dataset view.

The whole process takes under 5 minutes to set up.

***

### Integrations & Export Options

Once your data is collected, Car Dealer Email Scraper plugs directly into your existing workflow.

You can export results from the Apify dataset tab in **JSON**, **CSV**, or **Excel** for reporting, lead enrichment, and export dealer emails CSV pipelines. For storing into your stack, you can connect the dataset via **API access** (see [Apify API documentation](https://apify.com/docs/api)) and integrate downstream systems programmatically.

For workflow automation, use **webhooks**, **Zapier**, or **Make** to trigger actions (like CRM updates, tagging, or notifications) when the run completes. You can also set up **scheduled runs** in Apify so your car dealership email scraping software refreshes contact lists automatically.

***

### Pricing & Free Trial

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

You generally pay pay-as-you-go based on Apify Actor compute (CU), so you can test small batches first and scale up when you’re ready. For teams running frequent or high-volume dealer email finder workloads, Apify subscription plans may fit best—check the Apify pricing page for up-to-date details.

Start for free at [apify.com](https://apify.com) and scale when you're ready.

***

### Reliability & Performance

| What We Handle | How |
|---|---|
| Rate limiting & access variability | Uses practical request handling and concurrency management to keep runs steady |
| Reliability at scale | Supports `proxyConfiguration` for more consistent scraping |
| Output resilience | Produces `scrape_status` values and still returns records even when a website is missing |
| Dataset safety | Pushes results to the dataset during processing so you don’t lose everything on interruptions |
| Target-based stopping | Uses `maxBusinesses` as your results target to prevent runaway runs |

**Limitations:** This tool extracts contacts from publicly available web data. If a dealership doesn’t expose a website or contact emails on accessible pages, you may see lower `emails_found` counts for those businesses.

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 to get started. You can run small tests first, then scale based on your needs and usage.

#### Do I need to log in to use Car Dealer Email Scraper?

No login is required to run the actor. It works from publicly accessible web data and outputs results directly into your Apify dataset.

#### How accurate is the data?

Accuracy depends on what the dealership publishes on accessible pages. The actor saves what it finds into fields like `email_found`, `scraped_phones`, and `scraped_social_media`, along with context fields such as `avg_rating` and `total_reviews`.

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

You control this with `maxBusinesses` (range 1–1000). If you enable `scrapeMaxBusinessesPerLocation`, the actor targets up to `maxBusinesses` per location; otherwise it applies a single combined cap.

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

The dataset reflects the moment your run executes—freshness depends on how recently your actor run is started. For ongoing lead generation email scraping workflows, consider scheduled runs.

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

You should only use the extracted data in a lawful manner and in compliance with applicable privacy regulations. The actor collects from **publicly available data**, but it’s your responsibility to ensure your use complies with GDPR, CCPA, and relevant terms.

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

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

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

Yes. You can set up scheduled runs in Apify so your car dealership contact email scraper refreshes results automatically on a timeline you choose.

#### Can I access this via API?

Yes. You can retrieve run results programmatically using the Apify API (see [Apify API documentation](https://apify.com/docs/api)).

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

If scraping fails for a specific business, you’ll see failure-state information reflected in fields like `scrape_status` (for example, `failed` or `error`). The actor continues processing and saves available results to the dataset.

***

### Need Help or Have a Request?

Got a question about Car Dealer Email Scraper or want a new feature added? Reach out at <dataforleads@gmail.com>. We respond to feedback and maintain the actor—ideas like “batch CSV upload” and “webhook on completion” are especially welcome.

***

### Disclaimer & Responsible Use

*Car Dealer Email Scraper is the fastest, most reliable way to build dealer email contact lists — start your free run today.*

This actor collects **publicly available data** from web sources. It does not access private accounts, login-gated content, or password-protected pages. You are responsible for ensuring your use complies with GDPR, CCPA, and applicable platform Terms of Service. For data removal requests, 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., 'car dealer', 'auto dealership').

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

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

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

Target number of emails 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": "Car Dealer",
  "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": "Car Dealer",
    "googleMapsLocation": [
        "New York"
    ],
    "maxBusinesses": 5,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("scraperoka/car-dealer-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": "Car Dealer",
    "googleMapsLocation": ["New York"],
    "maxBusinesses": 5,
    "proxyConfiguration": { "useApifyProxy": True },
}

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Car Dealer Email Scraper",
        "description": "🚗 Car Dealer Email Scraper extracts verified dealer emails from car dealership sites, helping you build targeted B2B lists fast. 📩 Perfect for lead gen, outreach, and sales pipelines. ⚡ Save time, boost conversions, and stay compliant.",
        "version": "1.0",
        "x-build-id": "VjZqfOQijaZvdRjnh"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scraperoka~car-dealer-email-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scraperoka-car-dealer-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~car-dealer-email-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scraperoka-car-dealer-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~car-dealer-email-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scraperoka-car-dealer-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., 'car dealer', 'auto dealership').",
                        "default": "Car Dealer"
                    },
                    "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 emails 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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
