# New York WARN Notices Scraper (`automation-lab/new-york-warn-notices-scraper`) Actor

Scrape official NY DOL WARN notices for layoffs and closures. Export employer, region, dates, source links, and optional PDF text.

- **URL**: https://apify.com/automation-lab/new-york-warn-notices-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

## New York WARN Notices Scraper

Extract official New York Department of Labor WARN layoff and plant-closing notices from the public NY DOL WARN notice pages.

Use it to monitor employer layoffs, closures, restructuring signals, and regional labor-market changes in New York State without manually checking government pages.

### What does New York WARN Notices Scraper do?

New York WARN Notices Scraper collects structured records from the official NY DOL WARN notice pages.

It reads the current WARN table, follows yearly archive pages, and saves one dataset item per notice.

Each item includes the employer name, NY DOL region, posted date, notice date, notice URL, source page URL, row number, stable key, and scrape timestamp.

Optional PDF text extraction can add a notice text snippet and best-effort hints for affected employees, layoff or closure type, county, location, and union metadata when those values are present in the notice document.

### Who is it for?

New York WARN Notices Scraper is built for teams that need official layoff and closure signals as soon as they appear.

### Who is this scraper for?

- Recruiters monitoring newly displaced talent pools.
- Outplacement firms tracking companies that may need transition services.
- B2B sales teams looking for churn, restructuring, vendor-risk, or facility-change triggers.
- Investors and analysts watching employer distress signals.
- Journalists covering layoffs and plant closings in New York.
- Economic development teams monitoring local labor-market changes.
- Labor-market researchers building repeatable WARN datasets.

### Why use this actor?

WARN notices are valuable because they are official, time-sensitive business signals.

Manual monitoring is slow.

The NY DOL pages are also split between a current page and archive pages.

This actor makes the workflow repeatable by turning those pages into normalized dataset rows.

### Data source

The actor uses public pages from the New York Department of Labor.

Default start URL:

```text
https://dol.ny.gov/warn-notices
````

The page currently redirects to the legacy WARN notices page.

The actor can discover linked archive pages such as 2024 and 2023 WARN notices.

### What data can you extract?

| Field | Description |
| --- | --- |
| `companyName` | Employer or company name from the WARN table |
| `region` | NY DOL region |
| `datePosted` | Normalized posted date |
| `noticeDate` | Normalized notice date |
| `noticeDateRaw` | Raw notice date text, including amended notes |
| `affectedEmployees` | Best-effort worker count from PDF text when enabled |
| `layoffClosureType` | Best-effort layoff, closure, relocation, temporary, or permanent hint |
| `location` | Best-effort site/location hint from PDF text |
| `county` | Best-effort county hint from PDF text |
| `industry` | Reserved nullable industry field |
| `naicsCode` | Reserved nullable NAICS field |
| `unionName` | Best-effort union hint from PDF text |
| `noticeUrl` | Linked NY DOL notice document |
| `sourcePageUrl` | Page where the table row was found |
| `sourceFileType` | Source type, usually PDF for notice links |
| `sourceRowNumber` | Row number in the source table |
| `stableKey` | Deterministic key for monitoring and deduplication |
| `noticeText` | Optional PDF text snippet |
| `scrapedAt` | ISO timestamp for the run |

### How much does it cost to scrape New York WARN notices?

This actor uses pay-per-event pricing.

You pay a small start fee plus a per-record charge for each WARN notice saved.

Keeping `includeNoticeText` disabled is the cheapest mode because it parses the public HTML tables only.

Enable PDF text extraction only when you need enriched fields from the notice document.

### How to use New York WARN Notices Scraper

1. Open the actor on Apify.
2. Keep the prefilled NY DOL WARN URL or add an archive page.
3. Set `maxItems` to the number of notices you need.
4. Optionally filter by `region`, `companyQuery`, or posted date.
5. Decide whether to enable `includeNoticeText`.
6. Run the actor.
7. Export the dataset as JSON, CSV, Excel, or via API.

### Input configuration

#### `startUrls`

Use NY DOL WARN pages or direct notice PDF URLs.

The default start URL is enough for most users.

#### `years`

Controls which archive years are discovered from the landing page.

The default includes 2025, 2024, and 2023.

#### `includeArchiveYears`

When enabled, the actor follows archive links discovered on the landing page.

Disable it if you only want the exact provided page.

#### `maxItems`

Limits the number of WARN notice records saved.

Use a small number for quick tests and a larger number for monitoring backfills.

#### `region`

Filters by region, for example `New York City`, `Long Island`, `Western`, `Capital`, or `Hudson Valley`.

#### `companyQuery`

Filters by employer substring.

#### `minDatePosted` and `maxDatePosted`

Use YYYY-MM-DD date strings to restrict records by posted date.

#### `includeNoticeText`

Fetches linked notice PDFs and attempts text extraction.

This can improve enrichment but is slower than table-only mode.

### Example input

```json
{
  "startUrls": [{ "url": "https://dol.ny.gov/warn-notices" }],
  "years": [2025, 2024, 2023],
  "includeArchiveYears": true,
  "maxItems": 100,
  "includeNoticeText": false
}
```

### Example filtered input

```json
{
  "startUrls": [{ "url": "https://dol.ny.gov/warn-notices" }],
  "region": "New York City",
  "companyQuery": "hotel",
  "maxItems": 25,
  "includeNoticeText": true
}
```

### Example output

```json
{
  "companyName": "Interstate Hotels, LLC. dba The Roosevelt Hotel",
  "region": "New York City",
  "datePosted": "2025-03-27",
  "noticeDate": "2025-03-21",
  "noticeDateRaw": "3/21/2025",
  "affectedEmployees": null,
  "layoffClosureType": null,
  "location": null,
  "county": null,
  "industry": null,
  "naicsCode": null,
  "unionName": null,
  "noticeUrl": "https://dol.ny.gov/warn-interstate-hotels-llc-dba-roosevelt-hotel-region-new-york-city-date-posted-3272025-notice-date",
  "sourcePageUrl": "https://dol.ny.gov/legacy-warn-notices",
  "sourceFileType": "pdf",
  "sourceRowNumber": 4,
  "stableKey": "...",
  "scrapedAt": "2026-07-04T00:00:00.000Z"
}
```

### Monitoring workflows

Run this actor on a schedule to watch for new notices.

Use `stableKey` to compare today's dataset with yesterday's dataset.

Send new rows to Slack, Airtable, Google Sheets, a CRM, or a database.

### Recruiting workflow

Recruiting teams can monitor affected employers by region.

A scheduled run can alert sourcers when new WARN notices appear in New York City, Long Island, or Western New York.

The output gives a source link for compliance and context.

### Sales and GTM workflow

Sales teams can use WARN notices as account signals.

Layoff and closure notices may indicate vendor churn, facility changes, budget pressure, restructuring, or urgent service needs.

Use the dataset to enrich account lists and trigger timely outreach.

### Investor and analyst workflow

Investors can track layoffs, closures, and amendments across a major labor market.

The actor preserves official source URLs so analysts can audit each row.

Regional filters help focus on specific metro areas or sectors.

### Integrations

You can connect the actor output to:

- Google Sheets for monitoring dashboards.
- Airtable for research queues.
- HubSpot or Salesforce for account triggers.
- Slack or email alerts for new notices.
- BigQuery, Snowflake, or Postgres for labor-market analysis.
- Apify webhooks for fully automated pipelines.

### API usage

#### Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/new-york-warn-notices-scraper').call({
  maxItems: 100,
  includeNoticeText: false
});
console.log(run.defaultDatasetId);
```

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("automation-lab/new-york-warn-notices-scraper").call(run_input={
    "maxItems": 100,
    "includeNoticeText": False,
})
print(run["defaultDatasetId"])
```

#### cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/automation-lab~new-york-warn-notices-scraper/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"maxItems":100,"includeNoticeText":false}'
```

### MCP usage

Use this actor from Claude Desktop or Claude Code through the Apify MCP server.

MCP URL:

```text
https://mcp.apify.com/?tools=automation-lab/new-york-warn-notices-scraper
```

Claude Code setup:

```bash
claude mcp add apify https://mcp.apify.com/?tools=automation-lab/new-york-warn-notices-scraper
```

Claude Desktop JSON configuration:

```json
{
  "mcpServers": {
    "apify-new-york-warn": {
      "url": "https://mcp.apify.com/?tools=automation-lab/new-york-warn-notices-scraper"
    }
  }
}
```

Example prompts:

- "Run the New York WARN Notices Scraper for the latest 100 notices."
- "Find WARN notices in New York City that mention hotels."
- "Compare today's WARN dataset with yesterday's dataset and summarize new employers."

### Tips for reliable runs

Start with table-only mode.

Use PDF text extraction only when you need enriched fields.

Set `maxItems` high enough for archive backfills.

Use date filters for scheduled monitoring.

Keep source URLs in downstream systems so every alert is auditable.

### FAQ

#### Is this an official NY DOL API?

No. The actor reads public NY DOL WARN pages and preserves source links for auditability.

#### Can I monitor only one region?

Yes. Use the `region` input to filter rows such as New York City, Long Island, Western, Capital, or Hudson Valley.

### Troubleshooting

#### Why are affected employees empty?

The public NY DOL table does not expose affected employee counts.

Enable `includeNoticeText` to fetch notice PDFs and attempt best-effort extraction.

Some PDFs may still omit or format counts in ways that cannot be reliably parsed.

#### Why did my run return fewer rows than expected?

Check `maxItems`, region filters, company filters, and date filters.

If archive discovery is disabled, the actor only parses the exact start pages you provided.

#### Why is PDF mode slower?

PDF mode downloads and parses one notice document per row.

For recurring monitors, table-only mode is usually enough to detect new notices.

### Legality and responsible use

This actor reads publicly available government pages.

Use the data responsibly and respect Apify's terms, the source website's terms, and applicable laws.

Do not use the output for discriminatory employment decisions or unlawful profiling.

### Related scrapers

- [California WARN Notices Scraper](https://apify.com/automation-lab/california-warn-notices-scraper)
- [Federal Register Regulatory Notices Scraper](https://apify.com/automation-lab/federal-register-regulatory-notices-scraper)
- [SEC Litigation Releases Scraper](https://apify.com/automation-lab/sec-litigation-releases-scraper)
- [OSHA Inspections Violations Scraper](https://apify.com/automation-lab/osha-inspections-violations-scraper)

### Changelog

Initial version extracts NY DOL WARN notice table rows and supports optional linked notice PDF text extraction.

### Support

If the NY DOL page changes or you need another WARN jurisdiction, open an issue on Apify.

### Dataset quality notes

The actor preserves both normalized dates and raw notice-date text.

Raw text is useful because amended notices often include multiple dates.

Rows include a stable key for repeat monitors.

### Performance notes

Table-only runs are lightweight HTTP runs.

PDF-enriched runs perform additional downloads and parsing.

For large backfills, keep `includeNoticeText=false` first, then run focused PDF-enriched jobs for records that need deeper detail.

# Actor input Schema

## `startUrls` (type: `array`):

Official NY DOL WARN landing/archive pages or direct notice PDF URLs. Leave the prefilled landing page to discover current and archive pages automatically.

## `years` (type: `array`):

Year archive pages to crawl from the NY DOL site when archive discovery is enabled.

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

Maximum WARN notice records to save. The default produces enough rows for monitoring while keeping first runs inexpensive.

## `region` (type: `string`):

Optional case-insensitive NY DOL region filter, for example New York City, Long Island, Western, Capital, or Hudson Valley.

## `companyQuery` (type: `string`):

Optional case-insensitive company/employer substring.

## `minDatePosted` (type: `string`):

Optional earliest NY DOL posted date in YYYY-MM-DD format.

## `maxDatePosted` (type: `string`):

Optional latest NY DOL posted date in YYYY-MM-DD format.

## `includeArchiveYears` (type: `boolean`):

When enabled, the actor follows yearly WARN archive links from the landing page before applying filters and maxItems.

## `includeNoticeText` (type: `boolean`):

When enabled, the actor fetches each linked notice PDF and includes a text snippet plus best-effort affected-worker, closure/layoff, county, location, and union hints. Keep disabled for faster monitoring runs.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://dol.ny.gov/warn-notices"
    }
  ],
  "years": [
    2025,
    2024,
    2023
  ],
  "maxItems": 20,
  "includeArchiveYears": true,
  "includeNoticeText": false
}
```

# 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 = {
    "startUrls": [
        {
            "url": "https://dol.ny.gov/warn-notices"
        }
    ],
    "years": [
        2025,
        2024,
        2023
    ],
    "maxItems": 20,
    "includeArchiveYears": true,
    "includeNoticeText": false
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/new-york-warn-notices-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 = {
    "startUrls": [{ "url": "https://dol.ny.gov/warn-notices" }],
    "years": [
        2025,
        2024,
        2023,
    ],
    "maxItems": 20,
    "includeArchiveYears": True,
    "includeNoticeText": False,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/new-york-warn-notices-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 '{
  "startUrls": [
    {
      "url": "https://dol.ny.gov/warn-notices"
    }
  ],
  "years": [
    2025,
    2024,
    2023
  ],
  "maxItems": 20,
  "includeArchiveYears": true,
  "includeNoticeText": false
}' |
apify call automation-lab/new-york-warn-notices-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "New York WARN Notices Scraper",
        "description": "Scrape official NY DOL WARN notices for layoffs and closures. Export employer, region, dates, source links, and optional PDF text.",
        "version": "0.1",
        "x-build-id": "o9XHYcxDgG0JlaK6c"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~new-york-warn-notices-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-new-york-warn-notices-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~new-york-warn-notices-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-new-york-warn-notices-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~new-york-warn-notices-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-new-york-warn-notices-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": {
                    "startUrls": {
                        "title": "NY DOL WARN pages or notice PDFs",
                        "type": "array",
                        "description": "Official NY DOL WARN landing/archive pages or direct notice PDF URLs. Leave the prefilled landing page to discover current and archive pages automatically.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "years": {
                        "title": "Archive years to discover",
                        "type": "array",
                        "description": "Year archive pages to crawl from the NY DOL site when archive discovery is enabled.",
                        "default": [
                            2025,
                            2024,
                            2023
                        ]
                    },
                    "maxItems": {
                        "title": "Maximum WARN notices",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum WARN notice records to save. The default produces enough rows for monitoring while keeping first runs inexpensive.",
                        "default": 20
                    },
                    "region": {
                        "title": "Region filter",
                        "type": "string",
                        "description": "Optional case-insensitive NY DOL region filter, for example New York City, Long Island, Western, Capital, or Hudson Valley."
                    },
                    "companyQuery": {
                        "title": "Company name contains",
                        "type": "string",
                        "description": "Optional case-insensitive company/employer substring."
                    },
                    "minDatePosted": {
                        "title": "Earliest posted date",
                        "type": "string",
                        "description": "Optional earliest NY DOL posted date in YYYY-MM-DD format."
                    },
                    "maxDatePosted": {
                        "title": "Latest posted date",
                        "type": "string",
                        "description": "Optional latest NY DOL posted date in YYYY-MM-DD format."
                    },
                    "includeArchiveYears": {
                        "title": "Discover archive year pages",
                        "type": "boolean",
                        "description": "When enabled, the actor follows yearly WARN archive links from the landing page before applying filters and maxItems.",
                        "default": true
                    },
                    "includeNoticeText": {
                        "title": "Extract notice PDF text",
                        "type": "boolean",
                        "description": "When enabled, the actor fetches each linked notice PDF and includes a text snippet plus best-effort affected-worker, closure/layoff, county, location, and union hints. Keep disabled for faster monitoring runs.",
                        "default": false
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
