# UCC Filing Radar: Connecticut UCC Leads by Funders You Watch (`yungstentech/ucc-fresh-filings-radar`) Actor

Watch the funders (secured parties) you name and get new Connecticut UCC filings that list them as the secured party, pulled on your schedule from the state's official open-data feed and deduped per watch so you never see the same filing twice. A standing funder-watch, not a bulk list.

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

## Pricing

from $19.00 / monthly funder-watch

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

**UCC Filing Radar** watches the secured parties (funders) you name and delivers new Connecticut UCC filings that list them as the secured party. It reads the official Connecticut Secretary of the State open-data feed, keeps a per-watch memory so you never see the same filing twice, and returns flat rows you can schedule, download, or pipe through the Apify API.

This is a standing funder-watch, not a bulk export. You name the funders to track and it returns the businesses they just filed against: fresh, funder-qualified UCC leads instead of an aged bulk list.

### What does UCC Filing Radar do?

Every run pulls a recent date window from Connecticut's public [UCC Lien Filings dataset](https://data.ct.gov/resource/xfev-8smz.json) (published by the Connecticut Secretary of the State), keeps only the filings whose **secured party** matches one of the funder names you watch, removes any filing this watch has already delivered, and returns the rest as dataset rows. An optional webhook receives the same new filings for alerting.

The Connecticut feed is a single denormalized table, so each row already carries the debtor, the secured party, the filing type, and the acceptance date. There is no login, no proxy, and no join. During testing the newest filing in the feed was one day old, so a daily schedule surfaces filings the state accepted the day before in most cases. The feed does not publish over weekends and holidays, so the default lookback window covers those gaps.

### Why use UCC Filing Radar?

- **Track named funders.** Equipment lenders, powersports and marine financiers, and other secured parties file UCC-1s when they fund a business. Watching a funder's new filings is a read on where that funder is active.
- **Own the timing.** The filing is public the day the state accepts it. This actor delivers that window on your own schedule.
- **No duplicates.** Each watch remembers what it has already delivered, so an overlapping window costs you nothing and repeats nothing.
- **Public record.** UCC filings are public records published by the Connecticut Secretary of the State.

### How to use UCC Filing Radar

1. In the **Input** tab, list the funders you want to watch under **Secured parties to watch** (for example `Sheffield Financial`, `John Deere`, `Financial Pacific Leasing`).
2. Leave **State** on Connecticut and **Filing types** on `ORIG FIN STMT` (UCC-1 originations) unless you want other filing types.
3. Run it once to preview the matches. Set **Dry run** to true first if you want a no-charge preview of up to five rows.
4. Create a daily **Schedule** for the actor. Each scheduled run delivers only filings you have not seen before, so a daily cadence with the default 3-day lookback covers weekends and holidays.
5. Optionally set a **Webhook URL** to receive each run's new filings as a POST.

Give each distinct funder list its own **Watch name** so its deduplication memory stays separate.

### Input

| Field | Required | Default | Description |
|---|---|---|---|
| `securedPartyNames` | Yes | none | 1 to 50 funder names to watch. Case and punctuation insensitive substring match, each name at least 3 characters. |
| `state` | No | `CT` | Connecticut is the only state available today. |
| `filingTypes` | No | `["ORIG FIN STMT"]` | Filing types to include, or the single value `ALL`. |
| `lookbackDays` | No | `3` | Days back from today (America/New_York) to query, 1 to 14. |
| `debtorCities` | No | none | Optional list of debtor cities to keep, up to 25. |
| `webhookUrl` | No | none | Optional https URL that receives new matches as a POST. |
| `watchName` | No | `default` | Names this watch so its dedupe memory persists across runs. |
| `dryRun` | No | `false` | Preview up to 5 rows, charge nothing, write no watch memory. |

### Output

Each new filing is one flat dataset row. You can download the dataset in JSON, HTML, CSV, or Excel.

```json
{
    "filingNumber": "0005393671",
    "lienFilingNumber": "0005393671",
    "filingType": "ORIG FIN STMT",
    "filingTypeDetail": "OFS",
    "lienStatus": "Active",
    "acceptedDate": "2026-07-04",
    "lapseDate": "2031-07-04",
    "debtorName": "PEACH, COLLIN",
    "debtorStreet": "20 KELLOGG RD",
    "debtorCity": "MARLBOROUGH",
    "debtorState": "CT",
    "debtorZip": "06447",
    "securedPartyName": "Sheffield Financial, A Division of Branch Banking and Trust Company",
    "securedPartyStreet": "PO Box 1704",
    "securedPartyCity": "Clemmons",
    "securedPartyState": "NC",
    "securedPartyZip": "27012",
    "matchedNames": ["Sheffield Financial"],
    "state": "CT",
    "watchName": "default",
    "billing": "included",
    "source": "https://data.ct.gov/resource/xfev-8smz.json"
}
````

A `summary` record is also written to the run's key-value store under `OUTPUT` with counts for the run: new matches, delivered rows, any rows withheld at your charge limit, the seen-set size, the feed's newest accepted date, and the feed lag in days.

### Data fields

| Field | Meaning |
|---|---|
| `filingNumber` | The UCC filing number. This is the deduplication key. |
| `lienFilingNumber` | The published lien filing number. |
| `filingType` | Filing type, for example `ORIG FIN STMT`. |
| `filingTypeDetail` | The published filing-type description code. |
| `lienStatus` | Lien status, for example `Active`. |
| `acceptedDate` | Date the state accepted the filing (YYYY-MM-DD). |
| `lapseDate` | Lapse date, or null. |
| `debtorName` | Debtor business name, or the individual debtor name. |
| `debtorStreet`, `debtorCity`, `debtorState`, `debtorZip` | Debtor address. |
| `securedPartyName` | The secured party (funder). |
| `securedPartyStreet`, `securedPartyCity`, `securedPartyState`, `securedPartyZip` | Secured party address. |
| `matchedNames` | Which of your watched names matched this filing. |
| `state` | Always `CT`. |
| `watchName` | The watch this row belongs to. |
| `billing` | `included`, `overflow`, or `dry-run`. |
| `source` | The source dataset URL, on every row. |

### Demo dataset

The public demo dataset is at https://api.apify.com/v2/datasets/ZsU4cT51KrcFfka76/items?format=json. It was generated by live run `CZPnAX8vIJXLrWk8S` from a clean representative Connecticut funder-watch input for `Sheffield Financial` with dry-run preview enabled, so it shows real matched filing rows from the state feed without writing watch memory or billing alert events.

### Pricing

The actor is billed per event.

- **Monthly watch fee: 19.00 USD per watch**, which includes the first 25 delivered filings that month.
- **Overflow: 0.40 USD per delivered filing** beyond the first 25 in a month.
- **First calendar month free.** The watch fee is waived during your account's first calendar month, so an initial run to try it out costs nothing while your matches stay within the 25 included filings. The free month applies once per account.

A dry run charges nothing. A run that cannot complete its query charges nothing. Filings withheld because you hit your run's max-charge limit are not billed and are redelivered on the next run.

### Tips and advanced options

- Run daily on a Schedule. The default 3-day lookback covers weekends and holidays; overlap is free because filings you have already received are deduplicated.
- Use the same `watchName` across scheduled runs so the dedupe memory persists. Use different `watchName` values for different funder lists.
- Set a per-run max-charge limit if you want a hard ceiling. If a run hits it mid-delivery, the withheld filings are not billed and return on the next run.
- Use `dryRun` to check your funder spellings before scheduling. Matching is a substring test, so `Sheffield Financial` matches `Sheffield Financial, A Division of Branch Banking and Trust Company`.
- Narrow with `debtorCities` when you only want filings against debtors in specific towns.

### FAQ, limitations, and support

- **Is this data legal to use?** UCC filings are public records published by the Connecticut Secretary of the State. This actor reads the state's own open-data feed.
- **Which states are covered?** Connecticut only, today. The output fields and events are built so additional states can be added later without changing them.
- **Are source-document images or collateral descriptions included?** No. The Connecticut feed does not publish a document link or a collateral text field, so those are not in the output.
- **How reliable is the webhook?** It is best-effort alerting with retries. The dataset is the durable record. If you need to verify the caller, put a secret token in your webhook URL.
- **What happens if the feed changes shape?** The actor checks the feed's structure on every run and stops without charging if a field it depends on is missing, rather than delivering broken rows.

For issues or a custom variant, use the Issues tab on the actor page.

# Actor input Schema

## `securedPartyNames` (type: `array`):

The funders (secured parties) you want to watch, one per line. Matching is case and punctuation insensitive and uses a substring test, so "Sheffield Financial" matches "Sheffield Financial, A Division of Branch Banking and Trust Company". Provide 1 to 50 names, each at least 3 characters. This field is required: the radar watches named funders, it does not return every filing in the state.

## `state` (type: `string`):

The state whose UCC feed is watched. Connecticut is the only state available today. The output fields are built so additional states can be added later without changing them.

## `filingTypes` (type: `array`):

Which UCC filing types to include, matched against the feed's cd\_flng\_type field. The default is UCC-1 originations (ORIG FIN STMT), the new liens a funder files when it funds a business. Other valid values include AMENDMENT, CONTINUATION, ASSIGNMENT, RELEASE ORIG, TERMINATION, VESSEL LIEN and AIRCRAFT LIEN. Use the single value ALL to include every filing type.

## `lookbackDays` (type: `integer`):

How many days back from today (America/New\_York) to query. The default of 3 covers weekends and holidays on a daily schedule. Overlap between runs is free because already delivered filings are deduplicated per watch. The maximum of 14 is a catch-up ceiling.

## `debtorCities` (type: `array`):

Optional. When set, only filings whose debtor city matches one of these (case and punctuation insensitive) are delivered. Up to 25 cities.

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

Optional https URL that receives a POST with the new matches 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.

## `watchName` (type: `string`):

Names this watch within your account so its deduplication memory persists across scheduled runs. Lowercased and restricted to letters, digits and hyphens (1 to 40 characters). Use different names for different funder lists; each named watch is billed separately.

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

When true, fetch and match but return at most 5 preview rows, charge nothing and touch no watch memory. Use it to sanity check your funder names before scheduling.

## Actor input object example

```json
{
  "securedPartyNames": [
    "Sheffield Financial",
    "John Deere",
    "Financial Pacific Leasing"
  ],
  "state": "CT",
  "filingTypes": [
    "ORIG FIN STMT"
  ],
  "lookbackDays": 3,
  "watchName": "default",
  "dryRun": false
}
```

# Actor output Schema

## `newFilings` (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 = {
    "securedPartyNames": [
        "Sheffield Financial",
        "John Deere",
        "Financial Pacific Leasing"
    ],
    "filingTypes": [
        "ORIG FIN STMT"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("yungstentech/ucc-fresh-filings-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 = {
    "securedPartyNames": [
        "Sheffield Financial",
        "John Deere",
        "Financial Pacific Leasing",
    ],
    "filingTypes": ["ORIG FIN STMT"],
}

# Run the Actor and wait for it to finish
run = client.actor("yungstentech/ucc-fresh-filings-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 '{
  "securedPartyNames": [
    "Sheffield Financial",
    "John Deere",
    "Financial Pacific Leasing"
  ],
  "filingTypes": [
    "ORIG FIN STMT"
  ]
}' |
apify call yungstentech/ucc-fresh-filings-radar --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "UCC Filing Radar: Connecticut UCC Leads by Funders You Watch",
        "description": "Watch the funders (secured parties) you name and get new Connecticut UCC filings that list them as the secured party, pulled on your schedule from the state's official open-data feed and deduped per watch so you never see the same filing twice. A standing funder-watch, not a bulk list.",
        "version": "0.0",
        "x-build-id": "5zhi0ENOU2gHH6Bz8"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/yungstentech~ucc-fresh-filings-radar/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-yungstentech-ucc-fresh-filings-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~ucc-fresh-filings-radar/runs": {
            "post": {
                "operationId": "runs-sync-yungstentech-ucc-fresh-filings-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~ucc-fresh-filings-radar/run-sync": {
            "post": {
                "operationId": "run-sync-yungstentech-ucc-fresh-filings-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",
                "required": [
                    "securedPartyNames"
                ],
                "properties": {
                    "securedPartyNames": {
                        "title": "Secured parties to watch",
                        "minItems": 1,
                        "maxItems": 50,
                        "type": "array",
                        "description": "The funders (secured parties) you want to watch, one per line. Matching is case and punctuation insensitive and uses a substring test, so \"Sheffield Financial\" matches \"Sheffield Financial, A Division of Branch Banking and Trust Company\". Provide 1 to 50 names, each at least 3 characters. This field is required: the radar watches named funders, it does not return every filing in the state.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "state": {
                        "title": "State",
                        "enum": [
                            "CT"
                        ],
                        "type": "string",
                        "description": "The state whose UCC feed is watched. Connecticut is the only state available today. The output fields are built so additional states can be added later without changing them.",
                        "default": "CT"
                    },
                    "filingTypes": {
                        "title": "Filing types",
                        "type": "array",
                        "description": "Which UCC filing types to include, matched against the feed's cd_flng_type field. The default is UCC-1 originations (ORIG FIN STMT), the new liens a funder files when it funds a business. Other valid values include AMENDMENT, CONTINUATION, ASSIGNMENT, RELEASE ORIG, TERMINATION, VESSEL LIEN and AIRCRAFT LIEN. Use the single value ALL to include every filing type.",
                        "default": [
                            "ORIG FIN STMT"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "lookbackDays": {
                        "title": "Lookback window (days)",
                        "minimum": 1,
                        "maximum": 14,
                        "type": "integer",
                        "description": "How many days back from today (America/New_York) to query. The default of 3 covers weekends and holidays on a daily schedule. Overlap between runs is free because already delivered filings are deduplicated per watch. The maximum of 14 is a catch-up ceiling.",
                        "default": 3
                    },
                    "debtorCities": {
                        "title": "Debtor cities (optional filter)",
                        "type": "array",
                        "description": "Optional. When set, only filings whose debtor city matches one of these (case and punctuation insensitive) are delivered. Up to 25 cities.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "webhookUrl": {
                        "title": "Webhook URL (optional)",
                        "type": "string",
                        "description": "Optional https URL that receives a POST with the new matches 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."
                    },
                    "watchName": {
                        "title": "Watch name",
                        "type": "string",
                        "description": "Names this watch within your account so its deduplication memory persists across scheduled runs. Lowercased and restricted to letters, digits and hyphens (1 to 40 characters). Use different names for different funder lists; each named watch is billed separately.",
                        "default": "default"
                    },
                    "dryRun": {
                        "title": "Dry run (preview, no charge)",
                        "type": "boolean",
                        "description": "When true, fetch and match but return at most 5 preview rows, charge nothing and touch no watch memory. Use it to sanity check your funder names 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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
