# Cannabis License Radar: New-Licensee Alerts by Type & County (`yungstentech/cannabis-license-radar`) Actor

Name the NY cannabis license types, county or region to watch and get each newly-issued licensee as a deduped BD row (entity, license type, county, issue date) from the NY OCM open-data feed on your schedule. Alerts cover licenses issued from enrollment forward; report mode returns a recent cohort.

- **URL**: https://apify.com/yungstentech/cannabis-license-radar.md
- **Developed by:** [Paul Mikulskis](https://apify.com/yungstentech) (community)
- **Categories:** Lead generation, Automation, Agents
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1,500.00 / 1,000 new-licensee alerts

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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

Cannabis License Radar watches newly-issued **New York cannabis licenses** and delivers each new licensee to you as a clean, deduplicated alert row with the full business-development payload, pulled from the New York Office of Cannabis Management (OCM) official open-data feed on your own schedule. Name the license types, county or region you care about; every scheduled run finds the licenses issued since the last run and hands you the new ones. It runs on the Apify platform, so you get API access, scheduling, integrations and monitoring for free, and there is nothing to log into and no key to manage.

### What does Cannabis License Radar do?

New York issues adult-use cannabis licenses in a steady, lumpy stream: retail dispensaries, microbusinesses, cultivators, processors and distributors, roughly twenty a month statewide (24 to 38 across the full months measured, self-probed from the OCM feed at data.ny.gov/resource/jskf-tt3q, 2026-07-06). Each new licensee is a fresh business that needs banking, insurance, point-of-sale, security, real estate, packaging and legal help, and just over half of recent issuance is **not retail** (52%, same probe), so the storefront and menu monitors miss them.

This actor turns the state's own [OCM Current Licenses dataset](https://data.ny.gov/Economic-Development/Cannabis-License-Verification-Tool/jskf-tt3q) into a standing watch. You define a filter once, put it on a schedule, and each run:

1. Queries the OCM feed for your filter (license types, county or region, optional status).
2. Aggregates the raw feed by license number, so a licensee operating several sites is one alert, not several.
3. Compares the result against your filter's memory and delivers only the **newly-issued** licensees you have not seen before.
4. Optionally POSTs the new alerts to a webhook you choose.

### Why use Cannabis License Radar?

- **First contact.** Reach a new licensee in the days after issuance, before the field is crowded.
- **The non-retail wedge.** Cultivators, processors and distributors are just over half of recent issuance (52%, same probe) and are invisible to retail and menu trackers.
- **Deduplicated and forward-looking.** You are alerted once per licensee, from the day you start watching, never a wall of old back-catalog.
- **Verifiable.** Every row carries the OCM source URL so you can confirm any license against the state's own record.

### How to use Cannabis License Radar

1. Open the **Input** tab and choose your filter: pick one or more license types, and optionally a county or region.
2. Set a **Filter name** (for example `ny-nonretail`). This names the watch so its memory persists across your scheduled runs.
3. Run it once. The first run establishes a **baseline** of the licenses already issued for your filter and charges nothing. It watches forward from that moment.
4. Put it on a **Schedule**. The OCM feed posts weekly, so a daily schedule catches each new posting promptly; a weekly schedule keeps pace with the source.
5. Each later run delivers the new licensees issued since your last run.

#### Worked example

Input (also the store default):

```json
{ "mode": "watch", "licenseTypes": ["OCMCULT", "OCMPROC", "OCMDIST"], "filterName": "default" }
````

The **first run** returns a single baseline row and charges nothing:

```json
{ "rowType": "baseline-digest", "filterName": "default", "billing": "uncharged",
  "note": "Baseline established: 774 current licensee(s) on file for this filter; watching forward from today." }
```

A **later run**, once a new cultivator is issued, returns one alert row (billed once):

```json
{ "rowType": "new-licensee", "licenseNumber": "OCM-CULT-26-000242",
  "entityName": "Sofi Farms LLC", "licenseType": "Adult-Use Cultivator License",
  "licenseStatus": "Active", "issuedDate": "2026-05-11", "county": "Kings", "region": "Brooklyn",
  "address": null, "locations": [{ "address": null, "locationId": "..." }],
  "businessPurpose": "Adult-Use Cultivation", "billing": "included-tier", "sourceUrl": "https://data.ny.gov/resource/jskf-tt3q.json" }
```

Retail dispensary alerts additionally include the storefront street address. Cultivator, processor and distributor alerts identify the licensee by entity name, license type, county and region, issue date, license number and business purpose: OCM publishes a street address for only about a quarter of non-retail licensees, which is why the cultivator above shows `address: null`.

You can download the dataset in JSON, CSV, Excel or HTML.

### Demo dataset

The public demo dataset is at https://api.apify.com/v2/datasets/4kt3GZIRJqIFJmJlv/items?format=json\&clean=true. It was generated by a live report-mode run over New York non-retail cannabis licenses issued in 2026-04 through 2026-06. The dataset contains one cohort-report row with the nested licensee list, including license number, entity name, license type, issue date, county, region, business purpose, and source URL. It is a representative back-catalog report, not a watch enrollment.

### Output data

Each new-licensee alert row carries:

| Field | Meaning |
|---|---|
| `licenseNumber` | The license number (also the dedupe key). |
| `entityName`, `dba` | The new licensee and its trade name. |
| `licenseType`, `licenseTypeCode`, `licenseStatus` | What was licensed and its current status. |
| `issuedDate`, `effectiveDate`, `expirationDate` | The issuance and validity dates. |
| `address`, `locations` | The primary street address where OCM publishes one (always for retail, about a quarter of non-retail licensees), plus every site the license operates. |
| `county`, `region` | Territory. |
| `applicationNumber`, `businessPurpose` | Application reference and the licensed purpose. |
| `billing`, `sourceUrl` | How the row was billed, and the OCM URL to re-verify it. |

Uncharged event rows (covered by the watch fee) carry a `changeType` of `status-change`, `expiration-set` or `appearance-old-issued`. A weekly digest row summarizes the filter's activity. All are clearly marked.

### Modes

- **watch** (default): the standing filter-watch described above.
- **report**: a one-off cohort of every license issued in a type, county or region and period (`period` as `YYYY-MM` or `YYYY-MM..YYYY-MM`), billed once. This is the right surface for the recent back-catalog. Registered Organization (`OCMRO`) licenses are available here.
- **unwatch**: forget a saved filter's memory.
- **list-events**: replay a filter's change-event history.

### Pricing

This actor is pay-per-event. Actor start is free.

- **Filter watch-month, $5.00** per named filter per calendar month. Your account's **first month is free** (alerts still bill during it). A baseline run and a stale-feed run are never charged.
- **New-licensee alert, $1.50** each for the first 40 in a filter-month, then **$0.75** each beyond that. New York issuance is modest (the busiest month in the 2026-07-06 probe was 38), so the volume tier effectively never triggers on New York alone.
- **Cohort report, $29.00** per report-mode run.
- `maxAlertsPerRun` (default 50) caps any single run; anything withheld is not billed until delivered and redelivers on the next run.

A typical New York filter costs about **$5 per month plus roughly $1.50 per new licensee it finds** (tens per month statewide at most).

### Baseline-forward behavior

Alerts begin from the day you start watching a filter. The first run seeds the licenses already on file (uncharged) and watches forward, so you are never billed for the historical back-catalog. If you **widen a saved filter** under the same name (for example dropping the county to go statewide), the actor re-baselines it, again with no back-catalog charge. For the recent back-catalog, use **report mode**.

### Latency and volume, stated plainly

The OCM feed posts on a **weekly** cadence, so the honest latency is "within about a week of OCM posting," not same-day. New York issuance is a **niche new-issuance stream measured in tens of new licensees per month statewide**, not a firehose. This actor is built for coverage and first contact, not volume.

### FAQ and support

- **Where does the data come from?** The New York OCM Current Licenses dataset on the state open-data portal. It is a public licensee record; the actor reads it without any login or key.
- **Is this legal and compliant?** It reads a public government record and redistributes public license facts. It is registry information, not advice.
- **Can I get another state?** New York is first; other states are on the roadmap. Use the Issues tab to request one or report a problem.

# Actor input Schema

## `mode` (type: `string`):

What this run does. watch: establish (first run) or advance a standing filter-watch and deliver newly-issued licensees. unwatch: forget a saved filter's memory. list-events: replay this filter's change-event history. report: one-off newly-issued cohort report for a type/county/period (billed once, $29).

## `licenseTypes` (type: `array`):

Which NY OCM license type codes to watch. Empty means all watchable types. In watch mode OCMRO (Registered Organization) is not selectable because every RO record is a pending application with no issued date; it is available in report mode. Up to 10 types.

## `county` (type: `string`):

A single NY county to watch, matched case-insensitively (for example Kings, Ulster, New York). At least one of licenseTypes, county or region is required for a watch; report may be broad.

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

A single NY OCM region to watch, matched case-insensitively (for example Manhattan, Finger Lakes). An alternative to county.

## `statusFilter` (type: `array`):

Optional license\_status values to restrict the filter (for example Active). Empty means all statuses. Part of the filter definition, so changing it re-baselines the saved filter.

## `maxAlertsPerRun` (type: `integer`):

Hard cap on the number of new-licensee alerts delivered and charged in a single run. Any overflow is not added to the seen-set and redelivers on the next run, and a truncation marker names how many were withheld. Bounds a catch-up run.

## `webhookUrl` (type: `string`):

Optional https URL that receives a POST with the new alerts after each run. Best-effort alerting only: the dataset is the durable record. If you need to verify the caller, put a secret token in the URL yourself.

## `filterName` (type: `string`):

Names this filter within your account so its deduplication memory persists across scheduled runs. Lowercased and restricted to letters, digits and hyphens (1 to 40 characters). Widening a saved filter under the same name re-baselines it (no back-catalog charge).

## `period` (type: `string`):

Report mode only. The issued-date window for the cohort report, as YYYY-MM (a single month) or YYYY-MM..YYYY-MM (an inclusive range), for example 2026-04..2026-06.

## `dryRun` (type: `boolean`):

When true, fetch, aggregate and diff but return at most 5 preview rows, charge nothing and touch no filter memory. Use it to sanity check your filter before scheduling.

## Actor input object example

```json
{
  "mode": "watch",
  "licenseTypes": [
    "OCMCULT",
    "OCMPROC",
    "OCMDIST"
  ],
  "maxAlertsPerRun": 50,
  "filterName": "default",
  "dryRun": false
}
```

# Actor output Schema

## `newLicenseeAlerts` (type: `string`):

No description

## `runSummary` (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 = {
    "licenseTypes": [
        "OCMCULT",
        "OCMPROC",
        "OCMDIST"
    ],
    "maxAlertsPerRun": 50,
    "filterName": "default"
};

// Run the Actor and wait for it to finish
const run = await client.actor("yungstentech/cannabis-license-radar").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 = {
    "licenseTypes": [
        "OCMCULT",
        "OCMPROC",
        "OCMDIST",
    ],
    "maxAlertsPerRun": 50,
    "filterName": "default",
}

# Run the Actor and wait for it to finish
run = client.actor("yungstentech/cannabis-license-radar").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 '{
  "licenseTypes": [
    "OCMCULT",
    "OCMPROC",
    "OCMDIST"
  ],
  "maxAlertsPerRun": 50,
  "filterName": "default"
}' |
apify call yungstentech/cannabis-license-radar --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=yungstentech/cannabis-license-radar",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Cannabis License Radar: New-Licensee Alerts by Type & County",
        "description": "Name the NY cannabis license types, county or region to watch and get each newly-issued licensee as a deduped BD row (entity, license type, county, issue date) from the NY OCM open-data feed on your schedule. Alerts cover licenses issued from enrollment forward; report mode returns a recent cohort.",
        "version": "0.0",
        "x-build-id": "JKNnEIh4jQPcIJLw1"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/yungstentech~cannabis-license-radar/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-yungstentech-cannabis-license-radar",
                "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/yungstentech~cannabis-license-radar/runs": {
            "post": {
                "operationId": "runs-sync-yungstentech-cannabis-license-radar",
                "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/yungstentech~cannabis-license-radar/run-sync": {
            "post": {
                "operationId": "run-sync-yungstentech-cannabis-license-radar",
                "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": {
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "watch",
                            "unwatch",
                            "list-events",
                            "report"
                        ],
                        "type": "string",
                        "description": "What this run does. watch: establish (first run) or advance a standing filter-watch and deliver newly-issued licensees. unwatch: forget a saved filter's memory. list-events: replay this filter's change-event history. report: one-off newly-issued cohort report for a type/county/period (billed once, $29).",
                        "default": "watch"
                    },
                    "licenseTypes": {
                        "title": "License types",
                        "maxItems": 10,
                        "type": "array",
                        "description": "Which NY OCM license type codes to watch. Empty means all watchable types. In watch mode OCMRO (Registered Organization) is not selectable because every RO record is a pending application with no issued date; it is available in report mode. Up to 10 types.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "OCMRETL",
                                "OCMMICR",
                                "OCMCAURD22",
                                "OCMPROC",
                                "OCMCULT",
                                "OCMDIST",
                                "OCMPT3B",
                                "OCMDIST2",
                                "OCMPROC2",
                                "OCMXROD",
                                "OCMPT3F",
                                "OCMCAURD22_PCA",
                                "OCMRETL_PCA",
                                "OCMRO"
                            ],
                            "enumTitles": [
                                "Adult-Use Retail Dispensary",
                                "Adult-Use Microbusiness",
                                "Adult-Use Conditional Retail Dispensary",
                                "Adult-Use Processor",
                                "Adult-Use Cultivator",
                                "Adult-Use Distributor",
                                "Adult-Use Processor Type Three-Branding",
                                "Adult-Use Distributor (variant)",
                                "Adult-Use Processor (variant)",
                                "Adult-Use RO Dispensary",
                                "Adult-Use Processor Type Three-Flower",
                                "Adult-Use Conditional Retail Dispensary (PCA)",
                                "Adult-Use Retail Dispensary (PCA)",
                                "Registered Organization (report mode only)"
                            ]
                        }
                    },
                    "county": {
                        "title": "County (optional)",
                        "type": "string",
                        "description": "A single NY county to watch, matched case-insensitively (for example Kings, Ulster, New York). At least one of licenseTypes, county or region is required for a watch; report may be broad."
                    },
                    "region": {
                        "title": "Region (optional)",
                        "type": "string",
                        "description": "A single NY OCM region to watch, matched case-insensitively (for example Manhattan, Finger Lakes). An alternative to county."
                    },
                    "statusFilter": {
                        "title": "License statuses (optional)",
                        "type": "array",
                        "description": "Optional license_status values to restrict the filter (for example Active). Empty means all statuses. Part of the filter definition, so changing it re-baselines the saved filter.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxAlertsPerRun": {
                        "title": "Max alerts per run",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Hard cap on the number of new-licensee alerts delivered and charged in a single run. Any overflow is not added to the seen-set and redelivers on the next run, and a truncation marker names how many were withheld. Bounds a catch-up run.",
                        "default": 50
                    },
                    "webhookUrl": {
                        "title": "Webhook URL (optional)",
                        "type": "string",
                        "description": "Optional https URL that receives a POST with the new alerts after each run. Best-effort alerting only: the dataset is the durable record. If you need to verify the caller, put a secret token in the URL yourself."
                    },
                    "filterName": {
                        "title": "Filter name",
                        "type": "string",
                        "description": "Names this filter within your account so its deduplication memory persists across scheduled runs. Lowercased and restricted to letters, digits and hyphens (1 to 40 characters). Widening a saved filter under the same name re-baselines it (no back-catalog charge).",
                        "default": "default"
                    },
                    "period": {
                        "title": "Report period (report mode)",
                        "type": "string",
                        "description": "Report mode only. The issued-date window for the cohort report, as YYYY-MM (a single month) or YYYY-MM..YYYY-MM (an inclusive range), for example 2026-04..2026-06."
                    },
                    "dryRun": {
                        "title": "Dry run (preview, no charge)",
                        "type": "boolean",
                        "description": "When true, fetch, aggregate and diff but return at most 5 preview rows, charge nothing and touch no filter memory. Use it to sanity check your filter before scheduling.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
