# Crexi Property Details Scraper (`b2b_lead_generation/crexi-property-details-scraper`) Actor

Get full Crexi commercial property details from a list of property IDs. Fetches listings in parallel and returns flat records with asking price, cap rate, NOI, lease type and term, tenants, address with coordinates, and marketing text, ready for Excel, SQL, or any BI tool.

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

## Pricing

from $3.99 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js/docs.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## Crexi Property Details: Full Commercial Listing Data by Property ID

This actor takes one or more Crexi property IDs and returns the complete listing detail for each as a single flat record. You get the asking price, cap rate, NOI, lease terms, tenants, full address with coordinates, investment highlights, and marketing description, all as ready-to-use columns instead of nested JSON. IDs are fetched in parallel, so a batch of 50 properties takes seconds, not minutes.

### How it works

Paste property IDs into the input, one per line. The actor fetches each listing's detail page data concurrently, flattens the nested response into flat fields, and pushes one record per property to the dataset. A failed ID (removed listing, timeout) is logged and skipped without affecting the rest of the batch.

Both ID formats work and can be mixed:

- `2340253` (the numeric ID from a Crexi listing URL)
- `crexi_2340253` (the `property_id` returned by the Crexi Property Listings actor)

Duplicates resolve to one fetch, so you can paste ID lists without cleaning them first.

### Input parameters

| Field | Type | Default | Description |
|-------|------|---------|-------------|
| `propertyIds` | list of strings | | Property IDs, one per line. Up to 1,000 per run. Required. |
| `maxConcurrency` | integer | `5` | How many properties to fetch in parallel (max 20). |
| `requestTimeoutSecs` | integer | `30` | Timeout per request, in seconds. |
| `proxyConfiguration` | object | No proxy | Optional. Switch to Residential if requests start getting blocked. |

### What data does this actor extract?

Each record has 80+ flat fields. They come in three groups:

**Identity and location**

| Field | Example |
|-------|---------|
| `property_id` / `crexi_id` | `crexi_2340253` / `2340253` |
| `name` | `Dutch Bros Ground Lease` |
| `status` | `Active` |
| `address`, `city`, `county`, `state_code`, `zip` | `2930 Sperry Ave`, `Patterson`, `Stanislaus County`, `CA`, `95363` |
| `latitude` / `longitude` | `37.4645` / `-121.1751` |
| `crexi_url` | direct link to the listing |
| `thumbnailUrl` | primary photo URL |

**Deal terms in two flavors.** Display strings under `detail_*` and typed numeric values under `summary_*`, so spreadsheets get readable text and pipelines get sortable numbers:

| Display field | Example | Typed field | Example |
|---------------|---------|-------------|---------|
| `detail_asking_price` | `$1,534,000` | `askingPrice` | `1534000.0` |
| `detail_cap_rate` | `4.50%` | `summary_cap_rate` | `4.5` |
| `detail_noi` | `$69,000` | `summary_net_operating_income` | `69000.0` |
| `detail_price_per_sqft` | `$1,614.74` | `summary_price_per_sq_ft` | `1614.74` |
| `detail_lease_term` | `15.1 years` | `summary_lease_term` | `15.1` |
| `detail_lot_size_acres` | `0.5` | `summary_lot_size` | `0.5` |

Plus lease type, tenancy, tenants, rent bumps, ground lease flag, lease commencement and expiration dates, investment type, year built, and square footage in both forms.

**Marketing text and flags.** `investment_highlights` and `marketing_description` arrive as clean plain text (HTML stripped). Boolean flags include `isInOpportunityZone`, `hasOM`, `hasFlyer`, `hasVirtualTour`, `isSold`, and `isPaused`.

### Sample output

```json
{
    "property_id": "crexi_2340253",
    "name": "Dutch Bros Ground Lease",
    "status": "Active",
    "address": "2930 Sperry Ave",
    "city": "Patterson",
    "state_code": "CA",
    "zip": "95363",
    "askingPrice": 1534000.0,
    "summary_cap_rate": 4.5,
    "summary_net_operating_income": 69000.0,
    "detail_lease_type": "Absolute NNN",
    "detail_lease_term": "15.1 years",
    "tenants": "Starbucks, Dutch Bros. Coffee",
    "detail_rent_bumps": "10% Every 5 Years",
    "investment_highlights": "Prime Retail Location: High-visibility and easily accessible location...",
    "crexi_url": "https://www.crexi.com/properties/2340253/california-dutch-bros-ground-lease-grocery-outlet-outparcel"
}
````

### Use cases

- Deal underwriting: pull cap rate, NOI, lease term, and rent bumps for a shortlist of properties into one spreadsheet
- Pipeline enrichment: run the Crexi Property Listings actor for a region, then feed its `property_id` values here for full lease-level detail
- Tenant research: extract tenant names and lease structures across many net-lease listings at once
- Comp building: collect price per square foot, year built, and lot size for properties in a submarket
- Monitoring: re-run the same ID list on a schedule and diff `status`, `askingPrice`, and `updatedOn`

### FAQ

**How many properties can I look up in one run?**
Up to 1,000 IDs per run. Duplicates count once.

**What happens if an ID does not exist anymore?**
That ID is logged as failed and skipped. The run continues, and the final status message lists which IDs failed.

**What is the difference between detail\_ and summary\_ fields?**
They carry the same facts in two forms. `detail_cap_rate` is the display string (`4.50%`), `summary_cap_rate` is the number (`4.5`). Use `detail_*` for reports and `summary_*` for filtering, sorting, or math.

**Why are some fields missing on certain properties?**
Listings only include the facts the broker published. A property without a lease section has no lease fields; the columns simply stay empty for that record.

**Do I need a proxy?**
Usually not. If large batches start failing, switch the proxy setting to Residential and lower the concurrency.

**Where do the IDs come from?**
From a Crexi listing URL (the number after `/properties/`), or from the `property_id` field of the Crexi Property Listings actor, which searches listings by state, city, ZIP, county, price, and size.

Turn a list of Crexi property IDs into structured commercial real estate data with one run.

# Actor input Schema

## `propertyIds` (type: `array`):

Crexi property ids, one per line. Accepts the plain numeric id (2340253) or the prefixed form returned by the listings actor (crexi\_2340253). Duplicates are fetched only once. Up to 1,000 ids per run.

## `maxConcurrency` (type: `integer`):

How many properties to fetch in parallel. Higher is faster but more likely to get rate-limited.

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

Timeout for each detail request, in seconds.

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

Optional proxy for outgoing requests. Switch to Residential if requests start getting blocked.

## Actor input object example

```json
{
  "propertyIds": [
    "2340253",
    "crexi_1000002"
  ],
  "maxConcurrency": 5,
  "requestTimeoutSecs": 30,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `results` (type: `string`):

No description

# API

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

## JavaScript example

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

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

// Prepare Actor input
const input = {
    "propertyIds": [
        "2340253"
    ],
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("b2b_lead_generation/crexi-property-details-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 = {
    "propertyIds": ["2340253"],
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("b2b_lead_generation/crexi-property-details-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 '{
  "propertyIds": [
    "2340253"
  ],
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call b2b_lead_generation/crexi-property-details-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Crexi Property Details Scraper",
        "description": "Get full Crexi commercial property details from a list of property IDs. Fetches listings in parallel and returns flat records with asking price, cap rate, NOI, lease type and term, tenants, address with coordinates, and marketing text, ready for Excel, SQL, or any BI tool.",
        "version": "0.0",
        "x-build-id": "MWRaTMo7UVGSGFs89"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/b2b_lead_generation~crexi-property-details-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-b2b_lead_generation-crexi-property-details-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/b2b_lead_generation~crexi-property-details-scraper/runs": {
            "post": {
                "operationId": "runs-sync-b2b_lead_generation-crexi-property-details-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/b2b_lead_generation~crexi-property-details-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-b2b_lead_generation-crexi-property-details-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "propertyIds"
                ],
                "properties": {
                    "propertyIds": {
                        "title": "Property IDs",
                        "type": "array",
                        "description": "Crexi property ids, one per line. Accepts the plain numeric id (2340253) or the prefixed form returned by the listings actor (crexi_2340253). Duplicates are fetched only once. Up to 1,000 ids per run.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxConcurrency": {
                        "title": "Max concurrent requests",
                        "minimum": 1,
                        "maximum": 20,
                        "type": "integer",
                        "description": "How many properties to fetch in parallel. Higher is faster but more likely to get rate-limited.",
                        "default": 5
                    },
                    "requestTimeoutSecs": {
                        "title": "Request timeout (seconds)",
                        "minimum": 5,
                        "maximum": 120,
                        "type": "integer",
                        "description": "Timeout for each detail request, in seconds.",
                        "default": 30
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Optional proxy for outgoing requests. Switch to Residential if requests start getting blocked."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
