# Auto Repair Shop Email Scraper (`solid-scraper/auto-repair-shop-email-scraper`) Actor

🔧 Auto Repair Shop Email Scraper finds verified email leads for repair businesses by location & keywords. 🚗⚡ Instantly build targeted lists for outreach, marketing, and partnerships—save time and boost conversions with high-accuracy results.

- **URL**: https://apify.com/solid-scraper/auto-repair-shop-email-scraper.md
- **Developed by:** [SolidScraper](https://apify.com/solid-scraper) (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 $2.99 / 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

### Auto Repair Shop Email Scraper 📬

**Auto Repair Shop Email Scraper** helps you find auto repair shops in specific locations and extract their contact information—especially email addresses—from publicly available web pages. If you’re looking for an **auto repair shop email scraper**, a **vehicle repair shop lead scraper**, or an **auto repair business email extraction** workflow, this tool streamlines the hard part: turning business listings into a usable outreach list. Whether you’re a marketer, sales lead, recruiter, or data analyst, you can use Auto Repair Shop Email Scraper to build cleaner lead datasets faster—saving you hours of manual work.

---

### Why choose Auto Repair Shop Email Scraper?

| Feature | Benefit |
| --- | --- |
| ✅ All-in-one contact enrichment | Extracts emails plus phone numbers and social media links from business websites in one run |
| ✅ Reliability-focused scraping | Includes built-in resilience (proxy support and fallbacks) for better completion rates |
| ✅ Email-targeted output | Produces an email-focused dataset you can export straight to your CRM or spreadsheet |
| ✅ Structured, dataset-ready results | Saves consistent fields (business details + `email_found`) in a tabular dataset view |
| ✅ Scale-friendly batching | Handles multiple locations and large runs while respecting your business limits |
| ✅ Apify dataset output | Pushes results immediately so you don’t have to wait to collect useful partial data |

---

### Key features

- 🎯 **Auto repair shop lead targeting**: Uses your search term and locations to find relevant auto repair businesses
- 🌐 **Contact extraction from websites**: Scrapes each business website for email addresses, phone numbers, and social media profiles
- 🛡️ **Proxy support for reliable scraping**: Lets you use proxy configuration to improve stability for larger batches
- 🔄 **Resilient pipeline**: Includes resilience behavior with fallbacks so runs complete more often
- 💾 **Real-time data saving**: Pushes each result to the Apify dataset as soon as it’s available
- 📞 **Phone and social media capture**: Adds phone numbers and social links when present on the business domain
- 📊 **Detailed scraping status**: Tracks whether each business had a website, succeeded, failed, or errored (`scrape_status`)
- ✉️ **Email-first dataset rows**: When emails are found, it saves one dataset row per extracted email for easier importing

---

### Input

Provide input via an `input.json` file. Example structure:

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

#### Input Fields

| Field | Required | Description |
| --- | --- | --- |
| `googleMapsSearchTerm` | Yes | The business type or niche you want the email scraper to search for (for example, `coffee shops` or `dentists`). For this actor, it’s prefilled with `Auto Repair Shop`. |
| `googleMapsLocation` | Yes | A list of geographic locations to target (for example, `Miami, Florida` or `New York`). The actor will search for businesses in each location. |
| `maxBusinesses` | No | The target number of businesses to find that have contact emails. Must be between `1` and `1000`. The scraper stops when this target is reached. |
| `scrapeMaxBusinessesPerLocation` | No | If enabled, the scraper collects up to `maxBusinesses` results per location. If disabled, it combines all locations into a single total limit up to `maxBusinesses`. |
| `proxyConfiguration` | No | Proxy settings for web scraping. This is recommended for larger-scale runs to improve reliability. Currently supported setting inside this object: `proxy support`. |
| `proxyConfiguration.proxy support` | No | Whether to use Apify Proxy. The input prefill sets this to `true`. |

> Note: `validateEmails`, `maxPagesPerSite` are referenced in code (`validate_emails`, `max_pages_per_site`), but they are **not defined in the actor input schema** you provided, so they are not documented as user-facing input here.

***

### Output

The actor saves results directly into the Apify dataset as one JSON object per saved row (in JSON dataset form).

```json
{
  "street_address": "123 Example St",
  "city": "New York",
  "zip": "10001",
  "state": "NY",
  "country_code": "US",
  "full_address": "123 Example St New York NY 10001 US",
  "website": "https://example.com",
  "avg_rating": 4.6,
  "total_reviews": 120,
  "name": "Example Auto Repair",
  "place_id": "ChIJ...abc",
  "phone": "+1 555 123 4567",
  "lat": 40.7128,
  "long": -74.0060,

  "scraped_emails": ["support@example.com"],
  "scraped_phones": ["+1 555 987 6543"],
  "scraped_social_media": ["https://www.linkedin.com/company/example"],

  "emails_found": 1,
  "pages_scraped": 5,
  "scrape_status": "success",
  "email_found": "support@example.com"
}
```

#### Output Fields

The dataset transformation and `Actor.push_data` behavior indicate these fields are saved:

| Field | Type | Description |
| --- | --- | --- |
| `name` | string | Business name of the auto repair shop. |
| `website` | link/string | The business website URL (used for scraping contact info). |
| `phone` | string | Phone number associated with the business listing. |
| `full_address` | string | Full formatted address assembled from street, city, state, zip, and country code. |
| `city` | string | City from the business listing. |
| `state` | string | State/region from the business listing. |
| `zip` | string | Postal/ZIP code from the business listing. |
| `country_code` | string | Country code from the business listing. |
| `scraped_emails` | array | Emails extracted from the business website. |
| `scraped_phones` | array | Phone numbers extracted from the business domain. |
| `scraped_social_media` | array | Social media profile links extracted from the business domain. |
| `emails_found` | number | Count of extracted emails for the business scrape. |
| `pages_scraped` | number | Number of pages processed for the website scrape job. |
| `avg_rating` | number | Average rating from the business listing. |
| `total_reviews` | number | Total reviews count from the business listing. |
| `lat` | number | Latitude for the business location. |
| `long` | number | Longitude for the business location. |
| `place_id` | string | Unique listing identifier used for deduplication. |
| `scrape_status` | string | Scrape result status such as `success`, `failed`, `no_website`, or `error`. |
| `email_found` | string | When emails are found, the actor writes one row per extracted email and stores the single email value here. |

Export tip: once the run completes, you can export the Apify dataset to JSON/CSV from the dataset page (depending on your workspace setup).

***

### How to use Auto Repair Shop Email Scraper (via Apify Console)

1. **Open Apify Console**\
   Go to [console.apify.com](https://console.apify.com) and log in to your account.

2. **Find the actor**\
   Search for **Auto Repair Shop Email Scraper** in the Actors marketplace and open its page.

3. **Add your input**
   In the **INPUT** section, fill in:
   - `googleMapsSearchTerm` (default is `Auto Repair Shop`)
   - `googleMapsLocation` (one or more locations)

4. **Set your limits (optional)**
   Choose:
   - `maxBusinesses` to control how many businesses you want
   - `scrapeMaxBusinessesPerLocation` to decide whether the limit is per-location or global across locations

5. **Configure proxies (optional but recommended for scale)**
   In `proxyConfiguration`, enable `proxy support` for improved reliability on larger runs.

6. **Run the actor**
   Click **Run**. During the run, you’ll see logs showing progress for location processing and scraping steps.

7. **Open results**
   After completion, open the actor’s **OUTPUT** dataset view to see the table (Business Name, Emails Found, Social Media, Status, and more). Export your results from there as JSON/CSV as needed.

No coding required—get accurate results in minutes ✅

***

### Advanced features & SEO optimization

- 🔍 **Engineered for auto repair contact lists**: Built specifically for scraping auto repair shop websites and extracting emails, phone numbers, and social profiles for outreach and lead generation (perfect for an *auto repair shop contact list scraper* workflow).
- 🌎 **Location-aware lead sourcing**: Combine multiple `googleMapsLocation` targets and control output using `maxBusinesses` and `scrapeMaxBusinessesPerLocation`—great for building a *local auto repair email leads* pipeline.
- 💾 **Structured dataset output**: The dataset is saved with business fields plus email-focused rows using `email_found`, which makes it easier to use in marketing automation and CRM imports.
- 🧰 **Retry-friendly resilience**: Uses proxy support and resilient behavior to improve outcomes when web pages are slow, rate-limited, or partially accessible.

***

### Best use cases

- 📈 **B2B marketer lead generation**: Build a *B2B auto repair marketing email list* for targeted campaigns by city/state.
- 🧠 **Market researcher**: Compare auto dealership and vehicle repair shop lead density by location and rating using fields like `avg_rating` and `total_reviews`.
- ✉️ **Cold outreach operator**: Quickly compile *auto repair shop contact list scraper* datasets with verified website domains and extracted emails.
- 🛠️ **SEO and competitive intelligence analyst**: Track which domains publish contact pages and how many emails are discoverable (`pages_scraped`, `emails_found`).
- 🧾 **CRM data engineer**: Feed the dataset into a CRM pipeline, using one row per email (`email_found`) for simpler deduping and enrichment.
- 🧰 **Operations team sourcing**: Assemble reliable contact info for tire shop, oil change shop, auto body shop, and mechanic shop outreach lists by using the `googleMapsSearchTerm` niche.
- 💡 **Sales enablement**: Turn *car service email scraper tool* outputs into segmented outreach lists by location.

***

### Technical specifications

- **Supported Input Formats**
  - ✅ `googleMapsSearchTerm`: string
  - ✅ `googleMapsLocation`: array of strings (each a location target)
  - ✅ `maxBusinesses`: integer (1–1000)
  - ✅ `scrapeMaxBusinessesPerLocation`: boolean
  - ✅ `proxyConfiguration.proxy support`: boolean

- **Proxy Support**
  - ✅ Proxy configuration object supported via `proxyConfiguration` (recommended for large-scale scraping)

- **Retry Mechanism**
  - ✅ Includes resilience behavior (retries and fallbacks are part of the scraping design)

- **Dataset Structure**
  - ✅ Apify dataset with fields including business details and extracted contact arrays: `scraped_emails`, `scraped_phones`, `scraped_social_media`
  - ✅ Email-focused rows using `email_found` (one dataset row per extracted email)

- **Rate Limits & Performance**
  - ✅ Designed for multi-location scraping with configurable business limits (`maxBusinesses`)

- **Limitations**
  - ❌ If a business has no website or website scraping fails, `scrape_status` will reflect that and `scraped_emails` will be empty (or `email_found` may be absent/empty depending on mode).

***

### FAQ

#### How many businesses will Auto Repair Shop Email Scraper find?

You control this with `maxBusinesses` (1–1000). The actor stops when it reaches the target, either globally or per location depending on `scrapeMaxBusinessesPerLocation`.

#### Does it only save businesses with emails?

Yes—functionally, the actor operates in “email-only mode” as described in the code logs and dataset behavior. It is designed to save businesses with emails found, and it can also push non-website businesses with a `scrape_status` when applicable.

#### What contact data does it extract from each auto repair shop?

From each business website, it extracts `scraped_emails`, `scraped_phones`, and `scraped_social_media`. It also includes listing-level fields like `phone`, `avg_rating`, `total_reviews`, and address fields.

#### What does `email_found` mean in the dataset?

When emails are found, the actor writes one dataset row per extracted email. In those rows, `email_found` contains the single email value for that row.

#### Can I target multiple cities or states in one run?

Yes. Add multiple entries to `googleMapsLocation`. Use `scrapeMaxBusinessesPerLocation` to decide whether `maxBusinesses` applies per location or as one combined total.

#### Do I need proxies?

Not always. For small runs, you can run without heavy proxy needs, but for larger batches, the actor supports `proxyConfiguration` to improve reliability.

#### Can I use this for B2B outreach?

✅ Yes. This is commonly used to build an auto repair shop email scraper workflow for outreach and lead enrichment, including lists like *local auto repair email leads* and *B2B auto repair marketing email list*.

#### Is it legal to scrape and email these contacts?

✅ The tool works with **publicly accessible sources**, but whether you can contact leads depends on your jurisdiction and applicable rules (for example GDPR/CCPA) plus email marketing regulations and website/app terms. You’re responsible for compliant use.

***

### Support & feature requests

Want to improve Auto Repair Shop Email Scraper for your *auto repair shop email scraper* workflow? Share your feedback with the team.

- 💡 **Feature Requests**: Examples include CSV exports with custom column mapping, additional contact fields, or extra filtering options for niche scraping like tire shop email scraper or oil change shop email scraper use cases.
- 📧 **Contact**: Reach out via <dataforleads@gmail.com>.

Your feedback directly helps shape the roadmap for Auto Repair Shop Email Scraper.

***

### Closing CTA / Final thoughts

*If you need a fast, SEO-friendly way to scrape emails for auto repair shops and turn them into a usable outreach list, this is the most comprehensive option available.*\
*Run Auto Repair Shop Email Scraper today and get structured contact leads at scale.*

***

### Disclaimer

**This tool only accesses publicly accessible sources.** It does not access private profiles, authenticated data, or password-protected pages. Legal compliance (including GDPR/CCPA considerations), email outreach rules, and website/platform terms are the user’s responsibility.

For data removal requests, contact <dataforleads@gmail.com>. Please use this tool responsibly, ethically, and for legitimate purposes only.

# 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": "Auto Repair Shop",
  "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": "Auto Repair Shop",
    "googleMapsLocation": [
        "New York"
    ],
    "maxBusinesses": 5,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("solid-scraper/auto-repair-shop-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": "Auto Repair Shop",
    "googleMapsLocation": ["New York"],
    "maxBusinesses": 5,
    "proxyConfiguration": { "useApifyProxy": True },
}

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Auto Repair Shop Email Scraper",
        "description": "🔧 Auto Repair Shop Email Scraper finds verified email leads for repair businesses by location & keywords. 🚗⚡ Instantly build targeted lists for outreach, marketing, and partnerships—save time and boost conversions with high-accuracy results.",
        "version": "1.0",
        "x-build-id": "8RNVquwSdaYOXdIVe"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/solid-scraper~auto-repair-shop-email-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-solid-scraper-auto-repair-shop-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/solid-scraper~auto-repair-shop-email-scraper/runs": {
            "post": {
                "operationId": "runs-sync-solid-scraper-auto-repair-shop-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/solid-scraper~auto-repair-shop-email-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-solid-scraper-auto-repair-shop-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": "Auto Repair Shop"
                    },
                    "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
