# Optometrist Accurate Email Scraper (`contacts-api/optometrist-accurate-email-scraper`) Actor

Optometrist accurate email scraper to collect verified optometrist emails from clinics, eye care centers, and healthcare directories 📧👓 Ideal for outreach, partnerships, and optical industry lead generation.

- **URL**: https://apify.com/contacts-api/optometrist-accurate-email-scraper.md
- **Developed by:** [Lead Heaven](https://apify.com/contacts-api) (community)
- **Categories:** Lead generation, Other
- **Stats:** 2 total users, 1 monthly users, 0.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.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

### 👓 Optometrist Accurate Email Scraper — Find Verified Optometry Contacts Fast

> The fastest way to build a targeted optometry contact list. This optometrist accurate email scraper finds “Optometrist Accurate” and related eye care businesses on Google Maps, crawls their websites, and extracts public emails, phones, and social profiles — producing clean, export-ready optometrist accurate leads for sales, marketing, and research. Use it as your optometrist accurate email extractor and optometrist accurate data scraper in one automated workflow.

---

#### 🚀 Quick Start

1. Enter your search term — e.g., "Optometrist Accurate" or "optometrist", "eye care clinic"
2. Add one or more target locations — e.g., "New York", "Los Angeles, CA"
3. Set the maximum number of businesses with emails to collect
4. Enable Apify Proxy for scale (recommended)
5. Click Run and get your optometry contacts in minutes

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

---

#### 💡 What Is The Optometrist Accurate Email Scraper?

The Optometrist Accurate Email Scraper is a specialized lead generation and contact discovery tool for:

- Eyewear manufacturers and distributors
- B2B SaaS selling to optometry practices (EHR, scheduling, marketing)
- Sales development reps and local marketers
- Researchers, analysts, and data teams

It blends Google Maps discovery with deep website crawling to extract publicly available contact data for optometry clinics and eye care centers. Whether you need an optometrist accurate lead finder, an optometrist accurate lead scraper, an optometrist accurate contact scraper, or an optometrist accurate contact finder — this actor unifies all four in a single run and outputs a structured optometrist accurate list.

---

#### 📦 What Data Does It Extract?

- Business Name — Practice or company name from Google Maps
- Website — Official site URL from listing or website discovery
- Phone — Primary phone from listing or website
- Full Address — Complete address as listed
- City / State / ZIP — Parsed location components
- Country Code — ISO code where available
- Emails — All public emails found during crawl
- Additional Phones — Extra numbers detected on the website
- Social Media Links — Facebook, Instagram, LinkedIn, X/Twitter, etc.
- Email Count — Total unique emails per business
- Pages Scraped — Number of pages crawled per domain
- Rating — Average Google Maps star rating
- Reviews — Total number of Google reviews
- Latitude / Longitude — Coordinates for mapping or filtering
- Place ID — Google Maps place identifier
- Scrape Status — Per-record status: success, partial, or error

These outputs make it an effective optometrist accurate email extractor and optometrist accurate data scraper for streamlined enrichment.

---

#### ⚙️ Input Configuration

##### Minimal Example

```json
{
  "googleMapsSearchTerm": "Optometrist Accurate",
  "googleMapsLocation": ["New York"],
  "maxBusinesses": 50
}
````

##### Full Example With All Options

```json
{
  "googleMapsSearchTerm": "Optometrist Accurate",
  "googleMapsLocation": [
    "New York",
    "Boston, Massachusetts",
    "Philadelphia, Pennsylvania"
  ],
  "maxBusinesses": 200,
  "scrapeMaxBusinessesPerLocation": true,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

##### Input Parameters

- googleMapsSearchTerm (String, required) — The business type or niche to search (e.g., "Optometrist Accurate", "optometrist", "eye exam clinic").
- googleMapsLocation (Array, required) — One or more target locations (e.g., \["New York", "Los Angeles, CA"]).
- maxBusinesses (Number, optional but recommended) — Maximum businesses with emails to return (1–1,000). The run halts once reached.
- scrapeMaxBusinessesPerLocation (Boolean, optional) — If true, applies the cap per location; if false, cap is combined across all locations.
- proxyConfiguration (Object, optional) — Proxy settings. Strongly recommended for reliability and scale.

***

#### 📤 Sample Output

```json
[
  {
    "name": "BrightSight Optometry",
    "website": "https://www.brightsightoptometry.com",
    "phone": "+1 212-555-0147",
    "full_address": "245 W 29th St, New York, NY 10001, United States",
    "city": "New York",
    "state": "NY",
    "zip": "10001",
    "country_code": "US",
    "scraped_emails": [
      "info@brightsightoptometry.com",
      "appointments@brightsightoptometry.com"
    ],
    "scraped_phones": ["+1 212-555-0147", "+1 212-555-0198"],
    "scraped_social_media": [
      "facebook:https://facebook.com/brightsightoptometry",
      "instagram:https://instagram.com/brightsightoptometry"
    ],
    "emails_found": 2,
    "pages_scraped": 11,
    "avg_rating": 4.7,
    "total_reviews": 203,
    "lat": 40.7492,
    "long": -73.9967,
    "place_id": "ChIJ9-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, Footer, etc.)\
Step 4 → Extract public emails, phone numbers, and social media links\
Step 5 → Deduplicate, validate emails, and normalize data fields\
Step 6 → Return structured results ready to export or consume via API

Designed to function as an optometrist accurate lead finder and optometrist accurate lead scraper in a single pass, the optometrist accurate email scraper streamlines discovery and extraction from end to end.

***

#### ✨ Key Features

##### 🎯 Precise Location Targeting

Add any city, state, or region to pinpoint optometry practices in your exact target area — perfect for building geo-focused optometrist accurate leads and a reliable optometrist accurate list.

##### 🔍 Deep Website Crawl

Goes beyond the listing to crawl the site’s Home, Contact, About, and common footer sections, surfacing every publicly available email and phone — a built-in optometrist accurate email finder and optometrist accurate email extractor.

##### 🌎 Multi-Location Scaling

Run across dozens of cities in one go. Choose a combined cap or a per-location cap — ideal for building a multi-market optometrist accurate list without manual effort.

##### 🧹 Smart De-Duplication

Removes duplicate emails per domain and normalizes records, so your CRM imports stay clean. This doubles as an optometrist accurate contact scraper for enrichment.

##### ⚙️ Flexible Capping Strategy

Stop exactly at your target using maxBusinesses. Use scrapeMaxBusinessesPerLocation to distribute evenly across cities — a handy approach for balanced optometrist accurate leads.

##### 🛡️ Proxy-Ready For Reliability

Built with proxy support for consistent, large-scale runs without rate limits or IP blocks — an essential advantage for any optometrist accurate data scraper.

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

Normalized field names and consistent data types make imports easy for HubSpot, Salesforce, Apollo, Instantly, and more.

##### 🔄 Schedulable & Repeatable

Use Apify’s scheduler to refresh your optometrist accurate list weekly or monthly — keep optometrist accurate leads up-to-date without manual work.

***

#### 🎯 Use Cases

##### 💼 B2B Outreach & Sales

Target optometry clinics with eyewear frames, medical devices, practice management software, or marketing services. Treat it as your optometrist accurate lead finder and optometrist accurate lead scraper to feed cold email or calling pipelines.

##### 📣 Local & Regional Marketing

Build city-level campaigns with accurate contacts and phones. Keep a refreshed optometrist accurate list for recurring campaigns and promotions.

##### 🧑‍⚕️ Vendor & Partnership Development

Identify clinics for product trials, CE workshops, or referral partnerships. The tool doubles as an optometrist accurate contact finder to map out regional networks.

##### 🗃️ CRM/Database Enrichment

Fill missing emails, phones, and social links in existing records. Use the optometrist accurate email finder with your current domain list for rapid enrichment.

##### 📚 Research & Market Sizing

Quickly assemble optometry contact data by city or state for studies, surveys, or competitive analysis — reliably powered by an optometrist accurate data scraper.

***

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

Output depends on:

- Number of locations added
- Breadth of your search term (e.g., "optometrist" vs. "pediatric optometry")
- Website density and email visibility per market
- Your maxBusinesses cap and per-location strategy
- Proxy configuration and run timeout

Typical Ranges:

- Small (1–3 cities): 20–100 businesses with emails
- Medium (5–15 cities): 200–600 businesses with emails
- Large (20+ cities/states): 800–1,000+ per run

Run repeatedly across new regions to grow your optometrist accurate list without hitting platform limits.

***

#### 🔌 Integrations & Export Options

- JSON — Complete structured data
- CSV / Excel — Import directly into spreadsheets and CRMs
- Apify API — Stream results into your apps or data pipelines
- Zapier / Make — Trigger automations when new optometrist accurate leads appear
- Webhooks — Push records to your CRM on run completion

Plug into Instantly, Smartlead, Apollo, HubSpot, Salesforce, Close, Pipedrive, or any system that accepts CSV/JSON. Keep a living optometrist accurate list synced to your workflows.

***

#### 🛠️ 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 “Optometrist Accurate Email Scraper” in the Apify Store and click Try for free.

Step 3 — Set Your Search Term\
Enter “Optometrist Accurate” or a broader niche term like “optometrist,” “eye doctor,” “eye care clinic.”

Step 4 — Add Target Locations\
Add one or more locations — e.g., “New York”, “Los Angeles, CA”, “Miami, Florida”.

Step 5 — Set Your Limit\
Choose how many businesses with emails to return (1–1,000). The run halts automatically at your cap.

Step 6 — Choose Capping Strategy

- Combined cap: Total across all locations
- Per-location cap: Applies your max to each city independently

Step 7 — Enable Proxies\
Turn on Apify Proxy for steady, large-scale crawling.

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

Step 9 — Export\
Download CSV/JSON/Excel or consume results programmatically via the Apify API.

***

#### ⚖️ Legal & Compliance

This actor collects only publicly available business contact information (emails, phones, social links) published on the open web.

Best practices:

- Use publicly visible contact data only
- Do not bypass login walls or paywalls
- Respect each website’s robots.txt and Terms of Service
- Include an unsubscribe/opt-out in every outreach
- Follow applicable laws in your jurisdiction

Relevant regulations:

- GDPR (EU)
- CAN-SPAM Act (US)
- CASL (Canada)
- PECR (UK)

This tool is intended for ethical business prospecting. You are responsible for how you use the data collected.

***

#### ❓ Frequently Asked Questions

Q: Does this scrape private or personal inboxes?\
A: No. It only extracts emails visible on public webpages, making it a compliant optometrist accurate contact scraper.

Q: Can I search multiple cities in a single run?\
A: Yes. Add as many locations as you like and use the per-location cap for even distribution.

Q: Will it deduplicate emails and domains?\
A: Yes. Emails are deduplicated per domain to keep your optometrist accurate list clean and ready for outreach.

Q: Is proxy usage required?\
A: Not for small tests, but proxies are strongly recommended for 200+ businesses to avoid rate limits — especially if you’re using it as an optometrist accurate data scraper.

Q: Can I treat this as an email finder/enricher for existing domains?\
A: Yes. You can seed with known businesses and use it as an optometrist accurate email finder or optometrist accurate email extractor for enrichment.

Q: What’s the difference between the lead finder and lead scraper use?\
A: As an optometrist accurate lead finder, it discovers new businesses via Google Maps. As an optometrist accurate lead scraper, it crawls sites to extract emails and phones for those businesses.

Q: What export formats are available?\
A: JSON, CSV, and Excel — plus API and webhooks for automation.

Q: Can agencies use this for recurring client deliveries?\
A: Absolutely. Schedule weekly runs to refresh optometrist accurate leads and keep campaigns current.

***

#### 📦 Output Fields Reference

- name
- website
- phone
- full\_address
- city
- state
- zip
- country\_code
- scraped\_emails
- scraped\_phones
- scraped\_social\_media
- emails\_found
- pages\_scraped
- avg\_rating
- total\_reviews
- lat
- long
- place\_id
- scrape\_status

***

#### 🧑‍💻 Support & Custom Solutions

Have a question, need a feature, or want a custom build or integration? We can tailor the flow, add fields, or connect directly to your CRM/warehouse so your optometrist accurate leads land exactly where you need them.

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., '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": "Optometrist Accurate",
  "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": "Optometrist Accurate",
    "googleMapsLocation": [
        "New York"
    ],
    "maxBusinesses": 5,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

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

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Optometrist Accurate Email Scraper",
        "description": "Optometrist accurate email scraper to collect verified optometrist emails from clinics, eye care centers, and healthcare directories 📧👓 Ideal for outreach, partnerships, and optical industry lead generation.",
        "version": "1.0",
        "x-build-id": "N1UzkcBZkJ8bhdTST"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/contacts-api~optometrist-accurate-email-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-contacts-api-optometrist-accurate-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~optometrist-accurate-email-scraper/runs": {
            "post": {
                "operationId": "runs-sync-contacts-api-optometrist-accurate-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~optometrist-accurate-email-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-contacts-api-optometrist-accurate-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": "Optometrist Accurate"
                    },
                    "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
