# Chiropractors Email Scraper (`contacts-api/chiropractors-email-scraper`) Actor

Chiropractors email scraper to extract verified chiropractor emails from chiropractic clinics, wellness centers, private practices, and healthcare directories 📧🦴🩺 Perfect for healthcare outreach, recruitment, partnerships, and chiropractic lead generation.

- **URL**: https://apify.com/contacts-api/chiropractors-email-scraper.md
- **Developed by:** [Lead Heaven](https://apify.com/contacts-api) (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 $1.99 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

### 🧘 Chiropractors Email Scraper — Find Verified Leads in Minutes

> The fastest way to build a targeted chiropractors list. This actor searches Google Maps for chiropractors and related clinics in any city, crawls their websites, and extracts chiropractors email addresses, phone numbers, and social media profiles — all in one clean, export-ready dataset for immediate outreach and chiropractors leads.

---

#### 🚀 Quick Start

1. Enter your search term — e.g., "chiropractors" or "chiropractic clinic"
2. Add one or more target locations — e.g., "Miami, Florida"
3. Set your desired number of businesses with emails
4. Hit Run and get your results in minutes

No coding required. Export to CSV, JSON, or Excel instantly.

---

#### 💡 What Is the Chiropractors Email Scraper?

The Chiropractors Email Scraper is a purpose-built lead generation and contact discovery tool for:

- Healthcare and wellness marketing teams
- Local SEO agencies and lead gen shops
- B2B outreach and sales professionals
- Data providers and enrichment platforms

It combines Google Maps listing discovery with deep website crawling to extract publicly available contact data — producing an accurate, deduplicated chiropractors list ready for immediate use. Whether you need it as a chiropractors email finder, a chiropractors lead finder, or a chiropractors lead scraper, this actor covers all three in a single automated run.

Use it as your always-on chiropractors contact scraper to discover clinic websites, extract chiropractors email contacts, phones, and social profiles, and centralize everything into a structured dataset.

---

#### 📦 What Data Does It Extract?

| Field | Description |
|---|---|
| Business Name | Practice or clinic name from Google Maps |
| Website | Official website URL |
| Phone | Primary phone from the listing or website |
| Full Address | Complete address as listed |
| City / State / ZIP | Parsed location components |
| Country Code | ISO country code where available |
| Email Found | Primary email detected during crawl (if any) |
| Phone Numbers | Extra phone numbers discovered during crawl |
| Social Media Links | Facebook, Instagram, LinkedIn, X/Twitter, and more |
| # Emails | Total unique emails found per business |
| Pages Scraped | Number of website pages crawled per domain |
| Rating | Average Google Maps star rating |
| Reviews | Total number of Google reviews |
| Latitude / Longitude | Geo-coordinates for mapping and filtering |
| Place ID | Google Maps place identifier |
| Status | Per-record status: success, partial, or error |

This output is designed for direct ingestion into CRMs, spreadsheets, or APIs — ideal for a chiropractors contact finder workflow or any chiropractors data scraper pipeline.

---

#### ⚙️ Input Configuration

##### Minimal Example

```json
{
  "googleMapsSearchTerm": "chiropractors",
  "googleMapsLocation": ["Miami, Florida"],
  "maxBusinesses": 50
}
````

##### Full Example with All Options

```json
{
  "googleMapsSearchTerm": "chiropractors",
  "googleMapsLocation": [
    "Miami, Florida",
    "Orlando, Florida",
    "Tampa, Florida"
  ],
  "maxBusinesses": 200,
  "scrapeMaxBusinessesPerLocation": true,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

##### Input Parameters

| Parameter | Type | Required | Description |
|---|---|---|---|
| googleMapsSearchTerm | String | ✅ Yes | Business type or niche — e.g., "chiropractors", "chiropractic clinic" |
| googleMapsLocation | Array | ✅ Yes | One or more locations — e.g., \["Miami, Florida", "Austin, Texas"] |
| maxBusinesses | Number | ✅ Yes | Max businesses with emails to return (1–1,000). The run stops at this target |
| scrapeMaxBusinessesPerLocation | Boolean | ❌ No | If true, applies the cap per location; if false, uses a combined total |
| proxyConfiguration | Object | ❌ No | Proxy settings. Strongly recommended for large runs |

***

#### 📤 Sample Output

```json
[
  {
    "name": "Sunrise Chiropractic & Wellness",
    "website": "https://www.sunrisechirowellness.com",
    "phone": "+1 305-555-0199",
    "full_address": "1234 Coral Way, Miami, FL 33145, United States",
    "city": "Miami",
    "state": "FL",
    "zip": "33145",
    "country_code": "US",
    "email_found": "info@sunrisechirowellness.com",
    "scraped_phones": ["+1 305-555-0199", "+1 305-555-0123"],
    "scraped_social_media": [
      "facebook:https://facebook.com/sunrisechirowellness",
      "instagram:https://instagram.com/sunrise_chiro"
    ],
    "emails_found": 2,
    "pages_scraped": 12,
    "avg_rating": 4.7,
    "total_reviews": 96,
    "lat": 25.7549,
    "long": -80.2333,
    "place_id": "ChIJ1-EXAMPLEID",
    "scrape_status": "success"
  }
]
```

***

#### 🔧 How It Works — Under the Hood

```
Step 1 → Search Google Maps using your term + location
Step 2 → Collect business listings (name, address, phone, website)
Step 3 → Visit each website and crawl key pages (Home, Contact, About, Services)
Step 4 → Extract public emails, phone numbers, and social media links
Step 5 → Deduplicate and normalize all contact data
Step 6 → Return structured results ready for export or API consumption
```

The actor functions as both a discovery tool and an extractor: a chiropractors email extractor for websites plus a chiropractors contact finder for listing data — all orchestrated through the chiropractors email scraper pipeline.

***

#### ✨ Key Features

##### 🎯 Precise Location Targeting

Pinpoint clinics in any city, state, or region. Deliver hyper-local chiropractors leads by combining your search term and target locations.

##### 🔍 Deep Website Crawl

Goes beyond listings. Crawls homepages, contact pages, about pages, and footers to find every publicly available chiropractors email and phone number — acting as a reliable chiropractors email extractor.

##### 🌎 Multi-Location Scaling

Run across dozens of cities at once. Choose a combined cap or a per-location cap — perfect for building a large, multi-market chiropractors list.

##### 🧹 Smart De-Duplication

Automatically removes duplicate emails per domain so your data stays clean and actionable — no manual cleanup required after export.

##### 📊 Structured, CRM-Ready Output

Normalized fields and consistent formatting make it simple to drop results into HubSpot, Salesforce, Apollo, Instantly, or any outreach tool. Ideal for a chiropractors data scraper workflow.

##### 🛡️ Proxy-Ready for Reliability

Built-in proxy support ensures stable, large-scale runs without rate-limiting or IP blocks — essential for agency-level campaigns and sustained chiropractors leads acquisition.

##### ⏱️ Stop at Your Target

The run halts as soon as your maxBusinesses limit is reached — no wasted compute, no overage.

##### 🔄 Schedulable & Repeatable

Run daily, weekly, or monthly to continuously grow and refresh your chiropractors list using the same inputs.

***

#### 🎯 Use Cases

##### 💼 B2B Outreach & Sales

Quickly assemble pitch lists for local and multi-city campaigns. Use the tool as a chiropractors lead scraper to fuel cold email sequences and phone outreach.

##### 📣 Local & Regional Marketing

Create geo-targeted campaigns with verified contact details pulled directly from clinic websites — a practical chiropractors contact scraper for agencies.

##### 🧲 Lead Gen Agencies & Freelancers

Offer done-for-you prospecting. The platform doubles as a chiropractors lead finder and chiropractors email finder for repeatable client delivery.

##### 🗃️ CRM/DB Enrichment

Fill in missing emails, phones, and social profiles. Combine your existing NAP data with fresh contact info using this chiropractors contact finder.

##### 🧪 Research, Surveys, and Partnerships

Compile a chiropractors list for public health studies, insurer network development, or referral partnerships with complementary providers.

##### 🧰 Data Providers & App Builders

Use it as a dependable chiropractors data scraper to power dashboards, lead-scoring models, or local service marketplaces.

***

#### 📈 How Many Results Can You Get?

Scale from a small prospect list to a regional database — results depend on:

- Number of locations added
- Search term breadth (niche vs. broad)
- Website density and email visibility in each market
- maxBusinesses setting and per-location vs. combined mode
- Proxy configuration and run timeout

##### Typical Output Ranges

| Campaign Size | Businesses with Emails |
|---|---|
| Small (1–3 cities) | 20 – 100 |
| Medium (5–15 cities) | 200 – 600 |
| Large (20+ cities / states) | 800 – 1,000+ per run |

Run multiple times across different regions to continuously grow your chiropractors list without hitting any hard platform limits.

***

#### 🔌 Integrations & Export Options

Once your run completes, you can:

- JSON: Full structured data download
- CSV / Excel: Import directly into spreadsheets
- Apify API: Stream results into your own apps or workflows
- Zapier / Make: Trigger automations when new leads are found
- Webhooks: Push results to your CRM or pipeline on run completion

Plug directly into Instantly, Smartlead, Apollo, HubSpot, Salesforce, or any outreach platform that accepts CSV/JSON imports. Use it downstream as a reliable chiropractors data scraper for automated pipelines.

***

#### 🛠️ Step-by-Step Usage Guide

- Step 1 — Log in to Apify\
  Create a free account or sign in at apify.com.

- Step 2 — Open the Actor\
  Search for "Chiropractors Email Scraper" in the Apify Store and click Try for free.

- Step 3 — Set Your Search Term\
  Enter "chiropractors" or a niche variant like "pediatric chiropractor", "sports chiropractic", or "chiropractic clinic".

- Step 4 — Add Target Locations\
  Enter one or more city/state combos — e.g., "Miami, Florida", "Austin, Texas".

- Step 5 — Set Your Limit\
  Choose how many businesses with emails you want — 20 for a quick test, up to 1,000 for a full campaign.

- Step 6 — Choose Scaling Strategy\
  • Combined cap: The total across all locations combined\
  • Per-location cap: Applies your limit independently to each city

- Step 7 — Enable Proxies\
  Turn on Apify Proxy for stable, uninterrupted crawling at scale.

- Step 8 — Run 🚀\
  Click Start and let the Chiropractors Email Scraper do the work.

- Step 9 — Export\
  Download as JSON, CSV, or Excel — or pull via API straight into your stack.

***

#### ⚖️ Legal & Compliance

This actor collects only publicly available business contact information — emails and phone numbers published openly on websites or business listings.

Best practices to stay compliant:

- Only use publicly visible contact data
- Do not bypass login walls or paywalls
- Respect each website's robots.txt and Terms of Service
- Include an unsubscribe option in all outreach
- Follow applicable laws in your jurisdiction

Relevant regulations to be aware of:

| Regulation | Region |
|---|---|
| GDPR | European Union |
| CAN-SPAM Act | United States |
| CASL | Canada |
| PECR | United Kingdom |

This tool is intended for ethical business prospecting only. You are responsible for how you use the data collected with this chiropractors contact scraper.

***

#### ❓ Frequently Asked Questions

- Does this scrape private or personal emails?\
  No. The actor only extracts emails that are publicly visible on business websites — clinic inboxes, admin contacts, and general inquiry addresses. It operates as a compliant chiropractors email extractor.

- Can I search multiple cities in one run?\
  Yes. Add as many locations as needed. Use per-location capping for even geographic distribution of chiropractors leads.

- Does it deduplicate results?\
  Yes. Emails are deduplicated per domain to keep your chiropractors list accurate.

- Can I schedule recurring runs?\
  Absolutely. Use Apify's built-in scheduler to run weekly or monthly and keep your chiropractors leads fresh.

- What niches does the search term support?\
  Any Google Maps searchable term — try "sports chiropractor", "pediatric chiropractor", "chiropractic wellness", or "chiropractic clinic".

- Are proxies required?\
  Not for small runs, but strongly recommended for 200+ business runs to avoid rate limits and ensure stability.

- What export formats are available?\
  JSON, CSV, and Excel. You can also consume results via the Apify API or webhook — useful if you deploy it as a chiropractors lead finder in your stack.

- How is this different from manual Google searching?\
  Manual search is slow and inconsistent, and it won’t extract emails at scale. This tool automates discovery and contact extraction end-to-end — a true chiropractors email finder and chiropractors lead scraper in one.

- Can agencies white-label or resell this?\
  Yes. Run it on behalf of clients and deliver fresh chiropractors leads on a recurring basis.

- Does it capture social profiles too?\
  Yes. Where available, it extracts publicly linked profiles (Facebook, Instagram, LinkedIn, X/Twitter) alongside chiropractors email and phone data.

***

*Built for marketers, agencies, and sales teams who need accurate chiropractors leads at scale — fast. Put the chiropractors email scraper to work and grow your pipeline with verified contacts.*

***

#### 🧑‍💻 Support & Custom Solutions

Have a question, feature request, or need a custom build? We’re happy to help with:

- Custom input/output configurations
- Niche-specific adaptations (e.g., sports/pediatric chiropractic)
- Bulk or enterprise run support
- Integration assistance (CRM, webhook, automation)

For any help or custom solution, contact via this mail: scrapermindapi@gmail.com

# Actor input Schema

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

Enter the business type or niche for email scraper (e.g., 'chiropractors', 'chiropractic clinic').

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

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

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Chiropractors Email Scraper",
        "description": "Chiropractors email scraper to extract verified chiropractor emails from chiropractic clinics, wellness centers, private practices, and healthcare directories 📧🦴🩺 Perfect for healthcare outreach, recruitment, partnerships, and chiropractic lead generation.",
        "version": "1.0",
        "x-build-id": "hEHC5Cb0saJICaaVk"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/contacts-api~chiropractors-email-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-contacts-api-chiropractors-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/contacts-api~chiropractors-email-scraper/runs": {
            "post": {
                "operationId": "runs-sync-contacts-api-chiropractors-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/contacts-api~chiropractors-email-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-contacts-api-chiropractors-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., 'chiropractors', 'chiropractic clinic').",
                        "default": "chiropractors"
                    },
                    "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
