# LoopNet Business Listings Scraper (`parseforge/loopnet-scraper`) Actor

Extract comprehensive business listing data from LoopNet.com including financials, contact details, and specifications. Perfect for business brokers, investors, and market researchers.

- **URL**: https://apify.com/parseforge/loopnet-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** Lead generation, Automation
- **Stats:** 47 total users, 10 monthly users, 93.0% runs succeeded, 3 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

Pay per event

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.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.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/platform/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

![ParseForge Banner](https://github.com/ParseForge/apify-assets/blob/ad35ccc13ddd068b9d6cba33f323962e39aed5b2/banner.jpg?raw=true)

## 🏢 LoopNet Scraper

> 🚀 **Export commercial real estate listings in seconds.** Pull addresses, prices, property types, square footage, and listing URLs straight from LoopNet into clean CSV, Excel, JSON, or XML, no copy-paste and no broker calls.

> 🕒 **Last updated:** 2026-06-04 · **📊 18 fields** per record · scale up to 1,000,000 listings per run · nationwide US commercial coverage

LoopNet is one of the largest commercial real estate marketplaces in the United States, listing office, retail, industrial, land, multifamily, hospitality, and special-purpose properties for sale and for lease. This Actor turns any LoopNet location search into a structured dataset so you can analyze the market in a spreadsheet instead of clicking through pages one listing at a time.

Coverage spans every major US metro and thousands of smaller markets. Search by city and state (for example "Los Angeles, CA", "New York, NY", "Chicago, IL", or "Miami, FL"), filter by listing type and property category, and the Actor returns each matching property with its image, address, price, size, and a direct link back to the original LoopNet listing.

| 🎯 Target Audience | 💡 Primary Use Cases |
|---|---|
| Commercial real estate brokers and agents | Build lead lists of for-sale and for-lease properties in a target market |
| CRE investors and acquisition teams | Track new listings, pricing, and inventory by property type |
| Market analysts and researchers | Measure supply, price trends, and absorption across metros |
| Proptech and CRE data companies | Feed listing data into CRMs, dashboards, and valuation models |
| Lenders, appraisers, and developers | Pull comparable properties and monitor a submarket |

### 📋 What the LoopNet Scraper does

The LoopNet Scraper takes a location search and collects the commercial property listings that match it. For each property it captures:

- The listing image, title, and direct LoopNet URL
- Price and listing type (For Sale or For Lease)
- Property type (Office, Retail, Industrial, Land, Multifamily, and more)
- Square footage where published
- Full address broken into address, city, state, ZIP, and country

You control the search with four simple inputs: a location query, the listing type, an optional property type filter, and a maximum number of items. The Actor handles pagination, parsing, and de-duplication for you, then writes everything to a dataset you can export or pipe into another tool.

### 🎬 Full Demo (_🚧 Coming soon_)

A step-by-step video walkthrough is on the way. In the meantime, the How to use section below gets you to your first export in under two minutes.

### ⚙️ Input

Configure the run from the Apify UI or pass a JSON input via the API. All inputs are optional and come with sensible defaults.

<table>
  <thead>
    <tr><th>Field</th><th>Key</th><th>Type</th><th>Description</th><th>Default</th></tr>
  </thead>
  <tbody>
    <tr>
      <td>Search Query</td>
      <td><code>searchQuery</code></td>
      <td>String</td>
      <td>Location to search, for example "Los Angeles, CA", "New York, NY", "Chicago, IL", or "Miami, FL". Converted to a LoopNet URL slug.</td>
      <td><code>Los Angeles, CA</code></td>
    </tr>
    <tr>
      <td>Listing Type</td>
      <td><code>listingType</code></td>
      <td>String (select)</td>
      <td>Whether to scrape properties <code>for-sale</code> or <code>for-lease</code>.</td>
      <td><code>for-sale</code></td>
    </tr>
    <tr>
      <td>Property Type</td>
      <td><code>propertyType</code></td>
      <td>String (select)</td>
      <td>Filter by category: office, retail, industrial, land, multifamily, hospitality, flex, special-purpose, or health-care. Leave empty for all types.</td>
      <td><code>"" (all types)</code></td>
    </tr>
    <tr>
      <td>Max Items</td>
      <td><code>maxItems</code></td>
      <td>Integer</td>
      <td>Maximum listings to collect. Free users are limited to 10 items (preview). Paid users can request up to 1,000,000.</td>
      <td><code>10</code></td>
    </tr>
  </tbody>
</table>

#### Example 1: Industrial properties for sale in Los Angeles

```json
{
  "searchQuery": "Los Angeles, CA",
  "listingType": "for-sale",
  "propertyType": "industrial",
  "maxItems": 50
}
````

#### Example 2: All office space for lease in New York

```json
{
  "searchQuery": "New York, NY",
  "listingType": "for-lease",
  "propertyType": "office",
  "maxItems": 100
}
```

> ⚠️ **Good to Know:** LoopNet uses anti-bot protection, so an occasional run may return fewer results than the page shows or may need a retry. Results-page listings include price, address, property type, and square footage. Fields such as `capRate`, `yearBuilt`, `brokerName`, and `pricePerSqFt` live on individual detail pages and are frequently empty on the results feed, so expect them to be `null` for many records.

### 📊 Output

Each record is a flat JSON object, ideal for export to CSV, Excel, JSON, or XML. The dataset uses these fields:

| Field | Key | Description |
|---|---|---|
| 🖼 Image | `imageUrl` | URL of the listing photo |
| 📌 Title | `title` | Property name or street address as shown on LoopNet |
| 💲 Price | `price` | Listed price as text, for example "$2,500,000" |
| 📐 Price / SqFt | `pricePerSqFt` | Price per square foot (often `null`, from detail page) |
| 🏷 Property Type | `propertyType` | Office, Retail, Industrial, Land, and so on |
| 📏 Square Footage | `squareFootage` | Building size in square feet |
| 🏠 Address | `address` | Street address |
| 🏙 City | `city` | City |
| 🗺 State | `state` | Two-letter state code |
| 📮 ZIP | `zipCode` | Postal code |
| 🌎 Country | `country` | Country code, for example "US" |
| 🔁 Listing Type | `listingType` | "For Sale" or "For Lease" |
| 📈 Cap Rate | `capRate` | Capitalization rate (often `null`, from detail page) |
| 📅 Year Built | `yearBuilt` | Year constructed (often `null`, from detail page) |
| 👤 Broker / Firm | `brokerName` | Broker or listing firm (often `null`, from detail page) |
| 🔗 URL | `listingUrl` | Direct link to the LoopNet listing |
| 🕒 Scraped At | `scrapedAt` | ISO timestamp of collection |

#### Real sample records

```json
{
  "imageUrl": "https://images1.loopnet.com/i2/1tVreTs22fZoOGFLus0ov4by05nSzg1XFYNFnsCd1F8/117/industrial-property-for-sale-13290-e-daum-dr-city-of-industry-ca-91746.jpg",
  "title": "13290 E Daum Dr",
  "price": "$2,500,000",
  "pricePerSqFt": null,
  "propertyType": "Industrial",
  "squareFootage": 63000,
  "address": "13290 E Daum Dr",
  "city": "City of Industry",
  "state": "CA",
  "zipCode": "91746",
  "country": "US",
  "listingType": "For Sale",
  "capRate": null,
  "yearBuilt": null,
  "brokerName": null,
  "listingUrl": "https://www.loopnet.com/Listing/13290-E-Daum-Dr-City-of-Industry-CA/39018502/",
  "scrapedAt": "2026-06-04T21:38:02.011Z"
}
```

```json
{
  "imageUrl": "https://images1.loopnet.com/i2/V5XTHdzLiJGQQ8kF3xcieOR8ZU-WJuHMZ6k7qEr1o3A/117/industrial-property-for-sale-767-e-14th-pl-los-angeles-ca-90021.jpg",
  "title": "767 E 14th Pl",
  "price": "$300,000",
  "pricePerSqFt": null,
  "propertyType": "Industrial",
  "squareFootage": 4216,
  "address": "767 E 14th Pl",
  "city": "Los Angeles",
  "state": "CA",
  "zipCode": "90021",
  "country": "US",
  "listingType": "For Sale",
  "capRate": null,
  "yearBuilt": null,
  "brokerName": null,
  "listingUrl": "https://www.loopnet.com/Listing/767-E-14th-Pl-Los-Angeles-CA/37052433/",
  "scrapedAt": "2026-06-04T21:38:02.012Z"
}
```

```json
{
  "imageUrl": "https://images1.loopnet.com/i2/CynNlY1g72RuPmkviCg7h-T1Vtaf7G4f9kwaVutzQg8/117/land-property-for-sale-7210-s-western-ave-los-angeles-ca-90047.jpg",
  "title": "7210 S Western Ave",
  "price": "$125,000",
  "pricePerSqFt": null,
  "propertyType": "Land",
  "squareFootage": null,
  "address": "7210 S Western Ave",
  "city": "Los Angeles",
  "state": "CA",
  "zipCode": "90047",
  "country": "US",
  "listingType": "For Sale",
  "capRate": null,
  "yearBuilt": null,
  "brokerName": null,
  "listingUrl": "https://www.loopnet.com/Listing/7210-S-Western-Ave-Los-Angeles-CA/37277760/",
  "scrapedAt": "2026-06-04T21:38:02.012Z"
}
```

### ✨ Why choose this Actor

- **Real, verified output.** Field names and sample records above come straight from a live run, not a mock.
- **Clean, flat schema.** Every record exports cleanly to CSV, Excel, JSON, or XML with no nested wrangling.
- **Simple inputs.** Four fields cover location, sale versus lease, property category, and result count.
- **Scale on demand.** Collect a handful of comps or up to 1,000,000 listings in a single run.
- **Direct links back.** Every record includes the original LoopNet URL so you can verify any listing.
- **No account or cookies required.** Only publicly visible listing data is collected.

### 📈 How it compares to alternatives

| Approach | Setup time | Structured export | Scales to thousands | Maintenance |
|---|---|---|---|---|
| **LoopNet Scraper (this Actor)** | Under 2 minutes | Yes, CSV / Excel / JSON / XML | Yes, up to 1,000,000 | None, we maintain it |
| Manual copy-paste from the site | Hours per market | No | No | Constant |
| Generic web-scraping framework | Days of coding | You build it | Maybe | You own every breakage |
| Paid CRE data subscription | Sales calls and contracts | Yes | Yes | Vendor lock-in |

### 🚀 How to use

1. **Create a free Apify account** using [this sign-up link](https://console.apify.com/sign-up?fpr=vmoqkp). It takes about a minute and no credit card is needed to start.
2. **Open the LoopNet Scraper** from your Apify Console and click **Try for free**.
3. **Set your inputs**: type a location into Search Query, pick For Sale or For Lease, optionally choose a property type, and set Max Items.
4. **Click Start** and watch the run collect listings in real time. Most small runs finish in under a minute.
5. **Export your data** from the dataset tab as CSV, Excel, JSON, or XML, or grab it through the Apify API.

### 💼 Business use cases

#### Brokerage and lead generation

| Goal | How this Actor helps |
|---|---|
| Find active listings in a farm area | Search by city and property type to build a fresh inventory list |
| Identify owners and firms to contact | Pull listing URLs to dig into each property's broker page |

#### Investment and acquisitions

| Goal | How this Actor helps |
|---|---|
| Screen deals by size and price | Filter by property type and sort exported square footage and price |
| Track new supply in a metro | Re-run weekly and compare datasets to spot fresh listings |

#### Market research and analytics

| Goal | How this Actor helps |
|---|---|
| Measure inventory by category | Count Office, Retail, Industrial, and Land listings per market |
| Benchmark asking prices | Export price and square footage across many properties at once |

#### Proptech and product data

| Goal | How this Actor helps |
|---|---|
| Seed a CRE listings database | Bulk-collect structured records to populate your own app |
| Keep a dashboard current | Schedule runs and push results into your warehouse |

### 🔌 Automating LoopNet Scraper

Connect the Actor to the rest of your stack so listing data flows automatically:

- **Make** and **Zapier**: trigger a run on a schedule and route results into thousands of apps.
- **Slack**: post a message when new listings appear in your target market.
- **Airbyte**: load the dataset into your data warehouse on a recurring sync.
- **GitHub**: kick off runs from Actions and version your collection scripts.
- **Google Drive**: drop CSV or Excel exports into a shared folder for your team.

Use Apify Schedules to run the scraper hourly, daily, or weekly with zero manual effort.

### 🌟 Beyond business use cases

- **Academic research**: study commercial real estate supply, pricing, and geography across markets.
- **Personal projects**: track listings in a neighborhood you are watching or planning to invest in.
- **Non-profit and civic work**: analyze commercial property availability for community or economic-development studies.
- **Experimentation**: practice data cleaning, mapping, and visualization on a real, structured dataset.

### 🤖 Ask an AI assistant

Once you have exported your data, drop it into your favorite assistant and ask questions in plain English:

- **ChatGPT**: "Which industrial listings under $1M have the largest square footage?"
- **Claude**: "Summarize the price range of office space for lease in this dataset."
- **Perplexity**: "What are the most common property types in this LoopNet export?"
- **Microsoft Copilot**: "Build a pivot table of average price by city from this CSV."

### ❓ Frequently Asked Questions

**Is this Actor free to use?**
You can run it for free with a preview limit of 10 items. Paid Apify plans unlock up to 1,000,000 items per run.

**What locations are supported?**
Any US location LoopNet covers. Enter a city and state such as "Miami, FL" or "Chicago, IL".

**Can I scrape both for-sale and for-lease properties?**
Yes. Set `listingType` to `for-sale` or `for-lease`. Run it twice if you want both.

**Which property types can I filter by?**
Office, Retail, Industrial, Land, Multifamily, Hospitality, Flex, Special Purpose, and Health Care. Leave the field empty for all types.

**Why are capRate, yearBuilt, brokerName, or pricePerSqFt empty?**
Those fields live on individual property detail pages and are not always present on the results feed, so they are frequently `null`. Price, address, property type, and square footage are reliably populated.

**What export formats are available?**
CSV, Excel, JSON, and XML, plus direct access through the Apify API.

**How many listings can I collect in one run?**
Up to 1,000,000 on a paid plan. Free runs return up to 10 listings.

**Does the Actor handle pagination automatically?**
Yes. It walks through result pages until it reaches your Max Items limit.

**Do I need a LoopNet account or login?**
No. The Actor only collects publicly visible listing information.

**Why did a run return fewer results than expected?**
LoopNet uses anti-bot measures, so a run can occasionally return fewer listings or need a retry. Re-running usually resolves it.

**Can I schedule recurring runs?**
Yes. Use Apify Schedules to run the scraper on any cadence and keep your data fresh.

**Can I integrate the output with my own tools?**
Absolutely. Use the Apify API, webhooks, or integrations like Make, Zapier, and Airbyte.

### 🔌 Integrate with any app

Every run writes to an Apify dataset you can reach through the REST API, webhooks, and the official Apify client libraries for JavaScript and Python. Trigger runs, fetch results, and push them into CRMs, spreadsheets, BI dashboards, or your own database with a few lines of code.

### 🔗 Recommended Actors

If you work across real estate data, these ParseForge Actors pair well with this one:

- [Realtor.com Scraper](https://apify.com/parseforge/realtor-com-scraper): residential listings, prices, and property details.
- [Zillow Scraper](https://apify.com/parseforge/zillow-scraper): homes for sale with rich property data.
- [Redfin Scraper](https://apify.com/parseforge/redfin-scraper): residential listings and market info.
- [CommercialCafe Scraper](https://apify.com/parseforge/commercialcafe-scraper): additional commercial real estate listings.
- [Showcase Commercial Scraper](https://apify.com/parseforge/showcase-commercial-scraper): commercial properties from Showcase.com.

> 💡 **Pro Tip:** browse the complete [ParseForge collection](https://apify.com/parseforge) for hundreds more ready-to-run scrapers.

**🆘 Need Help?** [Open our contact form](https://tally.so/r/BzdKgA) and we will get back to you.

> **⚠️ Disclaimer:** This is an independent tool and is not affiliated with, endorsed by, or sponsored by LoopNet or CoStar Group. It collects only publicly available data and is intended for lawful use in line with applicable terms and regulations.

# Actor input Schema

## `searchQuery` (type: `string`):

Location to search (e.g. 'Los Angeles, CA', 'New York, NY', 'Chicago, IL', 'Miami, FL'). This is converted to a LoopNet URL slug.

## `maxItems` (type: `integer`):

Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000

## `listingType` (type: `string`):

Whether to scrape properties for sale or for lease.

## `propertyType` (type: `string`):

Type of commercial property to filter by. Leave empty for all types.

## Actor input object example

```json
{
  "searchQuery": "Los Angeles, CA",
  "maxItems": 10,
  "listingType": "for-sale",
  "propertyType": ""
}
```

# 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 = {
    "searchQuery": "Los Angeles, CA",
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/loopnet-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 = {
    "searchQuery": "Los Angeles, CA",
    "maxItems": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("parseforge/loopnet-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 '{
  "searchQuery": "Los Angeles, CA",
  "maxItems": 10
}' |
apify call parseforge/loopnet-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "LoopNet Business Listings Scraper",
        "description": "Extract comprehensive business listing data from LoopNet.com including financials, contact details, and specifications. Perfect for business brokers, investors, and market researchers.",
        "version": "0.1",
        "x-build-id": "ADMZBKgCwkjd0Pb8R"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~loopnet-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-loopnet-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/parseforge~loopnet-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-loopnet-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/parseforge~loopnet-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-loopnet-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "searchQuery": {
                        "title": "Search Query",
                        "type": "string",
                        "description": "Location to search (e.g. 'Los Angeles, CA', 'New York, NY', 'Chicago, IL', 'Miami, FL'). This is converted to a LoopNet URL slug."
                    },
                    "maxItems": {
                        "title": "Max Items",
                        "minimum": 1,
                        "maximum": 1000000,
                        "type": "integer",
                        "description": "Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000"
                    },
                    "listingType": {
                        "title": "Listing Type",
                        "enum": [
                            "for-sale",
                            "for-lease"
                        ],
                        "type": "string",
                        "description": "Whether to scrape properties for sale or for lease.",
                        "default": "for-sale"
                    },
                    "propertyType": {
                        "title": "Property Type",
                        "enum": [
                            "",
                            "office",
                            "retail",
                            "industrial",
                            "land",
                            "multifamily",
                            "hospitality",
                            "flex",
                            "special-purpose",
                            "health-care"
                        ],
                        "type": "string",
                        "description": "Type of commercial property to filter by. Leave empty for all types.",
                        "default": ""
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
