# Crexi Commercial Real Estate Yield & Off-Market Scraper (`xtracto/crexi-yield-scraper`) Actor

Scrape Crexi commercial real estate listings by map area: Cap Rate, NOI, Pro-Forma Cap Rate/NOI, asking price, asset class, occupancy, and broker details. Auto-subdivides dense markets so you never miss a listing.

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

## Pricing

from $15.00 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
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 Real Estate Scraper — Cap Rate, NOI & Off-Market Yield

Extract commercial real estate listings from **Crexi** by map area — with the financial
yield metrics that actually matter to investors: **Cap Rate, NOI, asking price, asset
class, and broker/brokerage details**. Built for institutional investors, hedge funds, and
acquisition teams sourcing undervalued commercial assets by the numbers, not by browsing.

### Why use this actor

- 💰 **The yield metrics, not just the address** — Cap Rate, NOI, Pro-Forma Cap Rate &
  Pro-Forma NOI, price per square foot, occupancy, and year built, captured for every
  listing that publishes them.
- 🗺️ **Search by map, get the whole market** — give it a geographic area and it
  automatically works through dense markets in tiles so you don't miss listings hidden
  behind a single page's result limit.
- 🏢 **Every commercial asset class** — Multifamily, Retail, Office, Industrial, Land,
  Hospitality, Self Storage, and Special Purpose, with an optional class filter.
- 🤝 **Broker & brokerage details** — broker name, brokerage firm, website, and license
  number for every listing.
- 📊 **Clean, stable JSON** — ready to drop into a database, spreadsheet, or RAG/analytics
  pipeline. Download as JSON, CSV, or Excel.
- 🔁 **Hands-off and resilient** — no account, no login, no API key. Automatic retries
  keep runs steady, and a global result cap protects you from runaway jobs.

### How it works

1. You give the actor one or more **map areas** (bounding boxes) and, optionally, the
   asset classes you care about — e.g. Multifamily across Los Angeles County.
2. The actor finds every commercial listing in that area. When an area is too dense to
   return in one pass, it automatically splits it into smaller sections and keeps going
   until everything is collected — duplicates removed automatically.
3. For each property it then pulls the full **financial detail** (Cap Rate, NOI,
   pro-forma figures, price/SqFt, occupancy) and the **broker/brokerage** information.
4. Results stream into your dataset, ready to download as JSON, CSV, or Excel.

You don't manage scrapers, browsers, accounts, or sessions — just describe the area and
run it.

### Use Cases

**Deal sourcing by yield threshold**
Set a target market (e.g. Phoenix metro) and cap rate floor (e.g. ≥6%), then filter the output for `capRate >= 6`. Run it weekly to catch every new Multifamily or Industrial listing that clears your hurdle rate before it lands on a broker's email list.

**Multi-market portfolio screening**
Give it bounding boxes for five metros at once — New York, Dallas, Miami, Denver, Atlanta — and compare average cap rates, NOI ranges, and price-per-sqft across markets in one dataset. Spot where your capital is best deployed without opening a single listing page.

**Broker & brokerage relationship mapping**
Extract the `brokers` block for every listing in a target market, de-duplicate by `publicProfileId`, and rank brokers by deal volume. Use it to identify the top 10 active brokers for Retail in Chicago before you pick up the phone.

**Value-add pipeline building**
Filter on `investmentType: "Value Add"` and `proFormaCapRatePct > capRatePct` to surface properties with the biggest spread between in-place and pro-forma NOI — the clearest signal of repositioning upside.

**Off-market & unpriced listing watch**
Set `includeUnpriced: true` to capture call-for-offers and auction listings before they get public pricing. Stack these against comparable sold comps in your own database to arrive at a bid before the seller sets a number.

### Input

Run it as-is (the example below is pre-filled), or adjust the area and filters:

```json
{
  "searchAreas": [
    {
      "label": "Los Angeles County",
      "north": 34.35,
      "south": 33.70,
      "east": -118.10,
      "west": -118.70
    }
  ],
  "assetTypes": ["Multifamily"],
  "includeUnpriced": false,
  "maxProperties": 200,
  "enrichFinancials": true,
  "enrichBrokers": true,
  "enrichmentConcurrency": 5
}
````

| Field | Type | Description |
|---|---|---|
| `searchAreas` | array | Map areas to scan. Each is `{ "label", "north", "south", "east", "west" }` in decimal degrees (north/south = latitude, east/west = longitude). Leave empty to scan the entire continental US (pair with a `maxProperties` cap). |
| `assetTypes` | array | Filter by asset class: `Multifamily`, `Retail`, `Office`, `Industrial`, `Land`, `Hospitality`, `Self Storage`, `Special Purpose`. Empty = all classes. |
| `includeUnpriced` | boolean | Include call-for-offers / auction / off-market listings with no published price. Default: `true`. |
| `maxProperties` | integer | Maximum unique properties to collect across all areas. Default: `200`. |
| `enrichFinancials` | boolean | Add the Cap Rate / NOI financial detail to each property. **Leave on** — these figures are the core value and are not part of the basic listing. Default: `true`. |
| `enrichBrokers` | boolean | Add broker & brokerage details to each property. Default: `true`. |
| `enrichmentConcurrency` | integer | How many detail lookups to run at once. Default: `5`. |
| `resultCapPerTile` | integer | Advanced: result threshold above which a map area is split into smaller sections. Default: `1440`. |
| `minTileSpanDeg` | number | Advanced: smallest map section to split down to (≈1 km at `0.01`). Default: `0.01`. |
| `maxQuadtreeDepth` | integer | Advanced: maximum number of times an area may be subdivided. Default: `8`. |
| `proxyConfiguration` | object | Optional. Apify Proxy is recommended for large multi-market sweeps. |

> **Note on broker contact:** Crexi does not publish broker email or phone numbers — those
> are only reachable through its in-app messaging. This actor returns everything that *is*
> public: broker name, brokerage firm, website, and license number.

### Output

One record per property. Real sample (Multifamily, Los Angeles County — long arrays
truncated):

```json
{
  "_source": "S1-api",
  "_input": "Los Angeles County",
  "_scrapedAt": "2026-05-29T08:10:18Z",
  "id": 2530138,
  "name": "5934 Buffalo Ave",
  "types": ["Multifamily"],
  "status": "On-Market",
  "investmentType": "Value Add",
  "askingPrice": 3950000.0,
  "capRate": 4.0,
  "noi": 157941.0,
  "squareFootage": 15331,
  "financials": {
    "askingPrice": 3950000.0,        "askingPriceDisplay": "$3,950,000",
    "capRatePct": 4.0,               "capRatePctDisplay": "4.00%",
    "proFormaCapRatePct": 6.49,      "proFormaCapRatePctDisplay": "6.49%",
    "noi": 157941.0,                 "noiDisplay": "$157,941",
    "proFormaNoi": 256353.0,         "proFormaNoiDisplay": "$256,353",
    "occupancyPct": "93",            "occupancyPctDisplay": "93%",
    "squareFootage": 15331,          "squareFootageDisplay": "15,331",
    "yearBuilt": "1972",             "yearBuiltDisplay": "1972"
  },
  "primaryAddress": "5934 Buffalo Ave, Van Nuys, CA 91401",
  "primaryLatitude": 34.1785214,
  "primaryLongitude": -118.4293149,
  "brokers": [
    {
      "firstName": "Jenny",
      "lastName": "Eng",
      "brokerageName": "CBRE - Glendale",
      "brokerageWebsite": "https://www.cbre.com/offices/corporate/los-angeles",
      "licenses": ["CA 01931224"],
      "numberOfAssets": 127,
      "publicProfileId": "jennyen"
    }
    // ... 2 more
  ],
  "listingUrl": "https://www.crexi.com/properties/2530138/california-5934-buffalo-ave"
}
```

| Field | Type | Description |
|---|---|---|
| `name` | string | Property title / listing name. |
| `types` | array | Asset class(es), e.g. `["Multifamily"]`. |
| `status` | string | Listing status, e.g. `On-Market`. |
| `investmentType` | string | Investment angle, e.g. `Value Add`, `Owner/User`. |
| `askingPrice` | number | Asking price in USD (absent for unpriced listings). |
| `capRate` | number | **Cap Rate** as a percentage (e.g. `4.0` = 4.00%). |
| `noi` | number | **Net Operating Income** in USD. |
| `squareFootage` | number | Building square footage. |
| `financials` | object | Full financial block: cap rate, NOI, pro-forma cap rate & NOI, occupancy, price/SqFt, units, year built — each with a numeric value and a formatted `*Display` string. |
| `primaryAddress` | string | Full street address of the property. |
| `primaryLatitude` / `primaryLongitude` | number | Property coordinates. |
| `brokers` | array | Broker(s): `firstName`, `lastName`, `brokerageName`, `brokerageWebsite`, `licenses`, `numberOfAssets`, `publicProfileId`. |
| `listingUrl` | string | Direct link to the listing on Crexi. |
| `summaryDetails` / `details` | array / object | The complete raw detail blocks from the listing, kept for full fidelity. |
| `locations` | array | Raw location records (all addresses associated with the asset). |
| `_source` | string | Always `S1-api` for a successful record. |
| `_input` | string | The search-area label this record came from. |
| `_scrapedAt` | string | UTC timestamp (ISO 8601) of when the record was collected. |

Failed inputs are returned as error records carrying `_error`, `_errorDetail`, and
`_source: "none"` (never silently dropped), and an undersampled map section is flagged
with `_warning` so you always know your coverage.

### Other actors in this collection

| Actor | What it extracts |
|---|---|
| [ThomasNet US B2B Supplier & Manufacturer Scraper](https://apify.com/) | US/North-American manufacturers & suppliers: capabilities, certifications, revenue, employees, location. |
| [Myfxbook Community Outlook / Retail Sentiment Scraper](https://apify.com/) | Retail FX long/short sentiment, positions, and volume by currency pair. |

# Actor input Schema

## `searchAreas` (type: `array`):

List of geographic bounding boxes to scrape, each {"label","north","south","east","west"} in decimal degrees (north/south = latitude, east/west = longitude). The actor auto-subdivides any box denser than Crexi's 1,440-result paging cap into quadrants. Leave empty to scan the continental US (very large — pair with a Max properties cap).

## `assetTypes` (type: `array`):

Filter by commercial asset class. Leave empty for all classes.

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

Include listings with no published asking price (call-for-offers / auction / off-market). Turn off to keep only priced assets.

## `maxProperties` (type: `integer`):

Global cap on unique properties collected across all search areas. Protects against runaway runs over dense regions (a single metro can hold thousands).

## `enrichFinancials` (type: `boolean`):

Fetch each property's detail page for the CRITICAL yield data — Cap Rate, NOI, Pro-Forma Cap Rate/NOI, price/SqFt, units, occupancy, year built. These are NOT in the search list, so leave this on to get the headline metrics. Adds one request per property.

## `enrichBrokers` (type: `boolean`):

Fetch each property's broker block (broker name, brokerage firm, website, license, public profile). Note: Crexi does not expose broker email/phone via its public API — those are gated behind in-app chat. Adds one request per property.

## `enrichmentConcurrency` (type: `integer`):

How many detail/broker requests to issue in parallel during enrichment.

## `resultCapPerTile` (type: `integer`):

When a bounding box advertises more than this many results, it is split into 4 quadrants. Crexi hard-limits deep paging at offset+count<1500 (1,440 retrievable), so values above 1440 are clamped.

## `minTileSpanDeg` (type: `number`):

Recursion floor: stop subdividing once a tile is smaller than this (in degrees, ~0.01 ≈ 1km). Tiles still capped at the floor are flagged as undersampled.

## `maxQuadtreeDepth` (type: `integer`):

Hard ceiling on recursive subdivision depth (4^depth leaf tiles max from one input box).

## `browserProfile` (type: `string`):

TLS fingerprint the actor imitates. Crexi uses Cloudflare, which the default Chrome profile clears. Change only if results start failing.

## `logLevel` (type: `string`):

Set DEBUG to surface per-tile/per-request diagnostics while troubleshooting.

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

Crexi's Cloudflare trusts a real Chrome TLS handshake, so datacenter proxy works for light runs. Use Residential for large multi-thousand-property sweeps to spread request volume.

## Actor input object example

```json
{
  "searchAreas": [
    {
      "label": "Los Angeles County",
      "north": 34.35,
      "south": 33.7,
      "east": -118.1,
      "west": -118.7
    }
  ],
  "includeUnpriced": true,
  "maxProperties": 200,
  "enrichFinancials": true,
  "enrichBrokers": true,
  "enrichmentConcurrency": 5,
  "resultCapPerTile": 1440,
  "minTileSpanDeg": 0.01,
  "maxQuadtreeDepth": 8,
  "browserProfile": "chrome131",
  "logLevel": "INFO",
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# 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 = {
    "searchAreas": [
        {
            "label": "Los Angeles County",
            "north": 34.35,
            "south": 33.7,
            "east": -118.1,
            "west": -118.7
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("xtracto/crexi-yield-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 = { "searchAreas": [{
            "label": "Los Angeles County",
            "north": 34.35,
            "south": 33.7,
            "east": -118.1,
            "west": -118.7,
        }] }

# Run the Actor and wait for it to finish
run = client.actor("xtracto/crexi-yield-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 '{
  "searchAreas": [
    {
      "label": "Los Angeles County",
      "north": 34.35,
      "south": 33.7,
      "east": -118.1,
      "west": -118.7
    }
  ]
}' |
apify call xtracto/crexi-yield-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Crexi Commercial Real Estate Yield & Off-Market Scraper",
        "description": "Scrape Crexi commercial real estate listings by map area: Cap Rate, NOI, Pro-Forma Cap Rate/NOI, asking price, asset class, occupancy, and broker details. Auto-subdivides dense markets so you never miss a listing.",
        "version": "0.1",
        "x-build-id": "kVLwv3ChfhXKFcL8P"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/xtracto~crexi-yield-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-xtracto-crexi-yield-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/xtracto~crexi-yield-scraper/runs": {
            "post": {
                "operationId": "runs-sync-xtracto-crexi-yield-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/xtracto~crexi-yield-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-xtracto-crexi-yield-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": {
                    "searchAreas": {
                        "title": "Search areas (map bounding boxes)",
                        "type": "array",
                        "description": "List of geographic bounding boxes to scrape, each {\"label\",\"north\",\"south\",\"east\",\"west\"} in decimal degrees (north/south = latitude, east/west = longitude). The actor auto-subdivides any box denser than Crexi's 1,440-result paging cap into quadrants. Leave empty to scan the continental US (very large — pair with a Max properties cap)."
                    },
                    "assetTypes": {
                        "title": "Asset classes",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Filter by commercial asset class. Leave empty for all classes.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "Multifamily",
                                "Retail",
                                "Office",
                                "Industrial",
                                "Land",
                                "Hospitality",
                                "Self Storage",
                                "Special Purpose"
                            ]
                        }
                    },
                    "includeUnpriced": {
                        "title": "Include unpriced listings",
                        "type": "boolean",
                        "description": "Include listings with no published asking price (call-for-offers / auction / off-market). Turn off to keep only priced assets.",
                        "default": true
                    },
                    "maxProperties": {
                        "title": "Max properties",
                        "minimum": 1,
                        "maximum": 50000,
                        "type": "integer",
                        "description": "Global cap on unique properties collected across all search areas. Protects against runaway runs over dense regions (a single metro can hold thousands).",
                        "default": 200
                    },
                    "enrichFinancials": {
                        "title": "Enrich with financial yield metrics (Cap Rate / NOI)",
                        "type": "boolean",
                        "description": "Fetch each property's detail page for the CRITICAL yield data — Cap Rate, NOI, Pro-Forma Cap Rate/NOI, price/SqFt, units, occupancy, year built. These are NOT in the search list, so leave this on to get the headline metrics. Adds one request per property.",
                        "default": true
                    },
                    "enrichBrokers": {
                        "title": "Enrich with broker / brokerage details",
                        "type": "boolean",
                        "description": "Fetch each property's broker block (broker name, brokerage firm, website, license, public profile). Note: Crexi does not expose broker email/phone via its public API — those are gated behind in-app chat. Adds one request per property.",
                        "default": true
                    },
                    "enrichmentConcurrency": {
                        "title": "Enrichment concurrency",
                        "minimum": 1,
                        "maximum": 16,
                        "type": "integer",
                        "description": "How many detail/broker requests to issue in parallel during enrichment.",
                        "default": 5
                    },
                    "resultCapPerTile": {
                        "title": "Result cap per tile (advanced)",
                        "minimum": 60,
                        "maximum": 1440,
                        "type": "integer",
                        "description": "When a bounding box advertises more than this many results, it is split into 4 quadrants. Crexi hard-limits deep paging at offset+count<1500 (1,440 retrievable), so values above 1440 are clamped.",
                        "default": 1440
                    },
                    "minTileSpanDeg": {
                        "title": "Minimum tile span in degrees (advanced)",
                        "type": "number",
                        "description": "Recursion floor: stop subdividing once a tile is smaller than this (in degrees, ~0.01 ≈ 1km). Tiles still capped at the floor are flagged as undersampled.",
                        "default": 0.01
                    },
                    "maxQuadtreeDepth": {
                        "title": "Max quadtree depth (advanced)",
                        "minimum": 1,
                        "maximum": 12,
                        "type": "integer",
                        "description": "Hard ceiling on recursive subdivision depth (4^depth leaf tiles max from one input box).",
                        "default": 8
                    },
                    "browserProfile": {
                        "title": "Browser compatibility profile",
                        "enum": [
                            "chrome131",
                            "chrome136",
                            "chrome145",
                            "safari18_0"
                        ],
                        "type": "string",
                        "description": "TLS fingerprint the actor imitates. Crexi uses Cloudflare, which the default Chrome profile clears. Change only if results start failing.",
                        "default": "chrome131"
                    },
                    "logLevel": {
                        "title": "Log level",
                        "enum": [
                            "INFO",
                            "DEBUG"
                        ],
                        "type": "string",
                        "description": "Set DEBUG to surface per-tile/per-request diagnostics while troubleshooting.",
                        "default": "INFO"
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Crexi's Cloudflare trusts a real Chrome TLS handshake, so datacenter proxy works for light runs. Use Residential for large multi-thousand-property sweeps to spread request volume.",
                        "default": {
                            "useApifyProxy": true
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
