# Crexi Property Details Scraping (`b2b_lead_generation/crexi-property-details-scraping`) Actor

Have a list of Crexi property IDs? Get the full story on each one: asking price, cap rate, NOI, lease type and term, tenants, address with coordinates, and marketing details. Pulled in parallel and delivered as clean records for your spreadsheet, database, or dashboard.

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

## Pricing

from $2.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 Scraper cover](https://i.imgur.com/ENcxsDS.png)

## Crexi Property Details Scraper

Turn a list of Crexi property ids into one flat, spreadsheet-ready row per listing. You get asking price, cap rate, NOI, lease terms, tenants, full address with coordinates, investment bullets, and the listing narrative, all as ready-to-use columns instead of nested JSON. Ids are fetched in parallel, so a batch of 50 properties finishes in seconds.

Both id formats work and can be mixed in a single run:

- `2340253`: the numeric id from a Crexi listing URL
- `crexi_2340253`: the `property_id` returned by the Crexi Property Listings actor
- `crexi_2340253_1`: a multi-location row id (folded back to the base asset automatically)

Duplicates collapse to a single fetch, so you can paste unfiltered id lists straight in.

### Input parameters

| Field | Type | Default | Description |
|-------|------|---------|-------------|
| `propertyIds` | list of strings | *required* | Property ids, one per line. Up to 1,000 per run. |
| `maxConcurrency` | integer | `5` | Parallel requests (max 20). Lower this if you hit rate limits. |
| `requestTimeoutSecs` | integer | `30` | Timeout per request, in seconds. |

### Sample inputs

**One property (smoke test)**

```json
{
    "propertyIds": ["2340253"]
}
````

**Batch of numeric ids from Crexi URLs**

```json
{
    "propertyIds": [
        "2340253",
        "1984210",
        "2011884",
        "2202441"
    ]
}
```

**Mixed id formats in one run (plain, prefixed, multi-location)**

```json
{
    "propertyIds": [
        "2340253",
        "crexi_1000002",
        "crexi_1234567_1"
    ]
}
```

**Chained from the Crexi Property Listings actor**

Feed its `property_id` column straight in:

```json
{
    "propertyIds": [
        "crexi_2340253",
        "crexi_2340254",
        "crexi_2340255",
        "crexi_2340256",
        "crexi_2340257"
    ],
    "maxConcurrency": 10
}
```

**Large batch with tuned parallelism and longer timeout**

```json
{
    "propertyIds": [
        "crexi_2340253", "crexi_1984210", "crexi_2011884", "crexi_2202441",
        "crexi_2100034", "crexi_2100035", "crexi_2100036", "crexi_2100037"
    ],
    "maxConcurrency": 15,
    "requestTimeoutSecs": 60
}
```

### What this actor returns

Each record is a single flat row with 80+ columns, grouped into four families.

**Identity and location**

| Field | Example |
|-------|---------|
| `property_id` / `crexi_asset_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` |
| `geo_latitude` / `geo_longitude` | `37.4645` / `-121.1751` |
| `listing_url` | direct link to the Crexi listing |
| `hero_image_url` | primary photo URL |

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

| Display field | Example | Numeric field | Example |
|---------------|---------|---------------|---------|
| `display_asking_price` | `$1,534,000` | `metric_asking_price` | `1534000.0` |
| `display_cap_rate` | `4.50%` | `metric_cap_rate` | `4.5` |
| `display_noi` | `$69,000` | `metric_net_operating_income` | `69000.0` |
| `display_price_per_sqft` | `$1,614.74` | `metric_price_per_sq_ft` | `1614.74` |
| `display_lease_term` | `15.1 years` | `metric_lease_term` | `15.1` |
| `display_lot_size_acres` | `0.5` | `metric_lot_size` | `0.5` |

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

**Marketing text and listing flags.** `investment_bullets` and `listing_narrative` arrive as clean plain text (HTML stripped). Boolean signals include `flag_opportunity_zone`, `flag_has_om`, `flag_has_flyer`, `flag_has_virtual_tour`, `flag_is_sold`, and `flag_is_paused`.

**Broker of record.** The lead brokerage is flattened into `broker_name`, `broker_type`, `broker_office`, and `broker_email`.

### Sample output

![Sample dataset output](https://i.imgur.com/d2DiLVA.png)

```json
{
    "property_id": "crexi_2340253",
    "crexi_asset_id": "2340253",
    "name": "Dutch Bros Ground Lease",
    "status": "Active",
    "address": "2930 Sperry Ave",
    "city": "Patterson",
    "state_code": "CA",
    "zip": "95363",
    "geo_latitude": 37.4645,
    "geo_longitude": -121.1751,
    "metric_asking_price": 1534000.0,
    "metric_cap_rate": 4.5,
    "metric_net_operating_income": 69000.0,
    "display_lease_type": "Absolute NNN",
    "display_lease_term": "15.1 years",
    "tenant_names": "Starbucks, Dutch Bros. Coffee",
    "display_rent_bumps": "10% Every 5 Years",
    "investment_bullets": "Prime Retail Location: High-visibility and easily accessible location...",
    "broker_name": "Jane Doe",
    "broker_office": "Marcus & Millichap",
    "hero_image_url": "https://images.crexi.com/assets/...",
    "listing_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 into one spreadsheet
- **Pipeline enrichment**: run the Crexi Property Listings actor for a region, feed its `property_id` column 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 a submarket
- **Change monitoring**: re-run the same id list on a schedule and diff `status`, `metric_asking_price`, and `last_updated_on`
- **Broker outreach**: export `broker_name`, `broker_office`, and `broker_email` for a targeted list

### Notes

- Failed ids (removed listings, timeouts, blocked responses) are logged and skipped without aborting the run. The final status message lists which ids failed.
- Listings only carry the fields the broker published. A property without a lease section has no lease columns; those cells simply stay empty for that row.
- Use `display_*` columns for reports and screenshots, `metric_*` columns for filtering, sorting, and math.

### Related lead generation actors

| Actor | What it does |
|-------|--------------|
| [Skip Tracing Property Records](https://apify.com/b2b_lead_generation/skip-tracing-property-records) | Skip trace property records to attach owner contact data |
| [Realtor Properties Contact Email](https://apify.com/b2b_lead_generation/realtor-properties-contact-email) | Pull realtor contact emails tied to Realtor.com listings |
| [Google Maps Email Extractor](https://apify.com/b2b_lead_generation/google-maps-email-extractor) | Harvest business emails from Google Maps search results |
| [Chrome Extension Email Extractor](https://apify.com/b2b_lead_generation/chrome-extension-email-extractor) | Extract developer emails from Chrome Web Store extensions |
| [Chrome Extension Scraper Email](https://apify.com/b2b_lead_generation/chrome-extension-scraper-email) | Alternative Chrome Web Store extension email scraper |
| [Shopify Website Scraper Email](https://apify.com/b2b_lead_generation/shopify-website-scraper-email) | Scrape store owner emails from Shopify sites |
| [WooCommerce Website Scraper Email](https://apify.com/b2b_lead_generation/woocommerce-website-scraper-email) | Scrape store owner emails from WooCommerce sites |
| [USA Business Leads Extractor](https://apify.com/b2b_lead_generation/usa-business-leads-extractor) | Broad US business leads with contact data |
| [USA Professional Leads Hub](https://apify.com/b2b_lead_generation/usa-professional-leads-hub) | Aggregated US professional service leads across industries |
| [USA Home Repair Leads](https://apify.com/b2b_lead_generation/usa-home-repair-leads) | US home repair and contractor leads |
| [USA Automotive Leads Hub](https://apify.com/b2b_lead_generation/usa-automotive-leads-hub) | US automotive industry leads |
| [USA Medical Services Extractor](https://apify.com/b2b_lead_generation/usa-medical-services-extractor) | US medical services and clinic leads |
| [USA Fitness Leads Hub](https://apify.com/b2b_lead_generation/usa-fitness-leads-hub) | US fitness studio and gym leads |
| [USA Beauty Spa Extractor](https://apify.com/b2b_lead_generation/usa-beauty-spa-extractor) | US beauty salon and spa leads |
| [USA Pet Services Extractor](https://apify.com/b2b_lead_generation/usa-pet-services-extractor) | US pet care and pet services leads |
| [UK Electrician Leads Extractor](https://apify.com/b2b_lead_generation/uk-electrician-leads-extractor) | UK electrician contractor leads |
| [AU Business Leads Search API](https://apify.com/b2b_lead_generation/au-business-leads-search-api) | Australia business leads via a search API |

![Try the Crexi Property Details Scraper](https://i.imgur.com/zVmeB5o.png)

# 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.

## Actor input object example

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

# 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"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("b2b_lead_generation/crexi-property-details-scraping").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"] }

# Run the Actor and wait for it to finish
run = client.actor("b2b_lead_generation/crexi-property-details-scraping").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"
  ]
}' |
apify call b2b_lead_generation/crexi-property-details-scraping --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-scraping",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Crexi Property Details Scraping",
        "description": "Have a list of Crexi property IDs? Get the full story on each one: asking price, cap rate, NOI, lease type and term, tenants, address with coordinates, and marketing details. Pulled in parallel and delivered as clean records for your spreadsheet, database, or dashboard.",
        "version": "0.0",
        "x-build-id": "zw8jtDnyh3yKOH33u"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/b2b_lead_generation~crexi-property-details-scraping/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-b2b_lead_generation-crexi-property-details-scraping",
                "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-scraping/runs": {
            "post": {
                "operationId": "runs-sync-b2b_lead_generation-crexi-property-details-scraping",
                "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-scraping/run-sync": {
            "post": {
                "operationId": "run-sync-b2b_lead_generation-crexi-property-details-scraping",
                "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": "Parallel 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
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
