# Crexi Scraper — CRE Listings, Financials & Broker Leads (`khadinakbar/crexi-scraper`) Actor

Scrape Crexi commercial real estate: for-sale listings, property details, financials, and broker contact leads via Crexi's public API. MCP/API-ready.

- **URL**: https://apify.com/khadinakbar/crexi-scraper.md
- **Developed by:** [Khadin Akbar](https://apify.com/khadinakbar) (community)
- **Categories:** Real estate, Lead generation, MCP servers
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.00 / 1,000 listing scrapeds

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

## Crexi Scraper — Commercial Real Estate Listings, Financials & Broker Leads

Scrape **Crexi** (crexi.com) commercial real estate at scale: for-sale listings, full property details, financials, and listing-broker leads — straight from Crexi's own data API. No login, no cookies, HTTP-only. Built for CRE investors, brokers, analysts, and AI agents.

### What it does

Give it a location (state + city) and property types, or paste specific Crexi property URLs, and it returns clean, structured JSON: asking price, property type & sub-types, square footage, lot size, year built, zoning, APN, geo-coordinates, full address, investment highlights, marketing description, and the listing broker(s) with brokerage name, website, license numbers, and Crexi profile.

### When to use it

- **CRE lead generation** — build lists of active commercial listings + their brokers in a market.
- **Investor deal sourcing** — filter by state, city, and property type; sort by price.
- **Market & comp research** — pull asking prices, sizes, cap-rate fields, and locations across a metro.
- **Broker prospecting** — extract broker names, brokerages, websites, and profile links.
- **Feeding AI agents** — MCP-ready: narrow input, flat structured output.

Not for LoopNet or Apartments.com (CoStar sites) — those require different tooling. This actor targets **Crexi** specifically.

### Output — one record per property

| Field | Description |
|---|---|
| `id`, `url` | Crexi asset ID + public listing URL |
| `name`, `status` | Property headline + listing status |
| `propertyTypes`, `subtypes` | Category (Office, Retail, Multifamily…) + sub-types |
| `askingPrice`, `askingPriceDisplay` | Numeric price + formatted string |
| `capRate` | Cap rate when the broker publishes it |
| `squareFootage`, `lotSizeSqFt`, `units` | Building size, lot size, unit count |
| `yearBuilt`, `yearRenovated`, `buildings`, `stories`, `zoning`, `apn` | Physical + legal detail |
| `address`, `city`, `county`, `state`, `stateCode`, `zip`, `latitude`, `longitude`, `fullAddress` | Full location + geo |
| `brokerageName`, `brokers[]` | Listing brokerage + broker leads (name, brokerage, website, licenses, profile URL) |
| `investmentHighlights[]`, `marketingDescription` | Marketing copy, cleaned of HTML |
| `isInOpportunityZone`, `isSold`, `isUnpriced`, `hasFlyer`, `hasOM`, `hasVideo`, `hasVirtualTour` | Status flags |
| `thumbnailUrl`, `numberOfImages` | Media |
| `activatedOn`, `updatedOn`, `scrapedAt` | Timestamps (ISO 8601) |

### Pricing — Pay Per Event

- **Actor start:** $0.00005 per run.
- **Listing scraped:** $0.005 per listing returned (primary event).
- **Detail + broker enrichment:** $0.009 per listing when enriched with full detail and/or broker data.

Turn off `enrichDetails` and `includeBrokers` for listing-card-only output at $0.005/listing. A 100-listing enriched run costs about **$1.40**. Pay-Per-Usage (compute + proxy) is also available.

### Input

#### Search mode (default)

```json
{
  "states": ["TX"],
  "cities": ["Austin"],
  "propertyTypes": ["Office", "Retail"],
  "sortBy": "priceHighToLow",
  "includeUnpriced": true,
  "maxResults": 100,
  "enrichDetails": true,
  "includeBrokers": true
}
````

- **states** — two-letter state codes. Primary, reliable location filter.
- **cities** — city names, most precise when paired with the matching state.
- **propertyTypes** — Retail, Office, Multifamily, Industrial, Land, Hospitality, Special Purpose, Mixed Use, Self Storage, Business for Sale.
- **sortBy** — `relevance`, `priceLowToHigh`, `priceHighToLow`.
- **maxResults** — hard cap (0 = unlimited).

#### Detail mode

Paste Crexi property URLs or bare asset IDs — the actor scrapes exactly those:

```json
{
  "startUrls": [
    "https://www.crexi.com/properties/2610175/texas-4700-barbara-rd-river-oaks",
    "2586166"
  ],
  "enrichDetails": true,
  "includeBrokers": true
}
```

### Usage examples

#### Apify API (JavaScript)

```javascript
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: 'YOUR_TOKEN' });
const run = await client.actor('khadinakbar/crexi-scraper').call({
  states: ['CA'], cities: ['Los Angeles'], propertyTypes: ['Multifamily'], maxResults: 50,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

#### Apify API (Python)

```python
from apify_client import ApifyClient
client = ApifyClient("YOUR_TOKEN")
run = client.actor("khadinakbar/crexi-scraper").call(run_input={
    "states": ["FL"], "cities": ["Miami"], "propertyTypes": ["Retail"], "maxResults": 50
})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["name"], item["askingPriceDisplay"])
```

### MCP / AI agents

Exposed as `apify--crexi-scraper` in the Apify MCP server. Narrow input, flat JSON output — ideal for Claude, GPT, and other agents doing CRE research and lead generation.

### FAQ

**Does it get broker email/phone?** Crexi does not expose direct broker contact publicly — it routes messages through in-app chat. The actor returns broker name, brokerage, brokerage website, license numbers, and Crexi profile link, which are enough to reach the broker.

**Why state + city instead of a free-text search box?** Crexi's free-text search does not reliably filter by location. State + city filters are precise and dependable, so the actor uses those.

**Does it cover for-lease listings?** This version targets for-sale commercial listings, the largest Crexi inventory.

**How fast is it?** It calls Crexi's JSON API directly (no browser), so runs are fast. Enrichment adds ~2 requests per listing.

### Legal

This actor collects only publicly available data from Crexi's public endpoints and performs no login or access-control circumvention. You are responsible for using the output in compliance with Crexi's Terms of Service, applicable laws, and data-protection regulations (including how you contact brokers). Use for legitimate business research and lead generation. Not affiliated with or endorsed by Crexi or CoStar.

# Actor input Schema

## `states` (type: `array`):

Filter listings to these US states, by two-letter code (e.g. \['TX','CA']). This is the primary, reliable location filter. Leave empty to search all states. Combine with 'cities' to narrow further.

## `cities` (type: `array`):

Optional city names to narrow results within the selected states (e.g. \['Austin','Dallas']). Case-insensitive, matched against Crexi's city index. Most precise when paired with the matching state code in 'states'. Leave empty for state-wide or nationwide search.

## `propertyTypes` (type: `array`):

Restrict results to these Crexi commercial property categories. Leave empty for all types. Accepts one or more of the listed categories (e.g. \['Multifamily','Retail']). Applies to search mode only; ignored when startUrls is set.

## `sortBy` (type: `string`):

Ordering of search results. 'relevance' uses Crexi's default ranking; 'priceLowToHigh' and 'priceHighToLow' sort by asking price. Applies to search mode only. Defaults to 'relevance'.

## `includeUnpriced` (type: `boolean`):

Whether to include listings with no public asking price (auctions, call-for-offers, unpriced). Set false to return only listings with a numeric asking price. Defaults to true. Search mode only.

## `maxResults` (type: `integer`):

Hard cap on the number of listing records the run will collect and charge for (e.g. 100). Guards your budget. In detail mode this caps how many startUrls are processed. Defaults to 100; set to 0 to remove the cap and collect every match.

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

One or more Crexi property page URLs (e.g. 'https://www.crexi.com/properties/2610175/texas-4700-barbara-rd') or bare numeric Crexi asset IDs (e.g. '2610175'). When provided, the actor switches to detail mode and scrapes exactly these properties instead of running a search. Leave empty to use the state/city/type filters.

## `enrichDetails` (type: `boolean`):

When true, each listing is enriched with its full detail record (year built, lot size, zoning, APN, sub-types, financial summary, investment highlights, marketing description) via one extra request per property. Set false for faster, cheaper listing-card-only output. Defaults to true.

## `includeBrokers` (type: `boolean`):

When true, each property is enriched with its listing broker(s): name, brokerage, brokerage website, license numbers, and Crexi public profile ID (one extra request per property). Crexi does not expose direct broker email/phone. Defaults to true.

## `proxyConfiguration` (type: `object`):

Proxy settings. Crexi's API is reached most reliably through Apify Residential proxies; this is the default and recommended setting. Datacenter may work but is less reliable against the API host.

## Actor input object example

```json
{
  "states": [],
  "cities": [],
  "propertyTypes": [],
  "sortBy": "relevance",
  "includeUnpriced": true,
  "maxResults": 30,
  "startUrls": [],
  "enrichDetails": true,
  "includeBrokers": true,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

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

Crexi commercial real estate records collected by this run.

# 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 = {
    "maxResults": 30,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("khadinakbar/crexi-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "maxResults": 30,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("khadinakbar/crexi-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "maxResults": 30,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call khadinakbar/crexi-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Crexi Scraper — CRE Listings, Financials & Broker Leads",
        "description": "Scrape Crexi commercial real estate: for-sale listings, property details, financials, and broker contact leads via Crexi's public API. MCP/API-ready.",
        "version": "1.0",
        "x-build-id": "gOfgxHwVGBtA67wwM"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/khadinakbar~crexi-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-khadinakbar-crexi-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/khadinakbar~crexi-scraper/runs": {
            "post": {
                "operationId": "runs-sync-khadinakbar-crexi-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/khadinakbar~crexi-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-khadinakbar-crexi-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "states": {
                        "title": "States",
                        "type": "array",
                        "description": "Filter listings to these US states, by two-letter code (e.g. ['TX','CA']). This is the primary, reliable location filter. Leave empty to search all states. Combine with 'cities' to narrow further.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "AL",
                                "AK",
                                "AZ",
                                "AR",
                                "CA",
                                "CO",
                                "CT",
                                "DE",
                                "FL",
                                "GA",
                                "HI",
                                "ID",
                                "IL",
                                "IN",
                                "IA",
                                "KS",
                                "KY",
                                "LA",
                                "ME",
                                "MD",
                                "MA",
                                "MI",
                                "MN",
                                "MS",
                                "MO",
                                "MT",
                                "NE",
                                "NV",
                                "NH",
                                "NJ",
                                "NM",
                                "NY",
                                "NC",
                                "ND",
                                "OH",
                                "OK",
                                "OR",
                                "PA",
                                "RI",
                                "SC",
                                "SD",
                                "TN",
                                "TX",
                                "UT",
                                "VT",
                                "VA",
                                "WA",
                                "WV",
                                "WI",
                                "WY",
                                "DC"
                            ]
                        },
                        "default": []
                    },
                    "cities": {
                        "title": "Cities",
                        "type": "array",
                        "description": "Optional city names to narrow results within the selected states (e.g. ['Austin','Dallas']). Case-insensitive, matched against Crexi's city index. Most precise when paired with the matching state code in 'states'. Leave empty for state-wide or nationwide search.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "propertyTypes": {
                        "title": "Property types",
                        "type": "array",
                        "description": "Restrict results to these Crexi commercial property categories. Leave empty for all types. Accepts one or more of the listed categories (e.g. ['Multifamily','Retail']). Applies to search mode only; ignored when startUrls is set.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "Retail",
                                "Office",
                                "Multifamily",
                                "Industrial",
                                "Land",
                                "Hospitality",
                                "Special Purpose",
                                "Mixed Use",
                                "Self Storage",
                                "Business for Sale"
                            ]
                        },
                        "default": []
                    },
                    "sortBy": {
                        "title": "Sort order",
                        "enum": [
                            "relevance",
                            "priceLowToHigh",
                            "priceHighToLow"
                        ],
                        "type": "string",
                        "description": "Ordering of search results. 'relevance' uses Crexi's default ranking; 'priceLowToHigh' and 'priceHighToLow' sort by asking price. Applies to search mode only. Defaults to 'relevance'.",
                        "default": "relevance"
                    },
                    "includeUnpriced": {
                        "title": "Include unpriced listings",
                        "type": "boolean",
                        "description": "Whether to include listings with no public asking price (auctions, call-for-offers, unpriced). Set false to return only listings with a numeric asking price. Defaults to true. Search mode only.",
                        "default": true
                    },
                    "maxResults": {
                        "title": "Max results",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Hard cap on the number of listing records the run will collect and charge for (e.g. 100). Guards your budget. In detail mode this caps how many startUrls are processed. Defaults to 100; set to 0 to remove the cap and collect every match.",
                        "default": 30
                    },
                    "startUrls": {
                        "title": "Crexi property URLs (detail mode)",
                        "type": "array",
                        "description": "One or more Crexi property page URLs (e.g. 'https://www.crexi.com/properties/2610175/texas-4700-barbara-rd') or bare numeric Crexi asset IDs (e.g. '2610175'). When provided, the actor switches to detail mode and scrapes exactly these properties instead of running a search. Leave empty to use the state/city/type filters.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "enrichDetails": {
                        "title": "Enrich with full property detail",
                        "type": "boolean",
                        "description": "When true, each listing is enriched with its full detail record (year built, lot size, zoning, APN, sub-types, financial summary, investment highlights, marketing description) via one extra request per property. Set false for faster, cheaper listing-card-only output. Defaults to true.",
                        "default": true
                    },
                    "includeBrokers": {
                        "title": "Include broker / agent leads",
                        "type": "boolean",
                        "description": "When true, each property is enriched with its listing broker(s): name, brokerage, brokerage website, license numbers, and Crexi public profile ID (one extra request per property). Crexi does not expose direct broker email/phone. Defaults to true.",
                        "default": true
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Proxy settings. Crexi's API is reached most reliably through Apify Residential proxies; this is the default and recommended setting. Datacenter may work but is less reliable against the API host.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ]
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
