# US County Property Records API — Owner, Value, Tax & Sales (`shelvick/county-property-records`) Actor

Look up normalized US property records by address or parcel ID — owner, assessed value, market value, property tax history, and sale history — from public county assessor and recorder data, one schema across many counties. A property-records API for agents, not consumer listing data.

- **URL**: https://apify.com/shelvick/county-property-records.md
- **Developed by:** [Scott Helvick](https://apify.com/shelvick) (community)
- **Categories:** Real estate, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $42.50 / 1,000 property record resolveds

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

## US County Property Records API — Owner, Value, Tax & Sales

Property data is scattered across thousands of county assessor and recorder sites, each with its own portal, format, and quirks. This Actor is a **property-records API**: pass an **address or parcel ID** and get a **normalized property record** — owner, **assessed value**, market value, **property tax history**, and **sale history by address** — sourced from **public county assessor and recorder data**, in **one schema across many counties**, so an agent calls one tool instead of learning a new site per county.

### What this does

- **Address → property record.** Pass full street addresses; each is routed to its county and returned as one normalized record.
- **Parcel ID → property record.** Already have the assessor parcel/account number? Pass `STATE/County/ParcelID` for an exact lookup.
- **One unified schema across counties.** Every record has the same shape regardless of which county it came from: `owner_name`, `parcel_id`, `assessed_value`, `market_value`, `tax_year`, `tax_history`, `last_sale_date` / `last_sale_price`, `sale_history`, and `characteristics` (year built, building/lot area, units).
- **Public-record sourcing.** Data comes from county assessor/recorder offices and government open-data — public records you're allowed to use and resell — not from consumer real-estate listing portals.
- **Batch + pay-on-success.** Submit many lookups in one run; you're charged only for records actually resolved. Counties not yet covered, and lookups that don't resolve, are returned with a status and are never charged.
- **Live coverage manifest.** Each run writes the current supported-county set to the key-value store (`COVERAGE`), so an agent can check coverage before or after a call.

Use cases:
- Enrich a list of addresses with owner, value, and last-sale data for diligence or lead research.
- Pull assessed value + sale history for a specific parcel during underwriting.
- Build a property dataset across several metros from one agent-callable tool.
- Verify owner-of-record and tax-year valuation for a known parcel ID.

### Why one schema across counties matters

The hard part of property data isn't any single county — it's that every county publishes differently. A scraper built for one county is a commodity: it solves 1/3000th of the problem and breaks on its own when that county redesigns its site. The moment you need a second county you start over.

This Actor absorbs that heterogeneity behind a single contract. Internally each county has its own source — a clean government open-data API where one exists, a rendered public portal where it doesn't — but the **output is identical** across all of them. Coverage grows over time without changing the call you make or the shape you parse.

Field coverage is **best-effort per county**: every record uses the same schema, with `null` where a particular county doesn't publish a particular field (one county may expose full sale history but not building characteristics; another the reverse). The contract is stable; the fill rate depends on what each county makes public. That's an honest tradeoff, surfaced in the data rather than hidden.

### How it compares

| Approach | Multiple counties, one schema | Public-record sourced | Pay-per-use, no minimum | Agent-callable |
|---|---|---|---|---|
| Single-county scraper | — | varies | OK | varies |
| Enterprise property-data platforms | OK | OK | — (subscription + contract) | — |
| **US County Property Records** | **OK** | **OK** | **OK** | **OK** |

Single-county scrapers cover one place and leave you to stitch the rest together. Enterprise data platforms cover the country but gate it behind monthly minimums and sales contracts. This Actor sits in the open middle: many counties behind one schema, public-record data, billed per record with no commitment, callable directly by an agent.

### Input

| Field | Type | Required | Default | Description |
|---|---|---|---|---|
| `addresses` | array of strings | one of | `[]` | Full US property street addresses, e.g. `"1001 Preston St, Houston, TX 77002"`. Each is matched to its county and returned as one record. Include city + state (and ZIP if known) for reliable routing. |
| `parcelLookups` | array of strings | one of | `[]` | Direct parcel/account lookups as `STATE/County/ParcelID`, e.g. `"IL/Cook/15362060520000"`. Use when you already know the ID. |
| `county` | string | no | `--` | Optional county hint (without "County"), e.g. `"Cook"`, to disambiguate addresses across county lines. |
| `state` | string | no | `--` | Optional two-letter state code, e.g. `"IL"`, paired with `county`. |
| `includeHistory` | boolean | no | `true` | Include full tax-year and recorded-sale history where the county publishes it. Set `false` for a current-snapshot-only record (faster, smaller). |
| `maxRecords` | integer | no | `50` | Safety cap on records resolved per run (1–1000). |

Provide `addresses`, `parcelLookups`, or both — at least one is required.

### Output

One dataset record per lookup. Example (`completed`):

```json
{
  "query": "425 Addison Rd, Riverside, IL 60546",
  "query_type": "address",
  "status": "completed",
  "county": "Cook",
  "state": "IL",
  "parcel_id": "15362060520000",
  "owner_name": "SMITH JOHN A & JANE B",
  "situs_address": "425 ADDISON RD, RIVERSIDE, IL 60546",
  "mailing_address": "425 ADDISON RD, RIVERSIDE, IL 60546",
  "assessed_value": 37000,
  "market_value": null,
  "land_value": 14350,
  "improvement_value": 22650,
  "tax_year": 2025,
  "tax_history": [],
  "last_sale_date": "2018-04-20",
  "last_sale_price": 249000,
  "sale_history": [
    { "date": "2018-04-20", "price": 249000, "document_type": "Warranty", "doc_number": "1815701295" }
  ],
  "characteristics": { "year_built": 1998, "building_sqft": 2450 },
  "source_url": "https://www.cookcountyassessor.com/pin/15362060520000",
  "fetched_at": "2026-06-22T14:03:11Z",
  "error": null
}
````

`status` is one of `completed`, `not_covered` (county not yet supported), or `failed` (covered county, no match — see `error`). Nullable fields are `null` where the county doesn't publish them. Every field is described in the dataset schema.

### Example

```json
{ "addresses": ["1060 Wakeling St, Philadelphia, PA 19124"], "includeHistory": true }
```

```bash
curl -X POST "https://api.apify.com/v2/acts/shelvick~county-property-records/run-sync-get-dataset-items?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"addresses":["1060 Wakeling St, Philadelphia, PA 19124"],"includeHistory":true}'
```

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_TOKEN")
run = client.actor("shelvick/county-property-records").call(
    run_input={"addresses": ["1060 Wakeling St, Philadelphia, PA 19124"]}
)
for record in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(record["owner_name"], record["assessed_value"], record["last_sale_price"])
```

### Calling from an AI agent

**Apify MCP server (`mcp.apify.com`).** This Actor is exposed as a callable tool; the input schema is self-documenting, so an LLM can construct correct calls from the tool description alone. Pass an address (or a `STATE/County/ParcelID`) and read back a normalized property record. Pay per call via x402 USDC on Base or Skyfire managed tokens — this Actor is enabled for agentic payments.

**Apify SDK (Python).** See the example above (`apify_client`).

**REST API.** Use `run-sync-get-dataset-items` for small synchronous batches; the async `/runs` endpoint for larger ones.

### Pricing

Pay-per-event, billed only on success: one charge per **resolved** property record, after the record is pushed. `not_covered` and `failed` results are returned for transparency but **never charged**, and a single Actor-start event is amortized across the whole batch. So a batch of addresses costs only for the ones that actually came back with data.

See the **Pricing** tab on this Store page for the current per-record rate and any active subscriber discounts.

### Behavior

**Run-level failures (rare):** input validation only — at least one of `addresses` / `parcelLookups` must be present; `maxRecords` is 1–1000.

**Per-record statuses (normal):**

- `completed` — record resolved and normalized.
- `not_covered` — the county isn't supported yet (`error: "county-not-covered"`). Check the `COVERAGE` manifest for the current set.
- `failed` — covered county but the lookup didn't resolve (`error: "no-match"`, or a transient source error). Address matching is exact-ish; include city/state/ZIP for best results.

**Performance:** open-data counties resolve in roughly 1–3 s per record; counties served from a rendered portal take longer. Lookups run concurrently, so a batch finishes far faster than the sum of its parts. Very large batches should use the async API rather than the 5-minute sync endpoint.

### FAQ

**Which counties are supported?**
A growing set spanning major metros across many states — including Chicago (Cook), New York City, Philadelphia, Phoenix (Maricopa), Houston (Harris), Dallas–Fort Worth (Dallas/Tarrant), San Antonio (Bexar), Austin (Travis), Miami (Miami-Dade), Tampa (Hillsborough), Orlando (Orange), Charlotte (Mecklenburg), Raleigh (Wake), Cleveland (Cuyahoga), Columbus (Franklin), Detroit (Wayne), Minneapolis (Hennepin), and Portland (Multnomah) — with more added regularly. The authoritative, always-current list is written to the `COVERAGE` key-value-store record on every run, so an agent can check coverage programmatically rather than trusting a static list.

**What happens for a county you don't cover yet?**
You get a record with `status: "not_covered"` and you are not charged for it. Coverage expands over time; the same call will start returning data once that county is added.

**Why is a field `null`?**
Counties publish different things. The schema is constant; a `null` means that county doesn't expose that field publicly. One county may have full sale history, another rich building characteristics — best-effort per source.

**Am I charged for addresses that don't resolve?**
No. Only `completed` records are billed.

**Can I look up by parcel number instead of address?**
Yes — pass `STATE/County/ParcelID` in `parcelLookups` for an exact lookup that skips address matching.

### What this doesn't do

- **No consumer listing data.** This returns official county assessor/recorder records, not for-sale listings, Zestimate-style estimates, or agent/MLS data.
- **No nationwide coverage (yet).** It covers a curated, growing set of counties; uncovered counties return `not_covered`, not an error.
- **No owner contact info.** Owner of record and mailing address come from public records; no phones, emails, or skip-tracing.
- **No fuzzy/owner-name search.** Look up by address or parcel ID, not "all properties owned by X" — that 1→many shape isn't supported.
- **No guaranteed field completeness.** Field fill rate varies by county (best-effort).

For for-sale listings and valuations, use a real-estate listings source. For nationwide enterprise coverage with SLAs, a subscription property-data platform is the better fit. For raw geometry/parcel boundaries, use a county GIS/parcel layer.

***

Design notes: [www.scotthelvick.com/tools/county-property-records](https://www.scotthelvick.com/tools/county-property-records)

# Actor input Schema

## `addresses` (type: `array`):

Full US property street addresses to resolve to county property records, e.g. "1001 Preston St, Houston, TX 77002". Each address is matched to the right county assessor/recorder and returned as one normalized record. Include city + state (and ZIP if known) for reliable county resolution. Provide this and/or `parcelLookups`; at least one is required.

## `parcelLookups` (type: `array`):

Direct parcel or assessor account lookups when you already know the ID, one per line in the form STATE/County/ParcelOrAccount, e.g. "TX/Harris/0660640130020". Use this for exact-record retrieval; use `addresses` when you only have the street address. Provide this and/or `addresses`; at least one is required.

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

Optional county name (without the word 'County') to scope or disambiguate lookups, e.g. "Harris". Useful when addresses are ambiguous across county lines. Leave blank to auto-resolve each address to its county.

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

Optional two-letter US state code to scope lookups, e.g. "TX". Combined with `county` to disambiguate same-named counties across states.

## `includeHistory` (type: `boolean`):

When true (default), each record includes full tax-year history and recorded sale history where the county publishes it. Set false for a current-snapshot-only record (owner, value, latest tax year) — faster and smaller.

## `maxRecords` (type: `integer`):

Safety cap on the number of records resolved in one run (across addresses + parcelLookups). Protects against oversized batches. Default 50.

## Actor input object example

```json
{
  "addresses": [
    "1001 Preston St, Houston, TX 77002"
  ],
  "parcelLookups": [],
  "includeHistory": true,
  "maxRecords": 50
}
```

# Actor output Schema

## `results` (type: `string`):

Normalized property records for this run (one per resolved query).

# 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 = {
    "addresses": [
        "1001 Preston St, Houston, TX 77002"
    ],
    "parcelLookups": [],
    "county": "",
    "state": ""
};

// Run the Actor and wait for it to finish
const run = await client.actor("shelvick/county-property-records").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 = {
    "addresses": ["1001 Preston St, Houston, TX 77002"],
    "parcelLookups": [],
    "county": "",
    "state": "",
}

# Run the Actor and wait for it to finish
run = client.actor("shelvick/county-property-records").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 '{
  "addresses": [
    "1001 Preston St, Houston, TX 77002"
  ],
  "parcelLookups": [],
  "county": "",
  "state": ""
}' |
apify call shelvick/county-property-records --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=shelvick/county-property-records",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "US County Property Records API — Owner, Value, Tax & Sales",
        "description": "Look up normalized US property records by address or parcel ID — owner, assessed value, market value, property tax history, and sale history — from public county assessor and recorder data, one schema across many counties. A property-records API for agents, not consumer listing data.",
        "version": "0.0",
        "x-build-id": "Eow23pza9gSvm0fQX"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/shelvick~county-property-records/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-shelvick-county-property-records",
                "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/shelvick~county-property-records/runs": {
            "post": {
                "operationId": "runs-sync-shelvick-county-property-records",
                "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/shelvick~county-property-records/run-sync": {
            "post": {
                "operationId": "run-sync-shelvick-county-property-records",
                "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": {
                    "addresses": {
                        "title": "Property addresses",
                        "type": "array",
                        "description": "Full US property street addresses to resolve to county property records, e.g. \"1001 Preston St, Houston, TX 77002\". Each address is matched to the right county assessor/recorder and returned as one normalized record. Include city + state (and ZIP if known) for reliable county resolution. Provide this and/or `parcelLookups`; at least one is required.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "parcelLookups": {
                        "title": "Parcel / account lookups",
                        "type": "array",
                        "description": "Direct parcel or assessor account lookups when you already know the ID, one per line in the form STATE/County/ParcelOrAccount, e.g. \"TX/Harris/0660640130020\". Use this for exact-record retrieval; use `addresses` when you only have the street address. Provide this and/or `addresses`; at least one is required.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "county": {
                        "title": "County hint (optional)",
                        "type": "string",
                        "description": "Optional county name (without the word 'County') to scope or disambiguate lookups, e.g. \"Harris\". Useful when addresses are ambiguous across county lines. Leave blank to auto-resolve each address to its county."
                    },
                    "state": {
                        "title": "State hint (optional)",
                        "type": "string",
                        "description": "Optional two-letter US state code to scope lookups, e.g. \"TX\". Combined with `county` to disambiguate same-named counties across states."
                    },
                    "includeHistory": {
                        "title": "Include tax & sale history",
                        "type": "boolean",
                        "description": "When true (default), each record includes full tax-year history and recorded sale history where the county publishes it. Set false for a current-snapshot-only record (owner, value, latest tax year) — faster and smaller.",
                        "default": true
                    },
                    "maxRecords": {
                        "title": "Max records",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Safety cap on the number of records resolved in one run (across addresses + parcelLookups). Protects against oversized batches. Default 50.",
                        "default": 50
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```