# NYC Restaurant Inspection Results Scraper (`automation-lab/nyc-restaurant-inspection-results-scraper`) Actor

Export NYC restaurant inspection grades, violations, scores, cuisine, address, phone, and geo fields from the official DOHMH Open Data API.

- **URL**: https://apify.com/automation-lab/nyc-restaurant-inspection-results-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Business
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## NYC Restaurant Inspection Results Scraper

Export NYC restaurant health inspection grades, violations, scores, cuisine, addresses, phone numbers, and source metadata from the public NYC Open Data DOHMH restaurant inspection API.

### What does NYC Restaurant Inspection Results Scraper do?

NYC Restaurant Inspection Results Scraper turns the public New York City Department of Health restaurant inspection dataset into clean Apify dataset rows.

It queries the Socrata Open Data API, applies your borough, ZIP code, cuisine, grade, date, CAMIS, or violation filters, and saves inspection records that are ready for spreadsheets, CRMs, BI tools, and compliance dashboards.

Use it when you need repeatable restaurant inspection data without building your own Socrata pagination, field mapping, and Apify export workflow.

### Who is it for?

- 🏙️ Local SEO agencies tracking restaurant reputation and grade changes.
- 🍽️ Restaurant consultants finding operators with repeat violations or poor scores.
- 🧾 Compliance teams monitoring health inspection outcomes by borough or ZIP code.
- 📍 Local lead generation teams enriching restaurant account lists.
- 🛡️ Insurance, lending, and risk teams screening food-service businesses.
- 📊 Data analysts building NYC restaurant quality dashboards.

### Why use this restaurant inspection scraper?

- ✅ Uses the official public NYC Open Data API.
- ✅ No browser automation or login required.
- ✅ Saves restaurant identity, address, cuisine, grade, score, violation, and geo fields.
- ✅ Supports incremental `recordDateFrom` workflows.
- ✅ Works with Apify datasets, API clients, webhooks, integrations, and MCP.
- ✅ Bounded by `maxItems` so test runs stay cheap.

### What data can you extract?

| Field | Description |
| --- | --- |
| `camis` | NYC DOHMH restaurant identifier |
| `dba` | Restaurant name |
| `borough` | NYC borough |
| `address` | Combined building, street, borough, and ZIP |
| `zipcode` | Restaurant ZIP code |
| `phone` | Phone number from the city dataset |
| `cuisine` | NYC cuisine description |
| `inspectionDate` | Inspection date |
| `inspectionType` | Cycle inspection, re-inspection, initial inspection, etc. |
| `action` | DOHMH action text |
| `violationCode` | Violation code such as `08A` |
| `violationDescription` | Violation description |
| `criticalFlag` | Critical / Not Critical / Not Applicable |
| `score` | Inspection score as a number |
| `grade` | Posted grade where available |
| `gradeDate` | Grade date |
| `recordDate` | Dataset record update date |
| `latitude` | Latitude |
| `longitude` | Longitude |
| `sourceApiUrl` | Exact API URL used for that page |

### How much does it cost to scrape NYC restaurant inspection results?

This actor uses pay-per-event pricing.

You pay a small start fee for each run and a per-record fee for every inspection row saved to the dataset.

Because the source is a public API and does not require residential proxies or browser automation, runs are designed to be lightweight and predictable.

### How to scrape NYC restaurant inspection data

1. Open the actor on Apify.
2. Set `maxItems` to the number of inspection rows you need.
3. Optionally choose a borough such as Manhattan, Brooklyn, Queens, Bronx, or Staten Island.
4. Add ZIP code filters such as `10002` or `11211`.
5. Add cuisine, grade, date, CAMIS, or violation filters if needed.
6. Run the actor.
7. Download the dataset as JSON, CSV, Excel, XML, or HTML.
8. Connect the run to webhooks or integrations for scheduled monitoring.

### Input options

#### Search scope

- `maxItems` limits the number of inspection rows.
- `borough` filters to one NYC borough.
- `zipCodes` filters to one or more postal codes.
- `cuisines` filters by exact NYC Open Data cuisine description.
- `grades` filters by grade values such as `A`, `B`, or `C`.

#### Date and compliance filters

- `inspectionDateFrom` includes inspections on or after a date.
- `inspectionDateTo` includes inspections on or before a date.
- `recordDateFrom` supports incremental refreshes based on NYC Open Data updates.
- `criticalOnly` keeps only rows with critical violations.
- `violationCodes` filters exact violation codes.

#### Restaurant identifiers

- `camisIds` lets you monitor specific restaurants by official NYC DOHMH CAMIS ID.

#### Advanced sorting

- `inspection_date_desc` returns the newest inspection dates first.
- `record_date_desc` returns the newest dataset updates first.
- `grade_date_desc` returns the newest grade dates first.
- `score_desc` returns highest inspection scores first.

### Example input

```json
{
  "maxItems": 100,
  "borough": "Manhattan",
  "zipCodes": ["10002"],
  "grades": ["A", "B", "C"],
  "orderBy": "inspection_date_desc"
}
````

### Example output

```json
{
  "camis": "40732665",
  "dba": "KATZ'S DELICATESSEN",
  "borough": "Manhattan",
  "address": "205, EAST HOUSTON STREET, Manhattan, 10002",
  "zipcode": "10002",
  "phone": "2122542246",
  "cuisine": "Sandwiches",
  "inspectionDate": "2024-04-24T00:00:00.000",
  "inspectionType": "Cycle Inspection / Re-inspection",
  "violationCode": "08A",
  "criticalFlag": "Not Critical",
  "score": 12,
  "grade": "A",
  "recordDate": "2026-07-02T06:00:15.000",
  "sourceDatasetId": "43nn-pn8j"
}
```

### Tips for better restaurant inspection exports

- Use `recordDateFrom` for scheduled monitoring jobs.
- Use ZIP codes for neighborhood prospecting.
- Use `criticalOnly` to focus on more serious compliance issues.
- Use `camisIds` when you already have a restaurant account list.
- Keep first runs small, inspect the dataset, then scale up.
- Combine `borough`, `cuisine`, and `grade` for targeted lead lists.

### Integrations and workflow patterns

- 📊 Send inspection records to Google Sheets for account research.
- 🧩 Push results into Airtable for sales operations.
- 📍 Join latitude and longitude with maps for territory planning.
- 🔔 Trigger Slack alerts when a scheduled run finds critical violations.
- 🧾 Export CSV files for compliance reviews.
- 🧠 Use Apify MCP to let AI agents query recent inspection results.

### API usage with Node.js

```js
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/nyc-restaurant-inspection-results-scraper').call({
  maxItems: 100,
  borough: 'Manhattan',
  zipCodes: ['10002'],
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### API usage with Python

```python
from apify_client import ApifyClient

client = ApifyClient('YOUR_APIFY_TOKEN')
run = client.actor('automation-lab/nyc-restaurant-inspection-results-scraper').call(run_input={
    'maxItems': 100,
    'borough': 'Manhattan',
    'zipCodes': ['10002'],
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

### API usage with cURL

```bash
curl -X POST 'https://api.apify.com/v2/acts/automation-lab~nyc-restaurant-inspection-results-scraper/runs?token=YOUR_APIFY_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"maxItems":100,"borough":"Manhattan","zipCodes":["10002"]}'
```

### MCP usage

You can use this actor through Apify MCP in Claude Code, Claude Desktop, and other MCP-compatible clients.

MCP server URL:

```text
https://mcp.apify.com/?tools=automation-lab/nyc-restaurant-inspection-results-scraper
```

Claude Code setup:

```bash
claude mcp add apify-nyc-inspections https://mcp.apify.com/?tools=automation-lab/nyc-restaurant-inspection-results-scraper
```

Claude Desktop JSON config:

```json
{
  "mcpServers": {
    "apify-nyc-inspections": {
      "url": "https://mcp.apify.com/?tools=automation-lab/nyc-restaurant-inspection-results-scraper"
    }
  }
}
```

Example prompts:

- "Run the NYC restaurant inspection scraper for Manhattan ZIP 10002 and summarize restaurants with critical violations."
- "Export 500 Brooklyn restaurant inspection rows and group them by cuisine and grade."
- "Monitor CAMIS IDs in this restaurant list and tell me which records changed since last week."

### Scheduling

Create a saved task on Apify when you need recurring monitoring.

Useful scheduled workflows include:

- Daily critical violation monitoring for client restaurants.
- Weekly grade changes by borough.
- Monthly restaurant lead enrichment for a sales territory.
- Incremental syncs using `recordDateFrom`.

### Data quality notes

The actor returns the fields published by NYC Open Data.

Some records can have missing grades, missing violation descriptions, or null location fields because the source dataset itself is incomplete for those rows.

The actor keeps those records instead of hiding them so analysts can make their own filtering decisions.

### FAQ

#### Why do I see multiple rows for the same restaurant?

The NYC dataset is inspection/violation based, not one row per restaurant. A restaurant can appear multiple times across inspections and violations.

#### Why is the grade empty?

Not every inspection row has a posted grade. Use `gradeDate` and `inspectionType` to understand when grades were assigned.

#### Why did my cuisine filter return no records?

Cuisine filters must match NYC Open Data cuisine descriptions exactly. Try running without a cuisine filter first, then copy the value from the dataset.

### Legality and responsible use

This actor uses a public NYC Open Data API endpoint. It does not bypass login, paywalls, or anti-bot controls.

You are responsible for using exported data in compliance with applicable laws, platform terms, and your own data governance rules.

### Related scrapers

Explore related Automation Lab actors:

- https://apify.com/automation-lab/google-maps-lead-finder
- https://apify.com/automation-lab/yelp-business-scraper
- https://apify.com/automation-lab/restaurant-lead-scraper
- https://apify.com/automation-lab/business-directory-scraper
- https://apify.com/automation-lab/open-data-scraper

### Changelog

- Initial version: public NYC Open Data restaurant inspection export with filters, pagination, and per-record billing.

### Support

If you need a new filter, output field, saved task example, or city inspection dataset added, open an issue from the Apify actor page.

### Summary

NYC Restaurant Inspection Results Scraper gives agencies, analysts, and compliance teams a reliable way to export New York City restaurant inspection records from the official public dataset.

It is built for repeatable monitoring, lead enrichment, and compliance workflows on Apify.

# Actor input Schema

## `maxItems` (type: `integer`):

Maximum number of inspection/violation rows to save. Keep low for test runs; increase for borough or citywide monitoring.

## `borough` (type: `string`):

Optional NYC borough filter.

## `zipCodes` (type: `array`):

Optional NYC ZIP codes to include, for example 10002 or 11211.

## `cuisines` (type: `array`):

Optional exact cuisine descriptions from NYC Open Data, such as Sandwiches, Coffee/Tea, Pizza, or American.

## `grades` (type: `array`):

Optional restaurant grade values to include.

## `inspectionDateFrom` (type: `string`):

Include inspections on or after this YYYY-MM-DD date.

## `inspectionDateTo` (type: `string`):

Include inspections on or before this YYYY-MM-DD date.

## `recordDateFrom` (type: `string`):

Incremental sync filter using the dataset record\_date field, in YYYY-MM-DD format.

## `criticalOnly` (type: `boolean`):

When enabled, only rows where critical\_flag is Critical are returned.

## `violationCodes` (type: `array`):

Optional exact violation code filters, for example 02B or 08A.

## `camisIds` (type: `array`):

Optional NYC DOHMH CAMIS restaurant identifiers for source-specific monitoring.

## `orderBy` (type: `string`):

Choose how NYC Open Data records are ordered before pagination.

## Actor input object example

```json
{
  "maxItems": 20,
  "borough": "Manhattan",
  "zipCodes": [
    "10002"
  ],
  "grades": [
    "A",
    "B",
    "C"
  ],
  "criticalOnly": false,
  "orderBy": "inspection_date_desc"
}
```

# Actor output Schema

## `overview` (type: `string`):

No description

# 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 = {
    "maxItems": 20,
    "borough": "Manhattan",
    "zipCodes": [
        "10002"
    ],
    "grades": [
        "A",
        "B",
        "C"
    ],
    "criticalOnly": false,
    "orderBy": "inspection_date_desc"
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/nyc-restaurant-inspection-results-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 = {
    "maxItems": 20,
    "borough": "Manhattan",
    "zipCodes": ["10002"],
    "grades": [
        "A",
        "B",
        "C",
    ],
    "criticalOnly": False,
    "orderBy": "inspection_date_desc",
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/nyc-restaurant-inspection-results-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 '{
  "maxItems": 20,
  "borough": "Manhattan",
  "zipCodes": [
    "10002"
  ],
  "grades": [
    "A",
    "B",
    "C"
  ],
  "criticalOnly": false,
  "orderBy": "inspection_date_desc"
}' |
apify call automation-lab/nyc-restaurant-inspection-results-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=automation-lab/nyc-restaurant-inspection-results-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "NYC Restaurant Inspection Results Scraper",
        "description": "Export NYC restaurant inspection grades, violations, scores, cuisine, address, phone, and geo fields from the official DOHMH Open Data API.",
        "version": "0.1",
        "x-build-id": "1fkf3jJOaW4Z2xYEe"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~nyc-restaurant-inspection-results-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-nyc-restaurant-inspection-results-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/automation-lab~nyc-restaurant-inspection-results-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-nyc-restaurant-inspection-results-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/automation-lab~nyc-restaurant-inspection-results-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-nyc-restaurant-inspection-results-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",
                "properties": {
                    "maxItems": {
                        "title": "Maximum inspection records",
                        "minimum": 1,
                        "maximum": 50000,
                        "type": "integer",
                        "description": "Maximum number of inspection/violation rows to save. Keep low for test runs; increase for borough or citywide monitoring.",
                        "default": 20
                    },
                    "borough": {
                        "title": "Borough",
                        "enum": [
                            "Bronx",
                            "Brooklyn",
                            "Manhattan",
                            "Queens",
                            "Staten Island"
                        ],
                        "type": "string",
                        "description": "Optional NYC borough filter."
                    },
                    "zipCodes": {
                        "title": "ZIP codes",
                        "type": "array",
                        "description": "Optional NYC ZIP codes to include, for example 10002 or 11211.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "cuisines": {
                        "title": "Cuisine descriptions",
                        "type": "array",
                        "description": "Optional exact cuisine descriptions from NYC Open Data, such as Sandwiches, Coffee/Tea, Pizza, or American.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "grades": {
                        "title": "Grades",
                        "type": "array",
                        "description": "Optional restaurant grade values to include.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "inspectionDateFrom": {
                        "title": "Inspection date from",
                        "type": "string",
                        "description": "Include inspections on or after this YYYY-MM-DD date."
                    },
                    "inspectionDateTo": {
                        "title": "Inspection date to",
                        "type": "string",
                        "description": "Include inspections on or before this YYYY-MM-DD date."
                    },
                    "recordDateFrom": {
                        "title": "Record date from",
                        "type": "string",
                        "description": "Incremental sync filter using the dataset record_date field, in YYYY-MM-DD format."
                    },
                    "criticalOnly": {
                        "title": "Critical violations only",
                        "type": "boolean",
                        "description": "When enabled, only rows where critical_flag is Critical are returned.",
                        "default": false
                    },
                    "violationCodes": {
                        "title": "Violation codes",
                        "type": "array",
                        "description": "Optional exact violation code filters, for example 02B or 08A.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "camisIds": {
                        "title": "CAMIS IDs",
                        "type": "array",
                        "description": "Optional NYC DOHMH CAMIS restaurant identifiers for source-specific monitoring.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "orderBy": {
                        "title": "Sort order",
                        "enum": [
                            "inspection_date_desc",
                            "record_date_desc",
                            "grade_date_desc",
                            "score_desc"
                        ],
                        "type": "string",
                        "description": "Choose how NYC Open Data records are ordered before pagination.",
                        "default": "inspection_date_desc"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```