# New York State Contract Reporter Scraper (`automation-lab/new-york-state-contract-reporter-scraper`) Actor

Extract NYSCR bid opportunities with CR numbers, agencies, due dates, categories, locations, and public notes for New York vendors.

- **URL**: https://apify.com/automation-lab/new-york-state-contract-reporter-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 State Contract Reporter Scraper

Extract open procurement opportunities from the New York State Contract Reporter (NYSCR) into clean, structured Apify datasets.

Use this actor to monitor New York public-sector bid listings, proposal deadlines, agencies, categories, locations, and public notes without manually refreshing the NYSCR search page.

### What does New York State Contract Reporter Scraper do?

New York State Contract Reporter Scraper turns NYSCR search result pages into structured procurement records.

It reads the public `/Ads/Search` results, paginates through matching opportunities, and saves one dataset item per contract reporter listing.

Each record includes the CR number, title, agency, division, issue date, due date, location, category, ad type, public note, source URL, and scrape timestamp.

The actor is HTTP based, so it is fast and lightweight compared with browser automation.

### Who is it for?

🧾 **Government vendors** use it to discover bid opportunities that match their services.

🏗️ **Construction and engineering firms** use it to watch categories such as environmental, architectural, surveying, and transportation.

💻 **IT and software vendors** use it to monitor new technology-related opportunities.

📈 **Capture managers** use it to feed opportunity records into CRM, spreadsheets, and alerting workflows.

📰 **Bid-intelligence platforms** use it to add New York State Contract Reporter coverage to tender databases.

### Why use this actor?

Manual NYSCR monitoring is repetitive.

A proposal team may need to check new opportunities every day, copy titles into spreadsheets, and route due dates to sales teams.

This actor automates that first collection step and produces export-ready data.

It is especially useful when you need repeatable monitoring rather than one-off browsing.

### What data can you extract?

| Field | Description |
| --- | --- |
| `crNumber` | NYSCR Contract Reporter number |
| `title` | Opportunity title |
| `agency` | Issuing agency or public entity |
| `division` | Agency division when shown |
| `issueDate` | Published/issue date shown by NYSCR |
| `dueDate` | Response due date shown by NYSCR |
| `location` | Project or service location when shown |
| `category` | NYSCR category |
| `adType` | Ad type, such as General |
| `note` | Public note from the listing card |
| `status` | Listing status used by the actor |
| `sourceUrl` | NYSCR search URL for the CR number |
| `scrapedAt` | ISO timestamp when the row was extracted |

### How much does it cost to scrape NYSCR opportunities?

This actor uses pay-per-event pricing.

There is a small run-start event and a per-opportunity event.

The exact per-item tiers are shown on the Apify Store pricing panel and may be updated after cost validation.

For planning, start with a small `maxItems` value, review output quality, then scale to larger monitoring runs.

### Quick start

1. Open the actor on Apify.

2. Enter one or more keywords, such as `construction`, `software`, or `engineering`.

3. Choose a date filter: Today, Last 7 days, or All time.

4. Set the maximum number of opportunities.

5. Run the actor.

6. Export the dataset as JSON, CSV, Excel, XML, or HTML.

### Input options

#### Keywords

Use keywords to search titles, contract numbers, or CR numbers.

Leave keywords empty to collect open opportunities sorted by issue date.

#### Date range

Use `Today` for daily checks.

Use `LastWeek` for a recurring weekly monitor.

Use `All` when building a broader historical lead list.

#### Maximum opportunities

`maxItems` caps the number of records saved.

Use a small number for testing and a larger number for production monitoring.

#### Direct NYSCR search URLs

Advanced users can paste NYSCR `/Ads/Search` URLs into `startUrls`.

The actor keeps the query parameters and paginates from the provided URL.

#### Agency ID

If you already know a NYSCR `GovernmentId`, pass it in `governmentId` to narrow results to one agency.

### Example input: weekly procurement monitor

```json
{
  "keywords": ["construction", "engineering"],
  "dateFilter": "LastWeek",
  "maxItems": 100,
  "status": "Open",
  "sort": "-DateIssued"
}
````

### Example input: IT opportunity search

```json
{
  "keywords": ["software"],
  "dateFilter": "All",
  "maxItems": 50,
  "status": "Open",
  "sort": "-DateDue"
}
```

### Example output

```json
{
  "crNumber": "2136420",
  "title": "Dorsey Street and Lake Colby Parking Lots Stormwater Upgrades and Lake Colby Beach Site Civil and Engineering Work",
  "agency": "Saranac Lake, Village of",
  "division": "Community Development Department",
  "issueDate": "7/3/2026",
  "dueDate": "7/24/2026",
  "location": "Dorsey Street Parking Lot and Lake Colby Beach Parking Lot and Site",
  "category": "Environmental",
  "adType": "General",
  "note": "Responses are due by July 17, 2026...",
  "status": "Open",
  "sourceUrl": "https://www.nyscr.ny.gov/Ads/Search?Keyword=2136420",
  "scrapedAt": "2026-07-06T04:23:33.999Z"
}
```

### Common workflows

📬 **Daily bid alerting**: schedule a run with `dateFilter` set to `Today`, then send the dataset to Slack, email, or a webhook.

📊 **CRM enrichment**: export CR numbers, agencies, titles, and due dates into Salesforce, HubSpot, Airtable, or Google Sheets.

🧠 **Market intelligence**: track categories and agencies over time to understand which departments are issuing relevant opportunities.

🔎 **Proposal pipeline review**: sort by due date and route high-fit opportunities to capture managers.

### Integrations

Apify datasets can be consumed by Zapier, Make, webhooks, API clients, and Apify integrations.

Use CSV or Excel exports for analysts.

Use JSON for data pipelines.

Use webhooks to trigger notifications after each scheduled run.

### 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/new-york-state-contract-reporter-scraper').call({
  keywords: ['construction'],
  dateFilter: 'LastWeek',
  maxItems: 100,
});

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/new-york-state-contract-reporter-scraper').call(run_input={
    'keywords': ['software'],
    'dateFilter': 'All',
    'maxItems': 50,
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

### API usage with cURL

```bash
curl "https://api.apify.com/v2/acts/automation-lab~new-york-state-contract-reporter-scraper/runs?token=$APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"keywords":["engineering"],"dateFilter":"LastWeek","maxItems":100}'
```

### MCP: use from Claude and other AI tools

You can connect this actor through the Apify MCP server.

Install it in Claude Code with:

```bash
claude mcp add apify-nyscr --url "https://mcp.apify.com/?tools=automation-lab/new-york-state-contract-reporter-scraper"
```

Use this JSON configuration for MCP clients that accept server config files:

```json
{
  "mcpServers": {
    "apify-nyscr": {
      "url": "https://mcp.apify.com/?tools=automation-lab/new-york-state-contract-reporter-scraper"
    }
  }
}
```

Use a tool URL scoped to this actor:

```text
https://mcp.apify.com/?tools=automation-lab/new-york-state-contract-reporter-scraper
```

Example prompts:

- "Find NYSCR software opportunities issued in the last week and summarize due dates."

- "Extract construction bid listings from the New York State Contract Reporter and group them by agency."

- "Monitor open environmental opportunities and prepare a CSV for our capture team."

### Tips for better results

Use specific keywords when you need focused results.

Use multiple keywords when different teams monitor different services.

Keep `maxItems` high enough to cover all matches for broad searches.

Use `LastWeek` for recurring schedules to reduce duplicate review.

Use `All` when discovering opportunities for the first time.

### Limitations

The actor extracts public search result cards.

NYSCR full opportunity details may require login or sign-up on the source website.

Attachment links are not available on the public listing cards and are therefore not included unless NYSCR exposes them publicly in the result page.

The source website controls result availability, dates, and text formatting.

### Troubleshooting

#### Why did I get zero records?

Try a broader keyword, set `dateFilter` to `All`, or leave keywords empty.

Very specific CR numbers or phrases may not have open matches.

#### Why do some fields look blank?

NYSCR does not show every field for every listing.

The actor saves `null` when a public listing card omits a division, location, or note.

#### Can I scrape closed opportunities?

The public search form is optimized for open listings.

If you pass `status` as `Closed` or `All`, NYSCR may still control what is returned.

### Data freshness

Each run fetches live NYSCR search pages.

`scrapedAt` shows when a record was collected.

Schedule the actor daily or weekly for repeat monitoring.

### Legality

This actor collects publicly visible procurement listing data.

### Is it legal to scrape NYSCR?

This actor collects publicly visible procurement listing data.

You are responsible for using the data in accordance with applicable laws, NYSCR terms, and your organization's compliance policies.

Do not use extracted data for spam or unauthorized contact.

### Related scrapers

Related Automation Lab actors for procurement and public-sector workflows:

- https://apify.com/automation-lab/sam-gov-scraper

- https://apify.com/automation-lab/ungm-scraper

- https://apify.com/automation-lab/ted-eu-tenders-scraper

Use the NYSCR scraper when your workflow specifically needs New York State Contract Reporter listings.

### FAQ

#### Does this actor require my NYSCR login?

No. It uses the public search result pages.

#### Does it download bid attachments?

Not in the MVP. Public search cards do not expose downloadable attachments.

#### Can I schedule it?

Yes. Use Apify schedules with `dateFilter` set to `Today` or `LastWeek`.

#### Can it monitor multiple keywords?

Yes. Add multiple keywords and the actor will search each one, de-duplicate CR numbers, and stop at `maxItems`.

#### What if NYSCR changes its website?

If the public HTML structure changes, open an actor issue with a failed run URL and the input you used.

### Output quality notes

The actor de-duplicates records by CR number.

Dates are preserved as shown by NYSCR.

The `sourceUrl` field points to a public search by CR number so users can quickly find the listing in NYSCR.

### Changelog

Initial version extracts public NYSCR open opportunity search results with keyword and date filters.

# Actor input Schema

## `keywords` (type: `array`):

Optional title, contract number, or CR number searches. Leave empty to scrape open opportunities sorted by latest issue date.

## `dateFilter` (type: `string`):

NYSCR date filter for opportunity issue dates.

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

Maximum NYSCR opportunity records to save.

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

Optional /Ads/Search URLs copied from NYSCR. The actor will paginate from each URL.

## `governmentId` (type: `string`):

Optional numeric NYSCR GovernmentId if you already know the agency filter ID.

## `status` (type: `string`):

Open opportunities are the commercially useful default for vendor monitoring.

## `sort` (type: `string`):

NYSCR sorting option.

## Actor input object example

```json
{
  "keywords": [
    "construction",
    "software"
  ],
  "dateFilter": "LastWeek",
  "maxItems": 20,
  "startUrls": [
    {
      "url": "https://www.nyscr.ny.gov/Ads/Search?DateFilter=LastWeek&Status=Open&Top=50&Sort=-DateIssued"
    }
  ],
  "status": "Open",
  "sort": "-DateIssued"
}
```

# 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 = {
    "keywords": [
        "construction",
        "software"
    ],
    "dateFilter": "LastWeek",
    "maxItems": 20,
    "startUrls": [
        {
            "url": "https://www.nyscr.ny.gov/Ads/Search?DateFilter=LastWeek&Status=Open&Top=50&Sort=-DateIssued"
        }
    ],
    "status": "Open",
    "sort": "-DateIssued"
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/new-york-state-contract-reporter-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 = {
    "keywords": [
        "construction",
        "software",
    ],
    "dateFilter": "LastWeek",
    "maxItems": 20,
    "startUrls": [{ "url": "https://www.nyscr.ny.gov/Ads/Search?DateFilter=LastWeek&Status=Open&Top=50&Sort=-DateIssued" }],
    "status": "Open",
    "sort": "-DateIssued",
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/new-york-state-contract-reporter-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 '{
  "keywords": [
    "construction",
    "software"
  ],
  "dateFilter": "LastWeek",
  "maxItems": 20,
  "startUrls": [
    {
      "url": "https://www.nyscr.ny.gov/Ads/Search?DateFilter=LastWeek&Status=Open&Top=50&Sort=-DateIssued"
    }
  ],
  "status": "Open",
  "sort": "-DateIssued"
}' |
apify call automation-lab/new-york-state-contract-reporter-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "New York State Contract Reporter Scraper",
        "description": "Extract NYSCR bid opportunities with CR numbers, agencies, due dates, categories, locations, and public notes for New York vendors.",
        "version": "0.1",
        "x-build-id": "cvVlpMgJ10gc3JLTC"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~new-york-state-contract-reporter-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-new-york-state-contract-reporter-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-state-contract-reporter-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-new-york-state-contract-reporter-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-state-contract-reporter-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-new-york-state-contract-reporter-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": {
                    "keywords": {
                        "title": "Keywords",
                        "type": "array",
                        "description": "Optional title, contract number, or CR number searches. Leave empty to scrape open opportunities sorted by latest issue date.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "dateFilter": {
                        "title": "Date range",
                        "enum": [
                            "Today",
                            "LastWeek",
                            "All"
                        ],
                        "type": "string",
                        "description": "NYSCR date filter for opportunity issue dates.",
                        "default": "LastWeek"
                    },
                    "maxItems": {
                        "title": "Maximum opportunities",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum NYSCR opportunity records to save.",
                        "default": 20
                    },
                    "startUrls": {
                        "title": "Direct NYSCR search URLs",
                        "type": "array",
                        "description": "Optional /Ads/Search URLs copied from NYSCR. The actor will paginate from each URL.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "governmentId": {
                        "title": "Agency ID",
                        "type": "string",
                        "description": "Optional numeric NYSCR GovernmentId if you already know the agency filter ID."
                    },
                    "status": {
                        "title": "Opportunity status",
                        "enum": [
                            "Open",
                            "Closed",
                            "All"
                        ],
                        "type": "string",
                        "description": "Open opportunities are the commercially useful default for vendor monitoring.",
                        "default": "Open"
                    },
                    "sort": {
                        "title": "Sort order",
                        "enum": [
                            "-DateIssued",
                            "DateIssued",
                            "-DateDue",
                            "DateDue",
                            "Title",
                            "Agency",
                            "Category"
                        ],
                        "type": "string",
                        "description": "NYSCR sorting option.",
                        "default": "-DateIssued"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
