# Crexi Property Listing (`b2b_lead_generation/crexi-property-listing`) Actor

Get Crexi commercial real estate listings as flat JSON. Filter 230,000+ US properties by state, city, ZIP, county, sale status, price, size, and year built. Each record has full address, coordinates, asking price, brokerage, photo, and Crexi link, ready for Excel, SQL, or any BI tool.

- **URL**: https://apify.com/b2b\_lead\_generation/crexi-property-listing.md
- **Developed by:** [B2B Lead Generation](https://apify.com/b2b_lead_generation) (community)
- **Categories:** Real estate, Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.99 / 1,000 results

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/docs.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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 Property Listings: Commercial Real Estate Data by State, City, ZIP, or County

This actor extracts commercial real estate listings sourced from Crexi, one of the largest commercial property marketplaces in the US. Search over 230,000 listings by location, sale status, price range, building size, lot size, and year built. Every result is a flat JSON record with the full address, coordinates, asking price, brokerage contact, photo URL, and a direct Crexi link, ready for Excel, Google Sheets, SQL, or any BI tool without extra parsing.

### How it works

The actor searches a nightly-refreshed database of Crexi listings. You set the filters, the actor pulls matching listings page by page (200 per page), flattens each record, and pushes it to the dataset. A run stops when it reaches your item limit or runs out of results. No login, cookies, or setup required: set the filters and run.

### Input parameters

All filters are optional and freely combinable. Leave everything empty to search nationwide.

| Field | Type | Default | Description |
|-------|------|---------|-------------|
| `stateCode` | string | `CA` | Two-letter US state code (CA, TX, NY). |
| `state` | string | | Full state name (California, Texas). |
| `city` | string | | City name. Matches across all states unless combined with `stateCode`. |
| `zipCode` | string | | Five-digit ZIP code. |
| `county` | string | | County name, e.g. Stanislaus County. |
| `countyCode` | string | | County FIPS code, e.g. 6037. |
| `address` | string | | Street address to match. |
| `status` | select | `for_sale` | One of `for_sale`, `call_for_offers`, `auction`, `sold`, `off_market`. |
| `sortBy` | select | | `newest_listed`, `oldest_listed`, `price_high_to_low`, `price_low_to_high`, or `recently_updated`. |
| `minListPrice` / `maxListPrice` | integer | | Asking price range in USD, inclusive. |
| `minSqft` / `maxSqft` | integer | | Building area range in square feet. |
| `minLotSqft` / `maxLotSqft` | integer | | Lot size range in square feet (1 acre = 43,560 sqft). |
| `minYearBuilt` / `maxYearBuilt` | integer | | Construction year range. |
| `page` | integer | `1` | API result page to start from (200 listings per page). |
| `maxItems` | integer | `100` | Stop after this many listings. Caps the run cost. Max 1000. |
| `requestTimeoutSecs` | integer | `30` | Timeout per API request. |
| `proxyConfiguration` | object | No proxy | Optional. Normally unnecessary. |

### What data does this actor extract?

Each listing is one flat record with 49 fields. The main ones:

| Field | Example |
|-------|---------|
| `property_id` | `crexi_1000002` |
| `status` | `for_sale` |
| `address` | `7101 Porter Rd` |
| `city` / `state_code` / `postal_code` | `Niagara Falls` / `NY` / `14304` |
| `county_name` | `Niagara County` |
| `lat` / `lon` | `43.108545` / `-78.983714` |
| `list_price` | `695000` |
| `sqft` / `lot_sqft` / `year_built` | building and lot details where Crexi provides them |
| `p_type` / `sub_type` | `commercial` plus the Crexi subtype |
| `agent_name` / `office_name` | listing brokerage |
| `property_photo` | primary photo URL |
| `href` | direct link to the listing on crexi.com |
| `list_date` / `last_update_date` | listing and update dates |

### Sample output

```json
{
    "property_id": "crexi_1000002",
    "status": "for_sale",
    "address": "7101 Porter Rd",
    "city": "Niagara Falls",
    "state_code": "NY",
    "postal_code": "14304",
    "county_name": "Niagara County",
    "lat": 43.108545,
    "lon": -78.983714,
    "list_price": 695000.0,
    "p_type": "commercial",
    "agent_name": "Ellicott Development",
    "property_photo": "https://images.crexi.com/assets/1000002/...jpg",
    "href": "https://www.crexi.com/properties/1000002/new-york-7101-porter-rd",
    "list_date": "2022-11-30",
    "source": "Crexi"
}
````

### Use cases

- Deal sourcing: pull every commercial listing in a target county or ZIP, sorted by newest first, and feed it to your acquisition pipeline
- Market analysis: track asking prices and inventory for a metro area over time by scheduling weekly runs
- Brokerage prospecting: collect listings with brokerage names to build outreach lists for a region
- Auction tracking: filter by `auction` or `call_for_offers` status to catch non-standard sale processes early
- Data enrichment: join records to your own property database by address or coordinates

### FAQ

**Where does the data come from?**
From a database of Crexi listings that is refreshed nightly. You get stable, structured records instead of scraping Crexi yourself.

**Why are beds and baths empty?**
These are commercial listings. The fields exist in the record for schema compatibility, but Crexi does not report them, so they stay null.

**What do call\_for\_offers and auction mean?**
Crexi uses a sale-process vocabulary. Call for offers means the seller collects offers until a deadline. Auction listings sell through a bidding event. Both are distinct from a standard for-sale listing.

**How many listings can one run collect?**
Up to 1,000 per run via `maxItems`. For bigger exports, use the `page` input to slice the result set across several runs: page 1 covers listings 1 to 200, page 6 covers 1,001 to 1,200, and so on.

**Do I need a proxy?**
No. Runs work out of the box without any proxy. The option exists only for special cases.

**What happens if a filter matches nothing?**
The run ends normally with zero items and the log shows the total the API reported.

Get structured Crexi commercial real estate data in minutes instead of building and maintaining your own scraper.

# Actor input Schema

## `stateCode` (type: `string`):

Two-letter US state code, e.g. CA, TX, NY (case-insensitive).

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

Full US state name, e.g. California, Texas (case-insensitive). Alternative to State code.

## `city` (type: `string`):

City name. Matches across every state unless combined with State code.

## `zipCode` (type: `string`):

Five-digit US ZIP / postal code, e.g. 90012.

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

County name, e.g. Stanislaus County. Combine with State code to avoid cross-state name collisions.

## `countyCode` (type: `string`):

County FIPS code, e.g. 6037, for exact county targeting.

## `address` (type: `string`):

Street address to match, e.g. 2930 Sperry Ave.

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

Sale status of the commercial listing. Crexi uses a sale-process vocabulary: for\_sale covers On-Market and Highest & Best listings; call\_for\_offers and auction are distinct sale mechanisms; off\_market listings are no longer active.

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

Order of the results. Unset returns a stable default order.

## `minListPrice` (type: `integer`):

Minimum asking price in USD, inclusive.

## `maxListPrice` (type: `integer`):

Maximum asking price in USD, inclusive.

## `minSqft` (type: `integer`):

Minimum building area in square feet, inclusive.

## `maxSqft` (type: `integer`):

Maximum building area in square feet, inclusive.

## `minLotSqft` (type: `integer`):

Minimum lot size in square feet, inclusive. 1 acre = 43,560 sqft.

## `maxLotSqft` (type: `integer`):

Maximum lot size in square feet, inclusive. 1 acre = 43,560 sqft.

## `minYearBuilt` (type: `integer`):

Earliest construction year to include, inclusive.

## `maxYearBuilt` (type: `integer`):

Latest construction year to include, inclusive.

## `page` (type: `integer`):

API result page to start from (200 listings per page). Use together with Maximum listings to collect a specific slice, e.g. page 3 with maxItems 200 returns listings 401-600.

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

Stop after this many listings have been pushed to the dataset. Caps the run cost.

## `requestTimeoutSecs` (type: `integer`):

Timeout for each API request, in seconds.

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

Optional proxy for the API requests. Usually unnecessary because the actor calls the BuyMLS API directly.

## Actor input object example

```json
{
  "stateCode": "CA",
  "state": "California",
  "city": "Los Angeles",
  "zipCode": "90012",
  "county": "Stanislaus County",
  "countyCode": "6037",
  "address": "2930 Sperry Ave",
  "status": "for_sale",
  "minListPrice": 100000,
  "maxListPrice": 5000000,
  "minSqft": 1000,
  "maxSqft": 50000,
  "minLotSqft": 10000,
  "maxLotSqft": 435600,
  "minYearBuilt": 1980,
  "maxYearBuilt": 2026,
  "page": 1,
  "maxItems": 100,
  "requestTimeoutSecs": 30,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `results` (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 = {
    "stateCode": "CA",
    "status": "for_sale",
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("b2b_lead_generation/crexi-property-listing").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 = {
    "stateCode": "CA",
    "status": "for_sale",
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("b2b_lead_generation/crexi-property-listing").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 '{
  "stateCode": "CA",
  "status": "for_sale",
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call b2b_lead_generation/crexi-property-listing --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Crexi Property Listing",
        "description": "Get Crexi commercial real estate listings as flat JSON. Filter 230,000+ US properties by state, city, ZIP, county, sale status, price, size, and year built. Each record has full address, coordinates, asking price, brokerage, photo, and Crexi link, ready for Excel, SQL, or any BI tool.",
        "version": "0.0",
        "x-build-id": "HyNwQG91g1qJYmpnT"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/b2b_lead_generation~crexi-property-listing/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-b2b_lead_generation-crexi-property-listing",
                "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/b2b_lead_generation~crexi-property-listing/runs": {
            "post": {
                "operationId": "runs-sync-b2b_lead_generation-crexi-property-listing",
                "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/b2b_lead_generation~crexi-property-listing/run-sync": {
            "post": {
                "operationId": "run-sync-b2b_lead_generation-crexi-property-listing",
                "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": {
                    "stateCode": {
                        "title": "State code",
                        "type": "string",
                        "description": "Two-letter US state code, e.g. CA, TX, NY (case-insensitive)."
                    },
                    "state": {
                        "title": "State name",
                        "type": "string",
                        "description": "Full US state name, e.g. California, Texas (case-insensitive). Alternative to State code."
                    },
                    "city": {
                        "title": "City",
                        "type": "string",
                        "description": "City name. Matches across every state unless combined with State code."
                    },
                    "zipCode": {
                        "title": "ZIP code",
                        "type": "string",
                        "description": "Five-digit US ZIP / postal code, e.g. 90012."
                    },
                    "county": {
                        "title": "County",
                        "type": "string",
                        "description": "County name, e.g. Stanislaus County. Combine with State code to avoid cross-state name collisions."
                    },
                    "countyCode": {
                        "title": "County FIPS code",
                        "type": "string",
                        "description": "County FIPS code, e.g. 6037, for exact county targeting."
                    },
                    "address": {
                        "title": "Street address",
                        "type": "string",
                        "description": "Street address to match, e.g. 2930 Sperry Ave."
                    },
                    "status": {
                        "title": "Listing status",
                        "enum": [
                            "for_sale",
                            "call_for_offers",
                            "auction",
                            "sold",
                            "off_market"
                        ],
                        "type": "string",
                        "description": "Sale status of the commercial listing. Crexi uses a sale-process vocabulary: for_sale covers On-Market and Highest & Best listings; call_for_offers and auction are distinct sale mechanisms; off_market listings are no longer active."
                    },
                    "sortBy": {
                        "title": "Sort order",
                        "enum": [
                            "newest_listed",
                            "oldest_listed",
                            "price_high_to_low",
                            "price_low_to_high",
                            "recently_updated"
                        ],
                        "type": "string",
                        "description": "Order of the results. Unset returns a stable default order."
                    },
                    "minListPrice": {
                        "title": "Minimum asking price (USD)",
                        "type": "integer",
                        "description": "Minimum asking price in USD, inclusive."
                    },
                    "maxListPrice": {
                        "title": "Maximum asking price (USD)",
                        "type": "integer",
                        "description": "Maximum asking price in USD, inclusive."
                    },
                    "minSqft": {
                        "title": "Minimum square footage",
                        "type": "integer",
                        "description": "Minimum building area in square feet, inclusive."
                    },
                    "maxSqft": {
                        "title": "Maximum square footage",
                        "type": "integer",
                        "description": "Maximum building area in square feet, inclusive."
                    },
                    "minLotSqft": {
                        "title": "Minimum lot size (sqft)",
                        "type": "integer",
                        "description": "Minimum lot size in square feet, inclusive. 1 acre = 43,560 sqft."
                    },
                    "maxLotSqft": {
                        "title": "Maximum lot size (sqft)",
                        "type": "integer",
                        "description": "Maximum lot size in square feet, inclusive. 1 acre = 43,560 sqft."
                    },
                    "minYearBuilt": {
                        "title": "Earliest year built",
                        "type": "integer",
                        "description": "Earliest construction year to include, inclusive."
                    },
                    "maxYearBuilt": {
                        "title": "Latest year built",
                        "type": "integer",
                        "description": "Latest construction year to include, inclusive."
                    },
                    "page": {
                        "title": "Start page",
                        "minimum": 1,
                        "type": "integer",
                        "description": "API result page to start from (200 listings per page). Use together with Maximum listings to collect a specific slice, e.g. page 3 with maxItems 200 returns listings 401-600.",
                        "default": 1
                    },
                    "maxItems": {
                        "title": "Maximum listings to collect",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Stop after this many listings have been pushed to the dataset. Caps the run cost.",
                        "default": 100
                    },
                    "requestTimeoutSecs": {
                        "title": "Request timeout (seconds)",
                        "minimum": 5,
                        "maximum": 120,
                        "type": "integer",
                        "description": "Timeout for each API request, in seconds.",
                        "default": 30
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Optional proxy for the API requests. Usually unnecessary because the actor calls the BuyMLS API directly."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
