# Crexi + LoopNet — CRE Listing Extractor (`nexascout/cre-listing-extractor-staging`) Actor

Find for-sale commercial properties on Crexi and LoopNet. Get listings, published cap rate and NOI, brokers, and repeat-run change reports.

- **URL**: https://apify.com/nexascout/cre-listing-extractor-staging.md
- **Developed by:** [NexaScout](https://apify.com/nexascout) (community)
- **Stats:** 2 total users, 0 monthly users, 100.0% runs succeeded, 3 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $13.50 / 1,000 cre listings

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## CRE Listing Extractor — Crexi & LoopNet for-sale listings

Find commercial real estate **for-sale** listings by city and state. Get structured prices, property details, broker names and companies, and source-backed financial figures when published. Run the same search again to see which listings are new or changed.

### What it does

- Searches **Crexi** and **LoopNet** and combines duplicate listings while preserving their source links.
- Returns asking price or auction bid, address, property type, size, status, description and days on market when available.
- Includes published cap rate and NOI with source evidence and dates when available. Missing figures stay missing; they are never estimated.
- Marks whether a LoopNet result is in the requested city or a neighboring city in the same metro area. Crexi rows with a known city or state mismatch are excluded.
- Supports repeat runs that compare changes in price, status, cap rate, NOI, title and description. Set a recurring Apify task to automate checks.

### Quick start

Choose both sources, enter the same city and state for each, and set a small listing limit. Example input for Dallas, Texas:

```json
{
  "sources": ["crexi", "loopnet"],
  "crexi": {"city": "Dallas", "state": "TX", "size": 5, "pages": 1},
  "loopnet": {"city": "Dallas", "state": "TX", "maxListings": 5}
}
```

Run the Actor, then open the **Dataset** tab for the listings. Every run also writes a `run_summary` with search coverage and a `change_report` with new, changed and unchanged counts. The first run establishes the comparison baseline; rerun the same search to see changes.

You can also refresh known listings with `crexi.refreshIds` and `loopnet.refreshUrls`. Supply **both** `loopnet.city` and `loopnet.state` for regional search. Omitting both requests global sitemap sampling rather than a regional search.

### Output

Each `listing` includes its source URL and identifiers, title, address, price, property attributes and source provenance. The `detail` field explains whether cap rate, NOI, broker name or other information was extracted, unpublished or ambiguous. Financial values include available evidence, period, basis and as-of date. `geo_filter` explains how the actual location compares with the requested city.

### Pricing

- **Actor start:** $0.045 per run.
- **Listing:** $0.0135 per unique listing written to the dataset.
- `run_summary` and `change_report` records do not trigger a listing charge.

For example, 10 returned listings cost **$0.18** in event charges (one start plus ten listings). Platform usage may also apply according to your Apify plan.

### Coverage and limitations

This Actor extracts **sales** listings. It does not search lease inventory or provide broker phone numbers or email addresses. A source may omit financial details; the Actor does not invent them. LoopNet regional searches can include nearby cities, which are labeled in each result. Searches have strict page and listing limits; they are a sample of available inventory, not a promise of full market coverage. Site availability and listing data can change. Verify property and financial information with its source before making decisions.

# Actor input Schema

## `sources` (type: `array`):

Which source(s) to extract. Runs sequentially (concurrency fixed at 1).

## `crexi` (type: `object`):

Crexi universal-search parameters. size is capped at 60 and pages at 2 by the verified code.

## `loopnet` (type: `object`):

LoopNet regional FOR-SALE discovery (city+state) + direct-URL refresh + global NewListings sitemap sampling. maxListings is capped at 20. Regional search uses the api.loopnet.com city/state for-sale page (VERIFIED) with strict city-vs-metro labeling.

## `monitoring` (type: `object`):

Repeat-run change detection. When enabled (default), the Actor reads the durable LISTING\_STATE record from a NAMED key-value store (scoped by `namespace`), compares it to this run, emits a new/changed/unchanged change report (dataset + CHANGE\_REPORT key), and updates the durable state. Scheduled execution is NOT turned on by this flag. Removed listings are NEVER inferred from bounded coverage.

## `budget` (type: `object`):

Per-source request / byte / time limits. These are the same hard limits the verified transport enforces; lowering them is allowed, raising them above the maxima is rejected.

## Actor input object example

```json
{
  "sources": [
    "crexi",
    "loopnet"
  ]
}
```

# Actor output Schema

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

No description

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

No description

## `changeReport` (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 = {
    "sources": [
        "crexi",
        "loopnet"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("nexascout/cre-listing-extractor-staging").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 = { "sources": [
        "crexi",
        "loopnet",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("nexascout/cre-listing-extractor-staging").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 '{
  "sources": [
    "crexi",
    "loopnet"
  ]
}' |
apify call nexascout/cre-listing-extractor-staging --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,nexascout/cre-listing-extractor-staging"
        }
    }
}
```

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/apksEEiHBvRt2GRR4/builds/Hq7acrm4jd81IzaBF/openapi.json