# Crexi Scraper - CRE Listings & Broker Leads (`logiover/crexi-scraper`) Actor

Crexi unofficial API: export US commercial real estate listings and broker leads to CSV/JSON. Scrape Crexi without login or API key.

- **URL**: https://apify.com/logiover/crexi-scraper.md
- **Developed by:** [Logiover](https://apify.com/logiover) (community)
- **Categories:** Real estate, Lead generation, AI
- **Features:** Limited permissions
- **Stats:** 26 total users, 7 monthly users, 99.1% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.75 / 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/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

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

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Crexi Scraper — US Commercial Real Estate Data & Broker Leads (No API)

![Apify Actor](https://img.shields.io/badge/Apify-Actor-00A67E?logo=apify\&logoColor=white) ![No API key](https://img.shields.io/badge/No%20API%20key-required-2ea44f) ![Pay per result](https://img.shields.io/badge/Pricing-Pay%20per%20result-1C7ED6) ![Commercial Real Estate](https://img.shields.io/badge/Category-CRE%20%26%20Leads-0EA5E9) ![Export](https://img.shields.io/badge/Export-JSON%20%7C%20CSV%20%7C%20Excel-F59E0B)

***

Extract US commercial real estate listings from **Crexi** without a login or API key. This Crexi scraper pulls CRE listing data — **asking price, cap rate, square footage, year built, full address + GPS** and the **listing brokers** behind each deal — straight from **crexi.com's public JSON API**, and exports it to CSV, JSON or Excel. Filter by property type, US state, keyword or price, or paste a Crexi search URL, and the Actor returns hundreds to hundreds of thousands of commercial listings with optional **broker contact enrichment** for B2B lead generation. **Fast, no browser, no API key, no login.**

> ### 🏆 Why this Crexi scraper?
>
> **40 fields per listing** · **hundreds of thousands of listings per search** · reads Crexi's public JSON API (no browser) · datacenter-proxy default · optional broker lead enrichment · export to JSON / CSV / Excel. The unofficial **Crexi API alternative** for CRE market research, deal sourcing and broker lead generation.

***

### ✨ What this Actor does / Key features

- 🏢 **All CRE property types** — Office, Retail, Industrial, Multifamily, Land, Hospitality, Self Storage, Mixed Use, Mobile Home, Special Purpose, Health Care.
- 🇺🇸 **State & keyword targeting** — filter by any US state (2-letter code or full name), free-text keyword, or paste a ready-made Crexi search URL.
- 💰 **Deal metrics** — asking price, cap rate, square footage, units, lot size (acres), year built, building class and occupancy on every enriched record.
- 🧑‍💼 **Broker lead enrichment** — with `fetchBrokers` on, pull each listing's broker name(s), license number(s), public Crexi profile URL and brokerage website — the B2B lead data.
- 🗺️ **Full address & GPS** — street, city, county, state, ZIP and full address plus exact latitude / longitude for mapping.
- 🔎 **Search-URL parsing** — paste any crexi.com search/results URL and the Actor reads its property-type, state and keyword filters automatically.
- ⚙️ **Speed vs. depth toggles** — turn `fetchDetails` and `fetchBrokers` off for a fast, lightweight scrape, or on for the full picture.
- ⚡ **Public JSON API, no browser** — reads the same public endpoints crexi.com uses; datacenter proxy is fast and reliable against Crexi's API host.
- 🔑 **No API key, no login** — no account, cookies or developer key required.

### 🚀 Quick start (3 steps)

1. **Configure** — paste one or more **Crexi search URLs** copied from crexi.com, or set the **Property types**, **US states**, **Keyword** and **price** fields. Toggle **Fetch listing details** and **Fetch broker contact leads** as needed.
2. **Run** — click **Start**. The Actor paginates the search results and streams listings into your dataset, enriching each with detail and broker calls.
3. **Get your data** — open the **Output** tab and export to **JSON, CSV, Excel or XML**, or pull it via the Apify API.

### 📥 Input

Give the Actor either one or more `searchUrls`, or use the explicit filter fields. Everything else is optional.

#### Example — retail listings in Texas from a search URL

```json
{
  "searchUrls": ["https://www.crexi.com/properties/texas/retail-commercial-real-estate"],
  "fetchDetails": true,
  "fetchBrokers": true,
  "maxResults": 200
}
```

#### Example — office deals in CA & NY by filters (with broker leads)

```json
{
  "propertyTypes": ["Office"],
  "states": ["CA", "NY"],
  "minPrice": 1000000,
  "maxPrice": 20000000,
  "fetchDetails": true,
  "fetchBrokers": true,
  "maxResults": 500
}
```

#### Example — fast, lightweight multifamily pull (no enrichment)

```json
{
  "propertyTypes": ["Multifamily"],
  "keyword": "Austin",
  "fetchDetails": false,
  "fetchBrokers": false,
  "maxResults": 1000
}
```

| Field | Type | Description |
|-------|------|-------------|
| `searchUrls` | array | Crexi search/result URLs copied from crexi.com. Property-type, state and keyword filters in the URL are parsed automatically. Leave empty to use the explicit filter fields. |
| `propertyTypes` | array | Filter by Crexi property type: Multifamily, Office, Retail, Industrial, Land, Hospitality, Mixed Use, Self Storage, Mobile Home, Special Purpose, Health Care. Empty = all types. |
| `states` | array | US state filter — 2-letter codes (`CA`, `TX`, `NY`) or full names. Empty = all states. |
| `keyword` | string | Free-text search (city, address, asset name). Optional. |
| `minPrice` / `maxPrice` | integer | Asking-price range in USD. Optional. |
| `includeUnpriced` | boolean | Include listings without a published price (auctions, call-for-offers, lease). Default `true`. |
| `fetchDetails` | boolean | One extra API call per listing to add cap rate, year built, lot size, units, occupancy, building class and description. Default `true`. |
| `fetchBrokers` | boolean | One extra API call per listing to add broker name, license, profile URL and brokerage website. Default `true`. |
| `maxResults` | integer | Stop after this many listings across all queries. `0` = no limit (a single search can span hundreds of thousands of listings). |
| `useProxy` | boolean | Route requests through Apify Proxy. Datacenter (default) is fast and reliable against Crexi's JSON API. |
| `proxyConfiguration` | object | Apify Proxy settings. Datacenter is the default and works reliably against Crexi's API host; you can switch to Residential if ever needed. |
| `maxConcurrency` | integer | How many detail/broker enrichment calls to run in parallel per page (1–20). |

> **Tip — get a search URL:** open crexi.com, apply your property-type / state / price filters in the UI, then copy the resulting `crexi.com/properties/...` URL from the address bar and paste it into `searchUrls`. The Actor reads the filters straight from the URL.

### 📤 Output

One row per listing — **40 fields**, exportable to JSON, CSV, Excel or XML. Here is a trimmed sample record:

```json
{
  "id": "a1b2c3d4",
  "name": "Prime Retail Strip Center",
  "url": "https://www.crexi.com/properties/123456/texas-prime-retail-strip-center",
  "propertyType": "Retail",
  "subtypes": "Strip Center",
  "status": "For Sale",
  "askingPrice": "4250000",
  "capRate": "6.75",
  "squareFootage": "18500",
  "units": "8",
  "lotSizeAcres": "1.85",
  "yearBuilt": "2004",
  "buildingClass": "B",
  "occupancy": "95",
  "address": "1200 Main Street",
  "city": "Austin",
  "county": "Travis",
  "state": "TX",
  "zip": "78701",
  "fullAddress": "1200 Main Street, Austin, TX 78701",
  "latitude": "30.2672",
  "longitude": "-97.7431",
  "brokerageName": "Lone Star Commercial",
  "brokerNames": "Jane Smith, Mark Lee",
  "brokerLicenses": "0654321, 0654322",
  "brokerProfileUrls": "https://www.crexi.com/profile/jane-smith, https://www.crexi.com/profile/mark-lee",
  "brokerageWebsite": "https://lonestarcre.com",
  "isInOpportunityZone": "false",
  "numberOfImages": "24",
  "thumbnailUrl": "https://images.crexi.com/assets/…/thumb.jpg",
  "activatedOn": "2026-06-18T00:00:00Z",
  "updatedOn": "2026-07-01T00:00:00Z",
  "scrapedAt": "2026-07-06T12:00:00Z"
}
```

<details>
<summary><b>📋 Full field reference (click to expand)</b></summary>

| Field | Description |
|-------|-------------|
| `id` | Crexi asset ID |
| `name` | Listing / asset name |
| `url` | Direct link to the Crexi listing |
| `propertyType` | Property type(s) (Office, Retail, Industrial, Multifamily, …) |
| `subtypes` | Property subtypes |
| `investmentType` | Investment type |
| `status` | Listing status (For Sale, Auction, Lease, Call for Offers) |
| `askingPrice` | Asking price in USD |
| `capRate` | Capitalization rate (when published) |
| `squareFootage` | Building size in sq ft |
| `units` | Number of units |
| `lotSizeAcres` | Lot size in acres |
| `yearBuilt` | Year built |
| `buildingClass` | Building class (A / B / C) |
| `occupancy` | Occupancy percentage |
| `address` | Street address |
| `city` | City |
| `county` | County |
| `state` | State code |
| `stateName` | Full state name |
| `zip` | ZIP code |
| `fullAddress` | Composed full address |
| `latitude` | GPS latitude |
| `longitude` | GPS longitude |
| `brokerageName` | Listing brokerage name |
| `brokerNames` | Listing broker name(s) — B2B lead data |
| `brokerLicenses` | Broker license number(s) |
| `brokerProfileUrls` | Public Crexi broker profile URL(s) |
| `brokerageWebsite` | Brokerage website |
| `isInOpportunityZone` | Whether the asset is in an Opportunity Zone |
| `hasVideo` | Whether the listing has video |
| `hasVirtualTour` | Whether the listing has a virtual tour |
| `numberOfImages` | Number of images |
| `thumbnailUrl` | Thumbnail image URL |
| `brokerTeamLogoUrl` | Broker team logo URL |
| `description` | Marketing description |
| `highlights` | Investment highlights |
| `activatedOn` | Listing activation date |
| `updatedOn` | Last updated date |
| `scrapedAt` | Scrape timestamp (ISO 8601) |

</details>

### 💡 Use cases

- **CRE market research** — analyze asking prices, cap rates and price-per-sqft by property type and state.
- **Broker lead generation** — build B2B outreach lists of CRE brokers with names, licenses, profile URLs and brokerage websites.
- **Investor deal sourcing** — filter Office, Retail, Industrial or Multifamily by price and surface deals that fit your mandate.
- **Comp databases** — assemble commercial comps with size, year built, cap rate and location for underwriting.
- **Mapping & dashboards** — feed geo-coded listings (`latitude`/`longitude`) into a GIS map or investment dashboard.
- **Opportunity Zone screening** — filter on `isInOpportunityZone` to surface tax-advantaged assets.

### 👥 Who uses it

CRE brokers & brokerages · real-estate investors & acquisitions teams · lenders & underwriters · proptech & data teams · B2B lead-gen agencies · market researchers & analysts.

### 💰 Pricing

This Actor runs on a simple **pay-per-result** model — you pay for the listings you extract, with no separate Apify platform fees to calculate. Try it on the **free tier** first, then scale up. See the **Pricing** tab on this page for the current rate.

### ❓ Frequently Asked Questions

#### Do I need a Crexi login or API key?

No. The Actor reads Crexi's public JSON API — no account, no cookies and no API key are required. You only need an Apify account.

#### Is this a Crexi API alternative?

Yes. Crexi has no public developer API, so this Actor works as an unofficial Crexi API alternative — it reads the same public JSON endpoints crexi.com uses and returns clean, structured listing and broker records you can call on a schedule.

#### Can I scrape Crexi without an API key or login?

Yes. This Crexi data extraction tool needs no account, cookies or API key — it reads Crexi's public listing API directly, so you can scrape commercial real estate listings and broker contacts straight away.

#### Can I get broker contact details for lead generation?

Yes. Enable **Fetch broker contact leads** (`fetchBrokers`) to pull each listing's broker name, license number, public Crexi profile and brokerage website — ready for B2B outreach.

#### Does it include cap rate and other deal metrics?

Yes, when published on the listing. Enable **Fetch listing details** (`fetchDetails`) to add `capRate`, `yearBuilt`, `lotSizeAcres`, `units`, `occupancy`, `buildingClass` and the marketing description to each record.

#### How do I export Crexi data to CSV or JSON?

Run a search, then download the dataset as CSV, JSON or Excel from the run page, or pull it programmatically via the Apify API. Every commercial real estate listing and broker lead comes out as a flat, ready-to-import row.

#### Can I scrape Crexi commercial listings from a search URL I copied?

Yes. Paste any crexi.com search URL into `searchUrls` and the scraper reads the property-type, state and keyword filters from the URL automatically.

#### How do I get commercial real estate comps by state?

Set `states` plus a `propertyTypes` value and enable `fetchDetails` to pull square footage, year built and cap rate — everything you need to assemble CRE comps for underwriting.

#### Does the Crexi scraper include GPS coordinates for mapping?

Yes. Every listing carries `latitude` and `longitude` alongside the full address, so you can feed geo-coded commercial listings straight into a GIS map or dashboard.

#### How much data can I get?

A single search can span hundreds of thousands of listings. Set `maxResults` to cap the run (0 = no limit), and narrow with property type, state and price filters to reach the most relevant inventory faster.

#### Is scraping Crexi legal?

This Actor collects only publicly available listing and broker data. You are responsible for using it in line with Crexi's terms and applicable laws (such as GDPR/CCPA for personal data). Use it responsibly.

### 🔗 More scrapers by logiover

Pair the Crexi scraper with the rest of the marketplace, classifieds and property-data suite:

| Actor | What it scrapes |
|---|---|
| [Airbnb Scraper](https://apify.com/logiover/airbnb-scraper) | Short-stay listings, prices, availability & reviews |
| [Craigslist Scraper](https://apify.com/logiover/craigslist-scraper) | US classifieds — real estate, for-sale & services |
| [Leboncoin Scraper](https://apify.com/logiover/leboncoin-scraper) | France's #1 classifieds marketplace |
| [Finn.no Scraper](https://apify.com/logiover/finn-no-scraper) | Norway's leading marketplace incl. property |
| [Blocket.se Scraper](https://apify.com/logiover/blocket-se-scraper) | Sweden's largest classifieds site |
| [Marktplaats Scraper](https://apify.com/logiover/marktplaats-nl-scraper) | Netherlands classifieds marketplace |
| [Avito Scraper](https://apify.com/logiover/avito-ru-scraper) | Russia's biggest classifieds platform |
| [DBA.dk Scraper](https://apify.com/logiover/dba-dk-scraper) | Denmark's marketplace listings |
| [Booking Hotels Prices Scraper](https://apify.com/logiover/booking-hotels-prices-scraper) | Hotel prices & availability |
| [SimilarWeb Scraper](https://apify.com/logiover/similarweb-scraper) | Website traffic & competitive intelligence |
| [Clutch.co Scraper](https://apify.com/logiover/clutch-co-scraper) | B2B agency & service-provider directory |

👉 Browse all **[logiover scrapers on Apify Store](https://apify.com/logiover)** — 180+ actors across real estate, jobs, crypto, social media & B2B data.

### ⏰ Scheduling & integration

Schedule this Actor on Apify to refresh your CRE dataset daily or weekly. Export results to JSON, CSV or Excel, sync to Google Sheets, or push straight to your database, CRM, BI tools and webhooks through the Apify API. Connect it to **Make, n8n or Zapier** to build automated deal-sourcing and broker-outreach pipelines.

### 🤖 AI Agents, MCP & RAG Integration

**Crexi Scraper** works natively as an on-demand data tool for AI assistants and autonomous workflows.

Connect this Actor directly to **Apify AI**, **Claude Desktop**, **Cursor**, **VS Code**, **Windsurf**, **LangChain**, or **LlamaIndex** via the official **Apify MCP Server** — no custom wrapper code needed:

```json
{
  "mcpServers": {
    "apify": {
      "type": "http",
      "url": "https://mcp.apify.com?tools=logiover/crexi-scraper"
    }
  }
}
```

- **Schema-typed inputs & outputs:** Clean JSON records with explicit `.actor/input_schema.json` and `.actor/output_schema.json` definitions so LLM agents infer parameters and parse fields accurately without HTML noise.
- **Bounded & predictable runs:** Built-in volume caps and pay-per-result budget guards prevent runaway agent tool loops.
- **RAG & automation ready:** Stream run datasets straight into vector stores, n8n, Make, Zapier, or webhook pipelines.

### 💬 Support, Issues & Reviews

- **Bug reports & target-site changes:** Hit an unexpected empty result or selector change? [Open a ticket in the Issues tab](https://apify.com/logiover/crexi-scraper/issues) with your **Run ID** or sample input — we actively monitor issues and ship fixes fast.
- **Feature & field requests:** Need an additional data attribute or filter? [Request it in the Issues tab](https://apify.com/logiover/crexi-scraper/issues).
- **Enjoying this Actor?** If it saved you engineering time, please consider leaving an honest [review on Apify Store](https://apify.com/logiover/crexi-scraper/reviews) or bookmarking [logiover/crexi-scraper](https://apify.com/logiover/crexi-scraper) — organic developer feedback helps others discover reliable tools and keeps maintenance prioritized.

### ⚖️ Legal

This Actor extracts only publicly available data and is intended for legitimate research, analytics and lead-generation use. You are responsible for complying with Crexi's terms of service, GDPR/CCPA and any applicable local laws when handling personal data such as broker contact details.

***

This Actor is an independent tool. It is not affiliated with, endorsed by, or sponsored by Crexi; Crexi and all other trademarks mentioned here are the property of their respective owners.

### 📝 Changelog

#### 2026-11-11

- Added reliable terminal run status telemetry and structured Apify AI / MCP Server (`mcp.apify.com`) tool configuration.
- Added direct Issues & Reviews support links and refreshed live maintenance verification.

#### 2026-11-01

- Monthly health check (2026-11-01): a live run on the current build completed successfully and returned data. Input options, output fields and pricing are unchanged.
- README refreshed: independence disclaimer added.

#### 2026-10-15

- Current crexi.com search URLs (`/search?…`) are now understood: property type and subtypes, asking price, lot size in acres and the listing-time window (e.g. "24 hours") are read from the URL. The same filters exist as inputs: `subtypes`, `minLotAcres`, `maxLotAcres`, `listedWithinHours`, `sortBy`.
- Fixed: the asking-price filter was silently ignored by Crexi's API (it wanted `askingPriceMin`/`askingPriceMax`); it now filters.
- The run follows its own timeout instead of a fixed 4.5-minute budget, and a run that could not reach Crexi fails with the reason instead of reporting an empty success.
- Every request now has a hard time limit, so a proxy connection that stalls can no longer hold up the run or push it past its timeout.
- A run that reaches its maximum cost per run now stops cleanly with its results saved and a status message, instead of ending as aborted.
- A proxy group your account cannot use no longer stops the run at start-up; it falls back to the default Apify Proxy.
- Memory is managed within the run's own limit, which removes a rare out-of-memory crash on large pages.
- The prefilled example asks for 150 listings with details (was 30), so a first run finishes in about a minute and a half.
- The default used when the field is left out for `maxResults` is now 4,370 (was 200).

#### 2026-09-23

- Fleet-wide quality audit. Verified end to end against live data and re-checked the input schema, the output columns and the run configuration.
- Output verified on a live run: 40 columns returned, 73.2% of cells populated.
- Run reliability reviewed: 100.0% of public runs succeeded in the last 30 days.
- Input schema, output schema and pricing configuration reviewed.
- Noted that 8 column(s) came back empty in this sample (`investmentType`, `capRate`, `units`, `lotSizeAcres`, `yearBuilt`, `buildingClass` and others); these are under review.

#### 2026-09-01

- Fleet-wide health check. Verified against this Actor's real run history: 30-day success rate, output row counts, per-field fill rates, and peak memory against the configured memory limit.
- Reviewed for the failure patterns that have cost this fleet runs — unguarded proxy setup, retry loops that can outlast the run's own time budget, and full-page HTML parsing that can exhaust a small container.
- No change to input, output fields or scraping logic.

#### 2026-08-11

- Maintenance release: refreshed the build and dependencies.
- Re-verified live execution, non-empty structured output and dataset field/type integrity.
- Reviewed reliability (retries, pagination) and output quality as part of a full-fleet QA pass.

#### 2026-08-01

- Completed the August 2026 full health check: verified empty/programmatic default, Console UI default, and two source-informed alternative inputs on Apify.
- Confirmed successful live execution, non-empty structured output, dataset-field/type integrity, and logical sample quality within the 5-minute quality window.
- Declared 40 dataset fields from typed live cloud samples so the output contract is no longer an empty placeholder.
- Declared 40 nullable dataset fields from typed live cloud samples so the output contract is no longer an empty placeholder or brittle to sparse modes.

#### 2026-07-06

- ✨ README overhaul: full badge/hero/callout structure, richer 40-field output sample, ready-to-run example scenarios, CRE & marketplace cross-promo links, expanded FAQ and clearer quick-start.

#### 2026-07-01

- Maintenance pass: re-verified end-to-end on live data and confirmed successful runs within the 5-minute quality window on the default input.
- Sharpened Store metadata (SEO title & description) and expanded the FAQ with high-intent, long-tail questions for easier discovery in Google and Apify Store search.
- Added ready-to-run example tasks that cover common real-world use cases.

#### 2026-06-15

- Reliability pass: re-verified end-to-end on live data with real-world inputs. Routine maintenance build.

#### 2026-06-07

- Docs: added coverage for Crexi unofficial API use, exporting Crexi data to CSV/JSON, and scraping Crexi without an API key or login.

  </content>

***

\*Maintained: last verified 2026-11-11 — checked end-to-end against live run history (reliability, output fields and types, and time/memory budgets).

### Filtering by subtype, lot size, price and listing date

Paste any current Crexi search URL and the filters it carries are honoured — property type and subtypes, asking price, lot size in acres and the listing-time window. For example, land listings activated in the last 24 hours, priced from $100,000, on at least 0.75 acres:

```
https://www.crexi.com/search?searchType=Sales&propertyAttributes.type_tree_Land=Agricultural,Residential,Commercial,Industrial,Farm,Ranch,Timber&propertyPrice.total_min=100000&ListingTimeline_dimension=24%20hours&lotAttributes.sizeAcre_min=0.75
```

The same filters are available as plain inputs (`subtypes`, `minPrice`, `maxPrice`, `minLotAcres`, `maxLotAcres`, `listedWithinHours`, `sortBy`) for runs built in the Console or over the API. Crexi's API has no listing-date filter of its own, so for a time window the Actor reads the newest listings first and stops at the first one older than the window — a daily run over a whole state finishes in seconds. Lease searches are not supported; the API behind this Actor serves sale listings.

# Changelog

This Actor's version history is a separate document: https://apify.com/logiover/crexi-scraper/changelog.md

# Actor input Schema

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

Optional. Crexi search/result URLs copied straight from crexi.com — both the classic https://www.crexi.com/properties/california/office-commercial-real-estate form and the current https://www.crexi.com/search?searchType=Sales\&propertyAttributes.type_tree_Land=Agricultural,Farm\&propertyPrice.total_min=100000\&ListingTimeline_dimension=24%20hours\&lotAttributes.sizeAcre_min=0.75 form. Property type and subtypes, state, keyword, asking price, lot size and the listing-time window are all read from the URL.

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

Filter by Crexi property type (pick one or more). Leave empty for all types.

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

Optional Crexi subtypes to keep, e.g. Agricultural, Residential, Farm, Ranch, Timber for Land or Office Building, Medical Office for Office. Spelled as Crexi shows them.

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

Filter by US state (pick one or more). Leave empty for all states.

## `keyword` (type: `string`):

Free-text search (city, address, asset name). Optional.

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

Optional minimum asking price filter.

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

Optional maximum asking price filter.

## `minLotAcres` (type: `integer`):

Optional. Keep only listings whose lot is at least this many acres (Crexi's own acreage filter).

## `maxLotAcres` (type: `integer`):

Optional. Keep only listings whose lot is at most this many acres.

## `listedWithinHours` (type: `integer`):

Only listings activated within the last N hours — 24 for the trailing day, 168 for a week. 0 = any time. The newest listings are read first and the search stops at the first older one, so this stays fast even on large markets.

## `sortBy` (type: `string`):

Order in which Crexi returns listings. A listing-time window always uses newest first.

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

Include listings without a published asking price (auctions, call-for-offers, lease).

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

Make one extra API call per listing to pull cap rate, year built, lot size, units, occupancy, building class and the marketing description. Slower but much richer. Turn off for a fast, lightweight scrape.

## `fetchBrokers` (type: `boolean`):

Make one extra API call per listing to pull the listing broker(s): name, license number, public Crexi profile and brokerage website — the B2B lead data. Turn off for a fast, lightweight scrape.

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

Stop after this many listings across all queries. 0 = no limit (a single search can span hundreds of thousands of listings).

## `useProxy` (type: `boolean`):

Route requests through Apify Proxy. Datacenter (the default) is fast and reliable against Crexi's JSON API.

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

Apify Proxy settings. Datacenter is the default and works reliably against Crexi's API host. You can switch to Residential if you ever need to, but it is slower and not required here.

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

How many detail/broker enrichment calls to run in parallel per page.

## Actor input object example

```json
{
  "searchUrls": [],
  "subtypes": [],
  "listedWithinHours": 0,
  "sortBy": "rank",
  "includeUnpriced": true,
  "fetchDetails": true,
  "fetchBrokers": true,
  "maxResults": 150,
  "useProxy": true,
  "proxyConfiguration": {
    "useApifyProxy": true
  },
  "maxConcurrency": 5
}
```

# Actor output Schema

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

All records extracted by this run. Open the Dataset tab to browse, filter, and export as CSV, JSON, or Excel.

# API

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

## JavaScript example

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

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

// Prepare Actor input
const input = {
    "searchUrls": [],
    "maxResults": 150
};

// Run the Actor and wait for it to finish
const run = await client.actor("logiover/crexi-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "searchUrls": [],
    "maxResults": 150,
}

# Run the Actor and wait for it to finish
run = client.actor("logiover/crexi-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "searchUrls": [],
  "maxResults": 150
}' |
apify call logiover/crexi-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,logiover/crexi-scraper"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/cWNEeVQa8cKbli8au/builds/9lvzQrghBa1A7yDup/openapi.json
