# Crexi Commercial Real Estate Scraper (`automation-lab/crexi-commercial-real-estate-scraper`) Actor

🏢 Export public Crexi listings with prices, locations, sizes, property types, brokerages, images, financial fields, and timestamps.

- **URL**: https://apify.com/automation-lab/crexi-commercial-real-estate-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Real estate
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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 web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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 Commercial Real Estate Scraper

Export public commercial property listings from Crexi into clean JSON, CSV, Excel, XML, or RSS data.

Use any filtered Crexi search URL to collect property IDs, listing links, names, addresses, asking prices, sizes, property types, brokerages, images, investment fields, and timestamps. The Actor talks to Crexi's public listing API, so routine searches are fast and do not require a browser or Crexi account.

### What does Crexi Commercial Real Estate Scraper do?

The Actor converts public Crexi search results into one structured dataset row per property.

It can:

- 🏢 scrape sale and lease inventory from public Crexi searches
- 📍 preserve location, city, state, ZIP, county, and coordinates
- 💰 extract asking price, cap rate, NOI, size, and investment type when public
- 🤝 collect public brokerage and broker metadata
- 🖼️ retain listing thumbnails and public image metadata
- 🔄 paginate large searches and remove duplicate property IDs
- 🧾 preserve the source API payload for advanced analysis
- ⏱️ add source and scrape timestamps for monitoring workflows

### Who is it for?

#### Commercial real estate investors

Build acquisition lists, compare asking prices, and screen opportunities by market or property type.

#### Brokers and business-development teams

Track active inventory, identify listing brokerages, and organize prospecting research.

#### Appraisers and lenders

Collect current asking-price and property-size evidence for market snapshots and underwriting research.

#### Market-data and analytics teams

Create repeatable inventory feeds for dashboards, warehouses, alerting systems, and historical comparisons.

#### Developers

Integrate public Crexi listings through the Apify API without maintaining pagination and normalization code.

### Why use this Crexi scraper?

- **Search URL support:** configure filters on Crexi and paste the resulting URL.
- **Fast HTTP extraction:** no full browser is required for normal listing searches.
- **Stable identifiers:** deduplication uses Crexi property IDs.
- **Partial-result safety:** search rows are retained if optional detail enrichment fails.
- **Data lineage:** each row includes its source search URL and collection time.
- **Raw payload access:** newly exposed Crexi fields remain available in `raw`.
- **Scheduled monitoring:** run daily or weekly and compare datasets over time.

### What data can you extract?

| Field | Description |
|---|---|
| `propertyId` | Stable Crexi property ID |
| `url` | Public property listing URL |
| `name` | Listing or property name |
| `description` | Public listing summary |
| `status` | Listing status, such as On-Market or Auction |
| `propertyTypes` | Commercial property categories |
| `askingPrice` | Public asking price |
| `squareFootage` | Public building or offering size |
| `capRate` | Public capitalization rate when available |
| `netOperatingIncome` | Public NOI when available |
| `investmentType` | Investment profile, such as Value Add |
| `location` | Address, city, county, state, ZIP, and coordinates |
| `brokerageName` | Public listing brokerage |
| `brokers` | Public broker metadata from detail enrichment |
| `thumbnailUrl` | Primary listing image |
| `images` | Public image metadata from detail enrichment |
| `activatedOn` | Listing activation timestamp |
| `updatedOn` | Listing update timestamp |
| `scrapedAt` | Actor collection timestamp |
| `sourceUrl` | Crexi search URL that produced the record |
| `raw` | Complete public source payload |

Fields may be absent when a listing owner does not publish that information.

### How to scrape Crexi listings

1. Open the public Crexi properties search.
2. Apply location, property-type, price, and other filters.
3. Copy the resulting `/properties` URL.
4. Paste it into **Crexi search URLs**.
5. Choose the maximum number of listings.
6. Enable detail enrichment only when you need additional public fields.
7. Click **Start**.
8. Export the dataset in your preferred format.

### Input

```json
{
  "searchUrls": [
    "https://www.crexi.com/properties?types%5B%5D=Retail"
  ],
  "maxItems": 100,
  "fetchDetails": false,
  "pageSize": 60,
  "sortOrder": "rank"
}
````

#### Input options

| Option | Type | Default | Purpose |
|---|---|---:|---|
| `searchUrls` | string array | Retail search | Public Crexi property search URLs |
| `maxItems` | integer | 100 | Global maximum unique listings |
| `fetchDetails` | boolean | false | Request each public property detail endpoint |
| `pageSize` | integer | 60 | Listings requested per API page |
| `sortOrder` | string | `rank` | Relevance, newest, price, or cap-rate ordering |

### Output example

```json
{
  "propertyId": 2558765,
  "url": "https://www.crexi.com/properties/2558765/alabama-vacant-freestanding-qsr-w-drive-thru",
  "name": "Vacant Freestanding QSR w Drive-Thru",
  "status": "Auction",
  "propertyTypes": ["Retail"],
  "askingPrice": 25000,
  "squareFootage": 1130,
  "investmentType": "Value Add",
  "location": {
    "city": "Birmingham",
    "state": { "code": "AL", "name": "Alabama" },
    "zip": "35218"
  },
  "brokerageName": "Diversified Realty Exchange",
  "updatedOn": "2026-07-09T21:07:20.598Z",
  "sourceUrl": "https://www.crexi.com/properties?types%5B%5D=Retail"
}
```

### Search URL examples

#### Retail inventory

```text
https://www.crexi.com/properties?types%5B%5D=Retail
```

#### Multiple property types

Use Crexi's interface to select multiple types, then copy the complete URL. Repeated query keys such as `types[]` are retained as arrays.

#### Location-specific search

Choose a city, county, state, or map region on Crexi. The resulting `placeIds[]`, map center, and related public filters are forwarded to the listing API.

### Optional detail enrichment

Set `fetchDetails` to `true` to request the public asset endpoint for every listing.

This may add:

- broker arrays
- cap rate and NOI
- gallery metadata
- property descriptions
- investment and occupancy details
- additional public listing attributes

Enrichment increases request count and runtime. If a detail request fails, the Actor still stores the useful search result.

### How much does it cost to scrape Crexi listings?

This Actor uses pay-per-event pricing: a small start charge plus a charge for each property saved. The exact amount is shown in the Apify Console before a run and decreases on higher platform tiers.

You control cost with `maxItems`. Start with 20 records, verify the fields, and then scale to the inventory volume you need.

### Tips for reliable results

- Use a focused Crexi search URL for precise market exports.
- Keep `fetchDetails` off if search-level fields are sufficient.
- Use stable property IDs when comparing runs.
- Schedule focused searches instead of repeatedly exporting the entire national feed.
- Keep the `raw` field when building long-lived pipelines.
- Expect optional financial fields to vary by listing.

### Listing monitoring workflow

1. Save a filtered search input as an Apify Task.
2. Schedule the Task daily or weekly.
3. Send datasets to cloud storage or a webhook.
4. Match records by `propertyId`.
5. Compare `askingPrice`, `status`, and `updatedOn`.
6. Alert when properties appear, disappear, or change.

### Lead sourcing workflow

Export `name`, `location`, `propertyTypes`, `brokerageName`, `url`, and public broker metadata. Filter the dataset for your market, then import qualified rows into a CRM for human review.

Do not use the Actor to send unsolicited messages or circumvent access controls.

### Integrations

#### Google Sheets

Use the Apify Google Sheets integration to create a searchable CRE inventory table.

#### Airtable

Upsert rows by `propertyId` and add internal underwriting or outreach status fields.

#### Make and Zapier

Trigger automations when scheduled runs complete or when a matching property enters the dataset.

#### Webhooks

Notify your application after a run and retrieve records through the dataset API.

#### Data warehouses

Load JSON or CSV exports into BigQuery, Snowflake, PostgreSQL, or your preferred analytics stack.

### API usage

#### JavaScript API example

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/crexi-commercial-real-estate-scraper').call({
  searchUrls: ['https://www.crexi.com/properties?types%5B%5D=Retail'],
  maxItems: 100,
  fetchDetails: false,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### Python API example

```python
from apify_client import ApifyClient

client = ApifyClient('YOUR_APIFY_TOKEN')
run = client.actor('automation-lab/crexi-commercial-real-estate-scraper').call(run_input={
    'searchUrls': ['https://www.crexi.com/properties?types%5B%5D=Retail'],
    'maxItems': 100,
    'fetchDetails': False,
})
for item in client.dataset(run['defaultDatasetId']).iterate_items():
    print(item)
```

### cURL API example

```bash
curl -X POST \
  'https://api.apify.com/v2/acts/automation-lab~crexi-commercial-real-estate-scraper/runs?token=YOUR_APIFY_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"searchUrls":["https://www.crexi.com/properties?types%5B%5D=Retail"],"maxItems":100}'
```

### Use with Apify MCP

Connect the Actor to AI clients through [Apify MCP](https://mcp.apify.com/?tools=automation-lab/crexi-commercial-real-estate-scraper).

#### Claude Code

```bash
claude mcp add apify --transport http \
  'https://mcp.apify.com/?tools=automation-lab/crexi-commercial-real-estate-scraper'
```

Example prompts:

- “Export 100 public Retail listings from this Crexi search and summarize asking prices.”
- “Find newly updated industrial properties in this dataset and group them by state.”
- “Compare cap rates among enriched Crexi listings where the field is public.”

#### Claude Desktop

Add this server to `claude_desktop_config.json`. Claude Desktop launches the remote-MCP bridge and opens Apify authentication when you first use the tool.

```json
{
  "mcpServers": {
    "apify": {
      "command": "npx",
      "args": [
        "-y",
        "mcp-remote",
        "https://mcp.apify.com/?tools=automation-lab/crexi-commercial-real-estate-scraper"
      ]
    }
  }
}
```

#### Cursor

Create or update `.cursor/mcp.json` in your project, then enable the `apify` server in **Cursor Settings → MCP**:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com/?tools=automation-lab/crexi-commercial-real-estate-scraper"
    }
  }
}
```

#### VS Code

Create `.vscode/mcp.json`, then run **MCP: List Servers** and start `apify`. VS Code prompts you to authenticate with Apify on first use.

```json
{
  "servers": {
    "apify": {
      "type": "http",
      "url": "https://mcp.apify.com/?tools=automation-lab/crexi-commercial-real-estate-scraper"
    }
  }
}
```

### Scheduling

Save the input as an Apify Task and use **Schedules** to run it automatically. A focused scheduled search provides a repeatable inventory snapshot without manual exports.

### Data quality

The Actor normalizes high-value fields but does not invent missing values. Crexi sellers control which pricing and financial details are public. Always review source listings before making an investment, lending, appraisal, or outreach decision.

### Error handling

Transient server and rate-limit responses are retried with exponential delay. Invalid non-Crexi URLs fail early. Duplicate IDs are ignored. A failed optional detail request produces a warning while preserving the search record.

### Legality

This Actor collects information exposed on public Crexi listing surfaces. Whether a particular use is lawful depends on your jurisdiction, purpose, contractual obligations, and the data you process.

Use reasonable request volumes, respect applicable laws and rights, avoid personal-data misuse, and review Crexi's terms. This documentation is not legal advice.

### FAQ

#### Does it require a Crexi account?

No. The supported search and public listing fields do not require Crexi credentials.

#### Can it scrape filtered searches?

Yes. Paste the complete filtered `/properties` URL. Array and scalar query parameters are forwarded.

#### Why is a financial field missing?

Not every listing publicly discloses price, cap rate, NOI, or other investment metrics. Enable detail enrichment, but expect some fields to remain absent.

#### Why did fewer records appear than requested?

The filtered search may contain fewer unique results, or Crexi may return an empty page before the requested cap.

#### Does it scrape private broker contact details?

No. It only preserves broker metadata returned by the public listing endpoints and does not bypass login controls.

#### How do I avoid duplicate records?

The Actor deduplicates by Crexi property ID during each run. For historical pipelines, upsert records by `propertyId` across runs.

### Related real estate scrapers

Explore other real-estate and market-data Actors from [automation-lab](https://apify.com/automation-lab) to combine Crexi inventory with additional public sources. Only use sources and data that fit your compliance requirements.

### Support

If a public Crexi search URL produces unexpected output, open an Actor issue with the input URL, run ID, expected fields, and a short example. Do not include private credentials or confidential deal information.

# Actor input Schema

## `searchUrls` (type: `array`):

Paste filtered public Crexi /properties URLs. Filters in each URL are preserved.

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

Stop after this many unique property listings across all searches.

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

Request each public property endpoint for additional financial, broker, and image fields. Search rows are kept if enrichment fails.

## `pageSize` (type: `integer`):

Number of listings requested per Crexi API page.

## `sortOrder` (type: `string`):

Choose how Crexi orders each search feed.

## Actor input object example

```json
{
  "searchUrls": [
    "https://www.crexi.com/properties?types%5B%5D=Retail"
  ],
  "maxItems": 20,
  "fetchDetails": false,
  "pageSize": 60,
  "sortOrder": "rank"
}
```

# 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 = {
    "searchUrls": [
        "https://www.crexi.com/properties?types%5B%5D=Retail"
    ],
    "maxItems": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/crexi-commercial-real-estate-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 = {
    "searchUrls": ["https://www.crexi.com/properties?types%5B%5D=Retail"],
    "maxItems": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/crexi-commercial-real-estate-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 '{
  "searchUrls": [
    "https://www.crexi.com/properties?types%5B%5D=Retail"
  ],
  "maxItems": 20
}' |
apify call automation-lab/crexi-commercial-real-estate-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Crexi Commercial Real Estate Scraper",
        "description": "🏢 Export public Crexi listings with prices, locations, sizes, property types, brokerages, images, financial fields, and timestamps.",
        "version": "0.1",
        "x-build-id": "zDJAndaxAmpKlEprH"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~crexi-commercial-real-estate-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-crexi-commercial-real-estate-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/automation-lab~crexi-commercial-real-estate-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-crexi-commercial-real-estate-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/automation-lab~crexi-commercial-real-estate-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-crexi-commercial-real-estate-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": {
                    "searchUrls": {
                        "title": "🏢 Crexi search URLs",
                        "type": "array",
                        "description": "Paste filtered public Crexi /properties URLs. Filters in each URL are preserved.",
                        "items": {
                            "type": "string",
                            "pattern": "^https://www\\.crexi\\.com/properties"
                        },
                        "default": [
                            "https://www.crexi.com/properties?types%5B%5D=Retail"
                        ]
                    },
                    "maxItems": {
                        "title": "Maximum listings",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Stop after this many unique property listings across all searches.",
                        "default": 100
                    },
                    "fetchDetails": {
                        "title": "Enrich property details",
                        "type": "boolean",
                        "description": "Request each public property endpoint for additional financial, broker, and image fields. Search rows are kept if enrichment fails.",
                        "default": false
                    },
                    "pageSize": {
                        "title": "Listings per API page",
                        "minimum": 10,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Number of listings requested per Crexi API page.",
                        "default": 60
                    },
                    "sortOrder": {
                        "title": "Sort order",
                        "enum": [
                            "rank",
                            "newest",
                            "priceLowToHigh",
                            "priceHighToLow",
                            "capRate"
                        ],
                        "type": "string",
                        "description": "Choose how Crexi orders each search feed.",
                        "default": "rank"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
