# Crexi Scraper — Commercial Real Estate Listings (`khadinakbar/crexi-commercial-real-estate-scraper`) Actor

Scrape Crexi commercial real estate for-sale listings — asking price, cap rate, NOI, size, zoning, broker & geo. Filter by type, state, city, ZIP, price, cap rate. MCP-ready.

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

## Pricing

from $8.00 / 1,000 property enriched (full detail + broker)s

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are 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 Scraper — Commercial Real Estate Listings

Scrape **commercial real estate for-sale listings from [Crexi](https://www.crexi.com)** — the largest US CRE marketplace — into clean, structured JSON. Filter by property type, state, city, ZIP, asking price, and cap rate, then optionally deep-enrich every listing with cap rate, NOI, year built, zoning, lot size, marketing description, and broker details.

Built HTTP-only against Crexi's public JSON API. No login, no cookies, fast and reliable. **MCP-ready** — drop it straight into an AI agent (Claude, ChatGPT, Gemini) as a tool.

### What you can do

- **Search by filters** — property type (Office, Retail, Industrial, Multifamily, Land, Hospitality, Mixed Use, Special Purpose, Self Storage, Mobile Home Park, Business for Sale, Senior Living), subtype, state, city, ZIP, price band, and cap-rate band.
- **Scrape specific listings** — paste Crexi property URLs and pull full detail for each.
- **Deep-enrich** — add cap rate, NOI, year built, zoning, lot size, APN, marketing description, investment highlights, and broker (name, brokerage, license, title) per listing.
- Feed the output into a CRM, deal-flow tracker, comps database, market-research model, or lead list.

### Who it's for

CRE brokers, acquisitions teams, private-equity and REIT analysts, appraisers, and PropTech builders who need Crexi deal data in bulk without copy-pasting from the site.

### Output — one record per listing

| Field | Description |
|---|---|
| `id` | Crexi listing ID |
| `name` | Listing name |
| `url` | Public Crexi listing URL |
| `propertyTypes` / `subtypes` | Asset classes and subtypes |
| `status` | e.g. `On-Market` |
| `askingPrice` / `isUnpriced` | Asking price in USD; unpriced flag |
| `capRate` / `noi` | Cap rate (%) and net operating income (USD) |
| `squareFootage` / `units` | Building size and unit count |
| `yearBuilt` / `lotSizeAcres` / `zoning` / `apn` | Physical + legal attributes |
| `address` / `city` / `county` / `state` / `zip` | Full location |
| `latitude` / `longitude` | Geo coordinates |
| `brokerageName` / `brokers[]` | Listing brokerage + broker name, title, license, state |
| `description` / `investmentHighlights` | Marketing copy (plain text) |
| `imageUrl` / `galleryCount` | Primary image + gallery size |
| `hasVideo` / `hasVirtualTour` / `isInOpportunityZone` | Media + zone flags |
| `activatedOn` / `updatedOn` / `scrapedAt` | ISO 8601 timestamps |

> `capRate`, `noi`, `yearBuilt`, `zoning`, `apn`, `description`, and `brokers` are populated when **Deep-enrich** is on (default) or when scraping property URLs. With enrichment off, you get the fast listing-card fields only.

### Pricing (pay-per-event)

| Event | Price |
|---|---|
| Actor start | $0.00005 |
| Property scraped (card fields, enrichment off) | $0.004 |
| Property enriched (full detail + broker) | $0.008 |

A typical 100-listing enriched run costs about **$0.80**. Turn off enrichment to halve the cost for lead-list use cases that only need price, size, type, and location.

### Example input — search

```json
{
  "propertyTypes": ["Multifamily"],
  "states": ["TX"],
  "cities": ["Austin"],
  "minPrice": 500000,
  "maxPrice": 5000000,
  "minCapRate": 6,
  "enrichDetails": true,
  "maxResults": 100
}
````

### Example input — specific listings

```json
{
  "propertyUrls": [
    "https://www.crexi.com/properties/2608102/michigan-5084-lovers-lane",
    "https://www.crexi.com/properties/2608071/ohio-14307-state-route-113"
  ]
}
```

### Run via API

**JavaScript (Apify client):**

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

const client = new ApifyClient({ token: 'YOUR_TOKEN' });
const run = await client.actor('khadinakbar/crexi-commercial-real-estate-scraper').call({
    propertyTypes: ['Retail'],
    states: ['FL'],
    maxResults: 50,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

**Python (Apify client):**

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_TOKEN")
run = client.actor("khadinakbar/crexi-commercial-real-estate-scraper").call(run_input={
    "propertyTypes": ["Industrial"],
    "states": ["CA"],
    "minCapRate": 5,
    "maxResults": 100,
})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["name"], item.get("askingPrice"), item.get("capRate"))
```

### Use as an MCP tool

Expose it to an AI agent via Apify's hosted MCP server:

```
https://mcp.apify.com?tools=khadinakbar/crexi-commercial-real-estate-scraper
```

The agent supplies filters or property URLs and receives structured listing JSON — ideal for "find me Austin multifamily deals under $3M with a 6%+ cap rate."

### FAQ

**Does it need Crexi login or cookies?** No. It uses Crexi's public JSON API. No credentials.

**Does it cover leases?** This version covers **for-sale** listings (the core Crexi marketplace, ~243K live listings). Lease listings are not included yet.

**Does it return broker emails/phones?** No — Crexi gates broker contact details behind login. You get broker name, brokerage, license, state, and title, which are publicly visible.

**How fresh is the data?** Listings are read live from Crexi at run time.

**Why are some fields empty?** With enrichment off, detail-only fields (cap rate, NOI, zoning, etc.) are not fetched. Turn on **Deep-enrich** for the full record.

**Can I get the whole market?** Yes — leave filters empty and raise `maxResults`. Watch the cost cap shown in the run log before large runs.

### Legal & compliance

This actor collects **publicly available** listing data from Crexi for legitimate business use such as market research, comps, and lead generation. You are responsible for using the data in compliance with Crexi's Terms of Service, applicable laws (including data-protection regulations), and any downstream contractual obligations. Do not use the data to spam, harass, or violate individuals' privacy. This actor is not affiliated with or endorsed by Crexi.

# Actor input Schema

## `propertyUrls` (type: `array`):

Use this when you already know the exact Crexi listings you want. Paste full Crexi property URLs (e.g. 'https://www.crexi.com/properties/2608102/michigan-5084-lovers-lane'). Each URL is scraped in full detail regardless of the enrichment toggle. When this list is non-empty it takes priority and the search filters below are ignored. Leave empty to run a filtered search instead.

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

Filter the search to one or more commercial asset classes (e.g. \['Retail','Multifamily']). Leave empty to include every property type. A listing tagged with several types matches if any selected type applies. This is a search filter and is ignored when Property URLs are provided.

## `subtypes` (type: `array`):

Narrow results to specific subtypes as spelled on Crexi (e.g. 'Apartment Building', 'Traditional Office', 'Strip Center'). Values are matched exactly, so copy them from a Crexi listing. Leave empty to include all subtypes of the selected property types. Ignored when Property URLs are provided.

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

Filter by US state using two-letter codes (e.g. \['TX','FL']). Leave empty for nationwide results across all 50 states plus DC. Combine with cities or ZIP codes to narrow further. Ignored when Property URLs are provided.

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

Filter by city name (e.g. \['Austin','Dallas']). Best paired with the matching state to avoid same-named cities in other states. Leave empty to skip city filtering. Ignored when Property URLs are provided.

## `zipCodes` (type: `array`):

Filter by 5-digit US ZIP code (e.g. \['78701','78702']). This is the tightest geographic filter and works with or without a state. Leave empty to skip ZIP filtering. Ignored when Property URLs are provided.

## `minPrice` (type: `integer`):

Only return listings with an asking price at or above this amount in US dollars (e.g. 500000). Leave empty for no lower bound. Listings without a published price are still included unless you disable 'Include unpriced'. Ignored when Property URLs are provided.

## `maxPrice` (type: `integer`):

Only return listings with an asking price at or below this amount in US dollars (e.g. 5000000). Leave empty for no upper bound. Combine with the minimum to define a price band. Ignored when Property URLs are provided.

## `minCapRate` (type: `integer`):

Only return listings with a published capitalization rate at or above this percentage (e.g. 6 means 6%). Listings without a cap rate are excluded when this is set. Leave empty to ignore cap rate. Ignored when Property URLs are provided.

## `maxCapRate` (type: `integer`):

Only return listings with a published cap rate at or below this percentage (e.g. 12 means 12%). Combine with the minimum to define a yield band. Leave empty for no upper bound. Ignored when Property URLs are provided.

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

When true (default), listings marketed without a public asking price are included in search results. Set false to return only listings that show a dollar price. Has no effect on Property URL scraping. Ignored when Property URLs are provided.

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

When true (default), each search result is enriched with a full detail request (cap rate, pro-forma cap rate, NOI, price/SqFt, price/unit, occupancy, class, beds, buildings, stories, year built, zoning, lot size, APN, marketing description, investment highlights) plus a broker request (name, brokerage, license, title). Set false for a faster, cheaper run that returns only the listing-card fields. Property URLs are always fully enriched.

## `includeGalleryImages` (type: `boolean`):

When true, add a full-resolution image URL array (all listing photos) to each enriched record via one extra request per listing. Defaults to false to keep runs fast and cheap; the primary thumbnail is always included regardless. Has no effect when Deep-enrich is off. Does not change the per-result price.

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

Hard cap on how many listings to return and bill for in one run (e.g. 100). Search stops once this many records are pushed, protecting your budget. Applies to search mode; Property URL runs process every URL you supply. Defaults to 100.

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

Proxy used to reach Crexi's API. Defaults to Apify Proxy datacenter routing pinned to the US, which is reliable for Crexi's public API host. Leave as default unless you hit persistent rate limits, in which case enable residential. Do not disable proxy — Crexi's API expects US egress.

## Actor input object example

```json
{
  "propertyUrls": [],
  "propertyTypes": [
    "Multifamily"
  ],
  "subtypes": [],
  "states": [
    "TX"
  ],
  "cities": [],
  "zipCodes": [],
  "includeUnpriced": true,
  "enrichDetails": true,
  "includeGalleryImages": false,
  "maxResults": 100,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyCountry": "US"
  }
}
```

# Actor output Schema

## `listings` (type: `string`):

Scraped Crexi commercial real estate listings.

## `runSummary` (type: `string`):

Mode, filters, counts, and billed amount for this run.

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

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

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "propertyUrls": [],
    "propertyTypes": [
        "Multifamily"
    ],
    "subtypes": [],
    "states": [
        "TX"
    ],
    "cities": [],
    "zipCodes": [],
    "maxResults": 100
};

// Run the Actor and wait for it to finish
const run = await client.actor("khadinakbar/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 = {
    "propertyUrls": [],
    "propertyTypes": ["Multifamily"],
    "subtypes": [],
    "states": ["TX"],
    "cities": [],
    "zipCodes": [],
    "maxResults": 100,
}

# Run the Actor and wait for it to finish
run = client.actor("khadinakbar/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 '{
  "propertyUrls": [],
  "propertyTypes": [
    "Multifamily"
  ],
  "subtypes": [],
  "states": [
    "TX"
  ],
  "cities": [],
  "zipCodes": [],
  "maxResults": 100
}' |
apify call khadinakbar/crexi-commercial-real-estate-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Crexi Scraper — Commercial Real Estate Listings",
        "description": "Scrape Crexi commercial real estate for-sale listings — asking price, cap rate, NOI, size, zoning, broker & geo. Filter by type, state, city, ZIP, price, cap rate. MCP-ready.",
        "version": "0.2",
        "x-build-id": "jt5gKjqzyGZXcy3hq"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/khadinakbar~crexi-commercial-real-estate-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-khadinakbar-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/khadinakbar~crexi-commercial-real-estate-scraper/runs": {
            "post": {
                "operationId": "runs-sync-khadinakbar-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/khadinakbar~crexi-commercial-real-estate-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-khadinakbar-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": {
                    "propertyUrls": {
                        "title": "Property URLs (specific listings)",
                        "type": "array",
                        "description": "Use this when you already know the exact Crexi listings you want. Paste full Crexi property URLs (e.g. 'https://www.crexi.com/properties/2608102/michigan-5084-lovers-lane'). Each URL is scraped in full detail regardless of the enrichment toggle. When this list is non-empty it takes priority and the search filters below are ignored. Leave empty to run a filtered search instead.",
                        "items": {
                            "type": "string",
                            "pattern": "crexi\\.com"
                        }
                    },
                    "propertyTypes": {
                        "title": "Property types",
                        "type": "array",
                        "description": "Filter the search to one or more commercial asset classes (e.g. ['Retail','Multifamily']). Leave empty to include every property type. A listing tagged with several types matches if any selected type applies. This is a search filter and is ignored when Property URLs are provided.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "Office",
                                "Retail",
                                "Industrial",
                                "Multifamily",
                                "Land",
                                "Hospitality",
                                "Mixed Use",
                                "Special Purpose",
                                "Self Storage",
                                "Mobile Home Park",
                                "Business for Sale",
                                "Senior Living"
                            ]
                        }
                    },
                    "subtypes": {
                        "title": "Property subtypes",
                        "type": "array",
                        "description": "Narrow results to specific subtypes as spelled on Crexi (e.g. 'Apartment Building', 'Traditional Office', 'Strip Center'). Values are matched exactly, so copy them from a Crexi listing. Leave empty to include all subtypes of the selected property types. Ignored when Property URLs are provided.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "states": {
                        "title": "States (2-letter codes)",
                        "type": "array",
                        "description": "Filter by US state using two-letter codes (e.g. ['TX','FL']). Leave empty for nationwide results across all 50 states plus DC. Combine with cities or ZIP codes to narrow further. Ignored when Property URLs are provided.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "cities": {
                        "title": "Cities",
                        "type": "array",
                        "description": "Filter by city name (e.g. ['Austin','Dallas']). Best paired with the matching state to avoid same-named cities in other states. Leave empty to skip city filtering. Ignored when Property URLs are provided.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "zipCodes": {
                        "title": "ZIP codes",
                        "type": "array",
                        "description": "Filter by 5-digit US ZIP code (e.g. ['78701','78702']). This is the tightest geographic filter and works with or without a state. Leave empty to skip ZIP filtering. Ignored when Property URLs are provided.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "minPrice": {
                        "title": "Minimum asking price (USD)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only return listings with an asking price at or above this amount in US dollars (e.g. 500000). Leave empty for no lower bound. Listings without a published price are still included unless you disable 'Include unpriced'. Ignored when Property URLs are provided."
                    },
                    "maxPrice": {
                        "title": "Maximum asking price (USD)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only return listings with an asking price at or below this amount in US dollars (e.g. 5000000). Leave empty for no upper bound. Combine with the minimum to define a price band. Ignored when Property URLs are provided."
                    },
                    "minCapRate": {
                        "title": "Minimum cap rate (%)",
                        "minimum": 0,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Only return listings with a published capitalization rate at or above this percentage (e.g. 6 means 6%). Listings without a cap rate are excluded when this is set. Leave empty to ignore cap rate. Ignored when Property URLs are provided."
                    },
                    "maxCapRate": {
                        "title": "Maximum cap rate (%)",
                        "minimum": 0,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Only return listings with a published cap rate at or below this percentage (e.g. 12 means 12%). Combine with the minimum to define a yield band. Leave empty for no upper bound. Ignored when Property URLs are provided."
                    },
                    "includeUnpriced": {
                        "title": "Include unpriced listings",
                        "type": "boolean",
                        "description": "When true (default), listings marketed without a public asking price are included in search results. Set false to return only listings that show a dollar price. Has no effect on Property URL scraping. Ignored when Property URLs are provided.",
                        "default": true
                    },
                    "enrichDetails": {
                        "title": "Deep-enrich each listing",
                        "type": "boolean",
                        "description": "When true (default), each search result is enriched with a full detail request (cap rate, pro-forma cap rate, NOI, price/SqFt, price/unit, occupancy, class, beds, buildings, stories, year built, zoning, lot size, APN, marketing description, investment highlights) plus a broker request (name, brokerage, license, title). Set false for a faster, cheaper run that returns only the listing-card fields. Property URLs are always fully enriched.",
                        "default": true
                    },
                    "includeGalleryImages": {
                        "title": "Include gallery images",
                        "type": "boolean",
                        "description": "When true, add a full-resolution image URL array (all listing photos) to each enriched record via one extra request per listing. Defaults to false to keep runs fast and cheap; the primary thumbnail is always included regardless. Has no effect when Deep-enrich is off. Does not change the per-result price.",
                        "default": false
                    },
                    "maxResults": {
                        "title": "Maximum results",
                        "minimum": 1,
                        "maximum": 50000,
                        "type": "integer",
                        "description": "Hard cap on how many listings to return and bill for in one run (e.g. 100). Search stops once this many records are pushed, protecting your budget. Applies to search mode; Property URL runs process every URL you supply. Defaults to 100.",
                        "default": 100
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Proxy used to reach Crexi's API. Defaults to Apify Proxy datacenter routing pinned to the US, which is reliable for Crexi's public API host. Leave as default unless you hit persistent rate limits, in which case enable residential. Do not disable proxy — Crexi's API expects US egress.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyCountry": "US"
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
