# Crexi Scraper - Commercial Property Listings for Sale (`abotapi/crexi-commercial-listings-scraper`) Actor

Scrape crexi.com commercial listings: asking price, cap rate, square footage, units, year built, lot size, APN, zoning, address, coordinates, status, photos plus agent and brokerage contacts and 100+ fields. Search by city, ZIP or keyword with type, price and sort filters, or paste URLs.

- **URL**: https://apify.com/abotapi/crexi-commercial-listings-scraper.md
- **Developed by:** [AbotAPI](https://apify.com/abotapi) (community)
- **Categories:** Real estate, Lead generation, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 1,000 listing 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.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 Commercial Listings Scraper

Pull structured commercial property listings from crexi.com at scale. Search any city, ZIP or keyword with property type, price and sort filters, or paste listing URLs directly, and get a clean JSON record per listing: asking price, cap rate, square footage, units, year built, lot size, APN, zoning, full address with coordinates, status, the complete photo gallery, and the listing agent plus brokerage contact details. Over 100 fields per listing, with optional one-click export into Notion, Linear, Airtable and other apps.

### Why This Scraper?

- Two ways to start: search by location and filters, or paste crexi.com listing URLs.
- Deep per-listing detail: square footage, units, year built, stories, lot size, cap rate, net operating income, APN, zoning and the full marketing description.
- Agent and brokerage contact cluster on every listing, including license numbers and the public profile.
- The complete image gallery, not just the thumbnail.
- Filter by property type, asking-price band, priced-only, and four sort orders in either direction.
- One finite cap (Max items) keeps every run predictable and on budget.
- Optional export into the apps you already use via MCP connectors.

### Data You Get

> Sample shape - values are illustrative placeholders, not from a live listing.

| Field | Example |
| --- | --- |
| id | 1000000 |
| name | Maple Court Apartments |
| property_type | Multifamily |
| askingPrice | 4250000 |
| capRate | 6.25 |
| squareFootage | 48000 |
| specifications.units | 64 |
| yearBuilt | 1998 |
| stories | 3 |
| lotSize | 2.4 |
| netOperatingIncome | 265000 |
| apn | 000-000-000 |
| zoning | R-4 |
| status | Active |
| fullAddress | 100 Main St, Austin, Travis County, TX 78701 |
| city | Austin |
| state | TX |
| zip | 78701 |
| latitude | 30.267200 |
| longitude | -97.743100 |
| url | https://www.crexi.com/properties/1000000/austin-maple-court-apartments |
| imageUrl | https://images.crexi.com/assets/1000000/placeholder_3000x2000_resize.jpg |
| brokerageName | Example Commercial Realty |
| agent_info.name | Jane Doe |
| agent_info.phone | +10000000000 |
| publicProfileId | janedoe |

### How to Use

Search by location and property type:

```json
{
  "mode": "search",
  "locations": ["Austin, TX"],
  "propertyTypes": ["Multifamily"],
  "maxItems": 20,
  "fetchDetails": true
}
````

Search a price band, priced listings only, sorted by cap rate:

```json
{
  "mode": "search",
  "locations": ["Dallas, TX"],
  "priceMin": 1000000,
  "priceMax": 25000000,
  "includeUnpriced": false,
  "sortBy": "capRate",
  "sortDirection": "Descending",
  "maxItems": 50
}
```

Paste listing URLs directly:

```json
{
  "mode": "url",
  "urls": [
    "https://www.crexi.com/properties/1000000/austin-maple-court-apartments",
    "https://www.crexi.com/properties/1000001/dallas-oak-plaza"
  ],
  "fetchDetails": true
}
```

### Input Parameters

| Parameter | Type | Description |
| --- | --- | --- |
| mode | select | `search` builds searches from your locations and filters; `url` loads the listing URLs you paste. |
| locations | array | Locations or keywords to search (e.g. `Austin, TX`, `90001`). Each entry is its own search. Search mode only. |
| propertyTypes | array | Property types to narrow the search (e.g. `Multifamily`, `Office`, `Retail`, `Industrial`, `Land`). Search mode only. |
| priceMin | integer | Only return listings with an asking price at or above this amount. |
| priceMax | integer | Only return listings with an asking price at or below this amount. |
| includeUnpriced | boolean | Include listings without a published asking price. Default true. |
| sortBy | select | Result order: `rank` (best match), `price`, `activatedOn` (newest), `capRate`. |
| sortDirection | select | `Descending` or `Ascending`. |
| urls | array | crexi.com listing detail URLs to load. URL mode only; filter fields are ignored. |
| fetchDetails | boolean | Load each listing for full size, units, cap rate, gallery and agent contact. Default true; adds a small per-item charge. |
| maxItems | integer | The single cap on the run: stop after this many listings. Default 20. 0 = unlimited. |
| maxPages | integer | Optional safety bound on result pages per search. Defaults to unlimited and does not cap the run; defers to Max items. |
| proxy | object | Apify Proxy configuration. The datacenter default is the lowest-cost option and works on every plan. |
| maxResidentialMB | integer | When using a Residential proxy group, cap residential traffic at this many MB, then auto-downgrade to the lower-cost tier. 0 = unlimited. |
| mcpConnectors | array | Optional MCP connectors to pipe results into (Notion, Linear, Airtable, Apify). Never changes the dataset. |
| notionParentPageUrl | string | Notion page URL or id under which item pages are created. Notion connector only. |
| maxNotifyListings | integer | Cap on items written to each connector per run. Does not affect the dataset. |

#### Export to your apps (MCP connectors)

Optionally send results into the tools you already use through Model Context Protocol (MCP) connectors. Authorize a connector under Apify, Settings, API & Integrations, then select it in `mcpConnectors`. Notion receives a rich page per listing (set `notionParentPageUrl`); other connectors get a best-effort write or digest. This step is fully optional, runs after scraping, and never changes the dataset output. Supported connectors: Notion (https://mcp.notion.com/mcp), Linear (https://mcp.linear.app/sse), Airtable (https://mcp.airtable.com/mcp), Apify (https://mcp.apify.com).

### Output Example

> Sample shape - values are illustrative placeholders, not from a live listing.

```json
{
  "id": 1000000,
  "name": "Maple Court Apartments",
  "url": "https://www.crexi.com/properties/1000000/austin-maple-court-apartments",
  "property_type": "Multifamily",
  "subtypes": ["Apartment Building"],
  "status": "Active",
  "askingPrice": 4250000,
  "capRate": 6.25,
  "squareFootage": 48000,
  "specifications": { "units": 64, "year_built": 1998 },
  "yearBuilt": 1998,
  "stories": 3,
  "lotSize": 2.4,
  "netOperatingIncome": 265000,
  "apn": "000-000-000",
  "zoning": "R-4",
  "marketingDescription": "Well-maintained 64-unit garden-style community in central Austin.",
  "fullAddress": "100 Main St, Austin, Travis County, TX 78701",
  "city": "Austin",
  "state": "TX",
  "zip": "78701",
  "latitude": 30.2672,
  "longitude": -97.7431,
  "images": [
    "https://images.crexi.com/assets/1000000/placeholder_3000x2000_resize.jpg"
  ],
  "brokerageName": "Example Commercial Realty",
  "agent_info": { "name": "Jane Doe", "company": "Example Commercial Realty", "phone": "+10000000000" },
  "firstName": "Jane",
  "lastName": "Doe",
  "publicProfileId": "janedoe",
  "licenseNumbers": ["TX 000000"],
  "numberOfAssets": 12,
  "scrapedAt": "2026-01-01T00:00:00.000Z"
}
```

### Plan Requirement

This actor runs on any Apify plan. The default datacenter proxy is the lowest-cost option and works on the free tier. A residential proxy group is optional and supported if you prefer it; set a residential traffic budget to cap spend and auto-downgrade.

# Actor input Schema

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

How to start the scrape. 'search' builds crexi.com searches from your locations, property types and filters. 'url' loads the crexi.com listing URLs you paste (filter fields below are ignored in URL mode).

## `locations` (type: `array`):

One or more locations or keywords to search (e.g. 'Austin, TX', '90001', 'warehouse Dallas'). Each entry is scraped as its own search. Leave empty to search all listings nationwide.

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

Optional property types to narrow the search (e.g. 'Multifamily', 'Office', 'Retail', 'Industrial', 'Land'). Applied across all locations.

## `priceMin` (type: `integer`):

Only return listings with an asking price at or above this amount.

## `priceMax` (type: `integer`):

Only return listings with an asking price at or below this amount.

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

Include listings that do not publish an asking price (auctions, call-for-offers). Turn off to return only priced listings.

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

Order crexi.com returns results in.

## `sortDirection` (type: `string`):

Ascending (low to high / oldest first) or descending (high to low / newest first).

## `urls` (type: `array`):

Paste crexi.com listing detail URLs (https://www.crexi.com/properties/<id>/<slug>). Multiple URLs supported; filter-mode fields are ignored.

## `fetchDetails` (type: `boolean`):

Load each listing page to add square footage, units, year built, stories, lot size, cap rate, APN, marketing description, the full image gallery and the agent and brokerage contact details. Slower and adds a small per-item charge; leave off for fast basic listings.

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

The single cap on this run: stop after collecting this many listings (across all searches and URLs). Set 0 for unlimited.

## `maxPages` (type: `integer`):

Optional safety bound on how many result pages to include per search. Defaults to unlimited (leave empty or set 0) and does NOT cap the run; it defers to Max items, which is the single cap. The run stops at Max items, not here.

## `proxy` (type: `object`):

Apify Proxy configuration. The datacenter default returns the same results at the lowest cost.

## `maxResidentialMB` (type: `integer`):

When using a Residential proxy group, cap residential traffic at this many MB. After the budget is reached the run auto-downgrades to the lower-cost tier (identical results). 0 = unlimited.

## `mcpConnectors` (type: `array`):

Optionally send results into the apps you already use, via Model Context Protocol (MCP) connectors. Authorize one under Apify, Settings, API & Integrations, then select it here. Notion gets a rich page-per-item export; other connectors get a best-effort write/digest. Leave empty to skip; never changes the dataset output. Supported: Notion (https://mcp.notion.com/mcp), Linear (https://mcp.linear.app/sse), Airtable (https://mcp.airtable.com/mcp), Apify (https://mcp.apify.com).

## `notionParentPageUrl` (type: `string`):

URL (or id) of the Notion page under which item pages are created. Required to enable the Notion export; ignored by other connectors.

## `maxNotifyListings` (type: `integer`):

Cap on items written to each connector per run. Does not affect the dataset.

## Actor input object example

```json
{
  "mode": "search",
  "locations": [
    "Austin, TX"
  ],
  "includeUnpriced": true,
  "sortBy": "rank",
  "sortDirection": "Descending",
  "urls": [
    "https://www.crexi.com/properties/2597217/new-york-48-w-48th-street"
  ],
  "fetchDetails": true,
  "maxItems": 20,
  "proxy": {
    "useApifyProxy": true
  },
  "maxResidentialMB": 0,
  "maxNotifyListings": 50
}
```

# Actor output Schema

## `overview` (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 = {
    "locations": [
        "Austin, TX"
    ],
    "urls": [
        "https://www.crexi.com/properties/2597217/new-york-48-w-48th-street"
    ],
    "maxItems": 20,
    "proxy": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("abotapi/crexi-commercial-listings-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 = {
    "locations": ["Austin, TX"],
    "urls": ["https://www.crexi.com/properties/2597217/new-york-48-w-48th-street"],
    "maxItems": 20,
    "proxy": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("abotapi/crexi-commercial-listings-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 '{
  "locations": [
    "Austin, TX"
  ],
  "urls": [
    "https://www.crexi.com/properties/2597217/new-york-48-w-48th-street"
  ],
  "maxItems": 20,
  "proxy": {
    "useApifyProxy": true
  }
}' |
apify call abotapi/crexi-commercial-listings-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Crexi Scraper - Commercial Property Listings for Sale",
        "description": "Scrape crexi.com commercial listings: asking price, cap rate, square footage, units, year built, lot size, APN, zoning, address, coordinates, status, photos plus agent and brokerage contacts and 100+ fields. Search by city, ZIP or keyword with type, price and sort filters, or paste URLs.",
        "version": "1.0",
        "x-build-id": "ffObLxhQyO06hkdN5"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/abotapi~crexi-commercial-listings-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-abotapi-crexi-commercial-listings-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/abotapi~crexi-commercial-listings-scraper/runs": {
            "post": {
                "operationId": "runs-sync-abotapi-crexi-commercial-listings-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/abotapi~crexi-commercial-listings-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-abotapi-crexi-commercial-listings-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",
                "required": [
                    "mode"
                ],
                "properties": {
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "search",
                            "url"
                        ],
                        "type": "string",
                        "description": "How to start the scrape. 'search' builds crexi.com searches from your locations, property types and filters. 'url' loads the crexi.com listing URLs you paste (filter fields below are ignored in URL mode).",
                        "default": "search"
                    },
                    "locations": {
                        "title": "Locations or keywords",
                        "type": "array",
                        "description": "One or more locations or keywords to search (e.g. 'Austin, TX', '90001', 'warehouse Dallas'). Each entry is scraped as its own search. Leave empty to search all listings nationwide.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "propertyTypes": {
                        "title": "Property types",
                        "type": "array",
                        "description": "Optional property types to narrow the search (e.g. 'Multifamily', 'Office', 'Retail', 'Industrial', 'Land'). Applied across all locations.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "priceMin": {
                        "title": "Minimum asking price (USD)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only return listings with an asking price at or above this amount."
                    },
                    "priceMax": {
                        "title": "Maximum asking price (USD)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only return listings with an asking price at or below this amount."
                    },
                    "includeUnpriced": {
                        "title": "Include unpriced listings",
                        "type": "boolean",
                        "description": "Include listings that do not publish an asking price (auctions, call-for-offers). Turn off to return only priced listings.",
                        "default": true
                    },
                    "sortBy": {
                        "title": "Sort by",
                        "enum": [
                            "rank",
                            "price",
                            "activatedOn",
                            "capRate"
                        ],
                        "type": "string",
                        "description": "Order crexi.com returns results in.",
                        "default": "rank"
                    },
                    "sortDirection": {
                        "title": "Sort direction",
                        "enum": [
                            "Descending",
                            "Ascending"
                        ],
                        "type": "string",
                        "description": "Ascending (low to high / oldest first) or descending (high to low / newest first).",
                        "default": "Descending"
                    },
                    "urls": {
                        "title": "Crexi.com URLs",
                        "type": "array",
                        "description": "Paste crexi.com listing detail URLs (https://www.crexi.com/properties/<id>/<slug>). Multiple URLs supported; filter-mode fields are ignored.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "fetchDetails": {
                        "title": "Fetch full details",
                        "type": "boolean",
                        "description": "Load each listing page to add square footage, units, year built, stories, lot size, cap rate, APN, marketing description, the full image gallery and the agent and brokerage contact details. Slower and adds a small per-item charge; leave off for fast basic listings.",
                        "default": true
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 0,
                        "type": "integer",
                        "description": "The single cap on this run: stop after collecting this many listings (across all searches and URLs). Set 0 for unlimited.",
                        "default": 20
                    },
                    "maxPages": {
                        "title": "Max pages per search",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Optional safety bound on how many result pages to include per search. Defaults to unlimited (leave empty or set 0) and does NOT cap the run; it defers to Max items, which is the single cap. The run stops at Max items, not here."
                    },
                    "proxy": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Apify Proxy configuration. The datacenter default returns the same results at the lowest cost.",
                        "default": {
                            "useApifyProxy": true
                        }
                    },
                    "maxResidentialMB": {
                        "title": "Residential traffic budget (MB)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "When using a Residential proxy group, cap residential traffic at this many MB. After the budget is reached the run auto-downgrades to the lower-cost tier (identical results). 0 = unlimited.",
                        "default": 0
                    },
                    "mcpConnectors": {
                        "title": "Pipe results into your apps (optional)",
                        "type": "array",
                        "description": "Optionally send results into the apps you already use, via Model Context Protocol (MCP) connectors. Authorize one under Apify, Settings, API & Integrations, then select it here. Notion gets a rich page-per-item export; other connectors get a best-effort write/digest. Leave empty to skip; never changes the dataset output. Supported: Notion (https://mcp.notion.com/mcp), Linear (https://mcp.linear.app/sse), Airtable (https://mcp.airtable.com/mcp), Apify (https://mcp.apify.com)."
                    },
                    "notionParentPageUrl": {
                        "title": "Notion parent page (Notion connector only)",
                        "type": "string",
                        "description": "URL (or id) of the Notion page under which item pages are created. Required to enable the Notion export; ignored by other connectors."
                    },
                    "maxNotifyListings": {
                        "title": "Max items to export per connector",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Cap on items written to each connector per run. Does not affect the dataset.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
