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

🚗✨ Email Scraper for Auto Repair Shops extracts verified contact emails from shop websites & listings. Save time on outreach and target local businesses for leads, partnerships, and marketing—perfect for sales teams and B2B research. 📩

- **URL**: https://apify.com/scraperoka/auto-repair-shop-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

### Auto Repair Shop Email Scraper 🚀

Manually hunting for auto repair shop emails and contact details across the web wastes hours of outreach time. **Auto Repair Shop Email Scraper** is a fast way to scrape business contact information (emails, phone numbers, and social media profiles) from publicly available sources—ideal for marketers, recruiters, and growth teams who need targeted lists at scale. In a single run, you can build a car repair marketing email list with thousands of useful fields available minutes after you start.

---

### What You Get: Sample Output

Here's a sample record from a single run:

```json
{
  "name": "Riverside Auto Repair",
  "website": "https://www.riversideautorepair.com",
  "phone": "+1-212-555-0198",
  "full_address": "1207 River Rd New York NY 10012 US",
  "city": "New York",
  "state": "NY",
  "zip": "10012",
  "country_code": "US",
  "scraped_emails": ["support@riversideautorepair.com"],
  "scraped_phones": ["+1-212-555-0198", "+1-212-555-0120"],
  "scraped_social_media": ["https://www.facebook.com/riversideautorepair"],
  "emails_found": 1,
  "pages_scraped": 8,
  "avg_rating": 4.6,
  "total_reviews": 212,
  "lat": 40.745,
  "long": -73.99,
  "place_id": "ChIJVxwZk9lZwokR1mE3bK8h6mU",
  "scrape_status": "success",
  "email_found": "support@riversideautorepair.com"
}
````

**Output Fields (what you’ll see in the dataset):**

| Field | Type | What It Tells You |
|---|---|---|
| `name` | string | The auto service provider’s business name you can reference in outreach |
| `website` | string | The business website URL to verify and route follow-up messages |
| `phone` | string | A primary phone value captured for the business listing |
| `full_address` | string | A ready-to-use mailing address string for CRM notes |
| `city` | string | Helps you filter your vehicle repair shop email list by market |
| `state` | string | Helps you segment by region for location-based campaigns |
| `zip` | string | Useful for local targeting and routing lead workflows |
| `country_code` | string | Standardized geography for aggregation and deduping |
| `scraped_emails` | array | Email addresses found on the business’s website(s) |
| `scraped_phones` | array | Additional phone numbers found during website scraping |
| `scraped_social_media` | array | Social links captured to enrich your lead profiles |
| `emails_found` | number | How many emails were discovered for the business |
| `pages_scraped` | number | Indicates how many pages/URLs were processed on the site |
| `avg_rating` | number | Listing rating to prioritize higher-trust prospects |
| `total_reviews` | number | Review count to gauge business popularity |
| `scrape_status` | string | Shows whether the record is `success`, `failed`, `no_website`, or `error` |

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

***

### Why Auto Repair Shop Email Scraper?

There are a lot of ways to pull data from local directories and business listings—here’s what sets **Auto Repair Shop Email Scraper** (and auto dealership email scraper workflows) apart.

#### Location-based collection that respects your limits

You set `googleMapsLocation` and a `maxBusinesses` cap so the actor stops once it hits your target. This makes it ideal for local auto repair email list building without endless runs.

#### Targeted contact enrichment from websites

After discovering businesses, it scrapes each website and extracts emails, phone numbers, and social media profiles. The result is a CRM-friendly dataset for B2B auto repair leads email scraper outreach.

#### Deduplicated, business-first output

The actor keeps a `place_id`-based uniqueness check while building the final results, helping you avoid duplicates in your mechanic shop email scraper pipeline.

#### Resilient website scraping with clear status tracking

When website scraping fails or a business has no website, the dataset includes empty contact arrays and a `scrape_status` value like `no_website` or `failed`. You get transparency to decide what to retry or exclude.

***

### Configuring Your Run

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

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

| Parameter | Required | What It Does |
|---|---|---|
| `googleMapsSearchTerm` | ✅ | The business type or niche you want the email scraper to target (prefilled with `Auto Repair Shop`) |
| `googleMapsLocation` | ✅ | One or more geographic locations to search (example: `["Miami, Florida"]`, but you can provide multiple) |
| `maxBusinesses` | ⬜ | Target number of businesses to find (bounded between `1` and `1000`). The scraper stops when this target is reached |
| `scrapeMaxBusinessesPerLocation` | ⬜ | When enabled, collect up to `maxBusinesses` results per location; when disabled, combine all locations into one total limit |
| `proxyConfiguration` | ⬜ | Proxy settings for scraping (recommended for large-scale scraping) |
| ↳ `proxyConfiguration.proxy support` | ⬜ | Routes requests through Apify Proxy for improved reliability |

***

### Core Capabilities

#### Auto repair shop contact scraping (emails, phones, social links)

Auto Repair Shop Email Scraper is designed to extract contact information including emails, phone numbers, and social media profiles. This gives you more than just addresses—perfect for auto body shop email scraper and mechanic shop email scraper lead lists.

#### Built for local market list building

By using `googleMapsLocation` and a structured `googleMapsSearchTerm`, it supports local discovery for vehicle repair shop email list and targeted email finder for auto repair shops workflows. You can run per city or combine multiple locations into one output.

#### Adjustable result control for clean prospecting pipelines

Use `maxBusinesses` and `scrapeMaxBusinessesPerLocation` to keep the dataset aligned with your sales or research needs. This helps avoid overwhelming your CRM when building a car repair marketing email list.

#### Website enrichment with immediate dataset saving

Website contact harvesting happens after business discovery, and records are pushed to the Apify dataset as results are processed. If no website is available, the actor still pushes the business (unless email-only mode prevents it—see scraping behavior below in the dataset `scrape_status`).

#### Proxy support for reliable large-scale scraping

`proxyConfiguration` is included to support more reliable scraping at scale. This is especially helpful when building large lists of auto service provider email scraping prospects across multiple runs.

In short: discover relevant auto repair businesses, enrich contacts from their websites, and export a structured dataset for outreach.

***

### Who Gets the Most Out of This

Here’s how different teams put Auto Repair Shop Email Scraper to work:

**Sales Development Reps** — Use it to build a targeted list of nearby shops and enrich each record with website contact emails and phone numbers. You end up with a usable contact dataset for faster cold outreach and better response rates.

**Local SEO and Marketing Teams** — Combine location targeting with business ratings/review counts to prioritize high-visibility prospects. That makes it easier to grow a car repair marketing email list for campaigns focused on specific cities and neighborhoods.

**B2B Lead Researchers** — The dataset includes structured fields like `place_id`, `avg_rating`, `total_reviews`, and `full_address`, which makes it practical for segmentation and deduping. You can also use the scraped social links to enrich CRM records beyond email addresses.

**CRM and Operations Analysts** — You can track success and failure outcomes using `scrape_status` and inspect counts like `emails_found` and `pages_scraped`. This supports data QA and consistent downstream transformations.

**Automation Developers** — Trigger runs via the Apify API and feed dataset rows into your systems. The output is designed to be integration-ready for pipelines that build a vehicle repair shop email list on schedule.

***

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

No coding needed. Here's how to run Auto Repair Shop Email Scraper from start to finish:

1. **Open the actor on Apify** — go to [console.apify.com](https://console.apify.com) and search for Auto Repair Shop Email Scraper.
2. **Enter your inputs** — set `googleMapsSearchTerm`, add one or more values in `googleMapsLocation`, and adjust `maxBusinesses` if you want a larger or smaller run.
3. **Configure proxy settings** — enable `proxyConfiguration` (including `proxyConfiguration.proxy support`) for more reliable scraping at scale.
4. **Hit Run and watch the live log** — monitor progress as the actor discovers businesses and scrapes websites for contact details.
5. **View results in the dataset tab** — each record includes fields like emails, phones, social links, and `scrape_status`.
6. **Export as JSON, CSV, or Excel** — download directly from the Apify dashboard when your dataset looks right.

The whole process takes under 5 minutes to set up.

***

### Integrations & Export Options

Once your data is collected, Auto Repair Shop Email Scraper plugs directly into your existing workflow.

Export formats are available straight from the dataset tab, including JSON, CSV, and Excel—useful for auto body shop email scraper databases, CRM imports, and spreadsheet-based research.

For more automation, you can use Apify’s API and integrations (including webhook-style automation patterns) to send results to your tools. If you want no-code orchestration, Zapier or Make workflows can also move your car repair marketing email list into downstream systems.

For deeper integration details, refer to the Apify API documentation at https://apify.com/docs/api.

***

### Pricing & Free Trial

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

You’ll typically start with a small test run to confirm data quality, then scale up using Apify’s paid compute. Exact costs depend on your Apify plan and usage; for the most accurate pricing, check the Apify pricing page.

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

***

### Reliability & Performance

| What We Handle | How |
|---|---|
| Rate limits | Designed to scrape reliably with configurable request routing and pacing |
| Proxy reliability | Supports `proxyConfiguration` to improve stability across runs |
| Website coverage variability | Tracks outcome using `scrape_status` (including `no_website`, `failed`, and `error`) |
| Data freshness for outreach | Extracts emails, phone numbers, and social links from business websites during the run |
| Clear dataset structure | Outputs consistent fields for emails found, phone/social extractions, and scrape progress |

**Limitations:** Results depend on the availability of websites and publicly accessible contact information. If a business has no website or no discoverable emails on the website, the record will reflect that via empty contact arrays and `scrape_status`.

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

***

### Frequently Asked Questions

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

Apify offers a free tier to get started. You can run a small test job to confirm that the output matches your expectations before scaling up.

#### Do I need to log in to use Auto Repair Shop Email Scraper?

No login is required for the actor’s workflow. It scrapes business and contact information from publicly available sources.

#### How accurate is the data?

Accuracy depends on what each business publishes on its website and publicly available sources. The actor collects emails, phones, and social links that it can extract during the run.

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

You control this using `maxBusinesses` (bounded from `1` to `1000`). If you enable `scrapeMaxBusinessesPerLocation`, it will collect up to `maxBusinesses` results per location; otherwise, it applies a combined total limit.

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

The data is as fresh as the moment you run the actor. Since it scrapes during the run, you’ll get up-to-date contact details for that time window.

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

The actor works with **publicly available data**. You are responsible for complying with GDPR, CCPA, and applicable laws or platform rules when storing and using the harvested contact information.

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

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

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

Yes—Apify supports scheduled runs. This is useful if you want to keep an auto service provider email scraping pipeline refreshed on a recurring cadence.

#### Can I access this via API?

Yes. You can trigger the actor and retrieve results programmatically using the Apify API. See https://apify.com/docs/api for details.

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

If an error occurs for a business, the dataset reflects it using fields like `scrape_status` (for example, `failed` or `error`). Your run still preserves the records that were already processed and pushed to the dataset.

***

### Need Help or Have a Request?

Got a question about Auto Repair Shop Email Scraper or want a new feature added? Reach out at <dataforleads@gmail.com>. We respond quickly and can help you tailor runs for local auto repair email list building.

Feature ideas we can build next include webhook notifications on completion and additional CSV-friendly structuring.

***

### Disclaimer & Responsible Use

*Auto Repair Shop Email Scraper is the fastest, most reliable way to build targeted contact lists from publicly available data — start your free run today.*

The actor uses **publicly available data** and does not access private accounts, login-gated content, or password-protected pages. It’s your responsibility to comply with GDPR, CCPA, and any applicable platform terms when you use and store the harvested emails. 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., '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("scraperoka/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("scraperoka/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 scraperoka/auto-repair-shop-email-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=scraperoka/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": "🚗✨ Email Scraper for Auto Repair Shops extracts verified contact emails from shop websites & listings. Save time on outreach and target local businesses for leads, partnerships, and marketing—perfect for sales teams and B2B research. 📩",
        "version": "1.0",
        "x-build-id": "1UNseig5dGcHnGtWP"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scraperoka~auto-repair-shop-email-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scraperoka-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/scraperoka~auto-repair-shop-email-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scraperoka-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/scraperoka~auto-repair-shop-email-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scraperoka-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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
