# LoopNet & Commercial Real Estate Scraper (`actorzlab/loopnet-scraper`) Actor

Scrape commercial property listings from LoopNet: office, retail, industrial, multifamily, land, and more. Extracts address, price, size, property type, broker contacts, and full details. No CoStar subscription required.

- **URL**: https://apify.com/actorzlab/loopnet-scraper.md
- **Developed by:** [Khalil Drissi](https://apify.com/actorzlab) (community)
- **Categories:** Real estate, E-commerce
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

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

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

## LoopNet & Commercial Real Estate Scraper

Extract commercial property listings from LoopNet — office, retail, industrial, multifamily, land, hotels, and more. Get address, price, size, property type, broker contacts, and full listing details without a CoStar or LoopNet Pro subscription.

### Features

- **7 property types** — Office, Retail, Industrial, Multifamily, Land, Hotel, Healthcare, and any other type LoopNet lists
- **For Sale and For Lease** — filter by transaction type or scrape both
- **Broker contacts** — name, company, and phone number from detail pages
- **Full listing details** — year built, cap rate, zoning, tenancy, lot size, description
- **Automatic pagination** — follows Next page links up to your configured limit
- **Structured output** — clean, typed JSON records ready for spreadsheets, databases, or AI pipelines
- **Pay per result** — $0.005 per property, billed only for successfully extracted records

### Use cases

- **Investment research** — screen properties by price, cap rate, size, and location without a CoStar subscription
- **Broker prospecting** — build contact lists of listing brokers and their companies in a target market
- **Appraisal & market analysis** — gather comparable sales data for commercial appraisals
- **AI training data** — large-scale structured real estate data for model training
- **Portfolio monitoring** — track listing activity in specific submarkets over time

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `searchUrls` | array | required | LoopNet search result URLs (paste directly from your browser) |
| `maxItems` | integer | 100 | Maximum properties to extract (0 = unlimited) |
| `maxPagesPerSearch` | integer | 10 | Pages to paginate per search URL |
| `scrapeDetailPage` | boolean | true | Visit detail pages for broker contacts and extra fields |
| `transactionType` | string | any | Filter: `any`, `sale`, or `lease` |
| `propertyTypes` | array | — | Optional type filter (e.g. `["Office","Industrial"]`) |
| `proxyConfiguration` | object | residential | Proxy settings — residential proxies recommended |

#### Getting a search URL

1. Go to [loopnet.com](https://www.loopnet.com) and search for properties using their filter UI
2. Apply filters: location, property type, price range, size, etc.
3. Copy the URL from your browser's address bar and paste it into `searchUrls`

#### Example inputs

**Manhattan office listings for sale:**
```json
{
  "searchUrls": ["https://www.loopnet.com/search/office-space/manhattan-new-york-ny/for-sale/"],
  "maxItems": 200,
  "scrapeDetailPage": true
}
````

**Industrial warehouses in the Midwest for lease:**

```json
{
  "searchUrls": [
    "https://www.loopnet.com/search/industrial-space/chicago-il/for-lease/",
    "https://www.loopnet.com/search/industrial-space/detroit-mi/for-lease/"
  ],
  "maxItems": 500,
  "transactionType": "lease"
}
```

**Fast metadata-only scrape (no detail pages):**

```json
{
  "searchUrls": ["https://www.loopnet.com/search/commercial-real-estate/los-angeles-ca/for-sale/"],
  "maxItems": 1000,
  "scrapeDetailPage": false
}
```

### Output

Each extracted property is pushed as a dataset record with the following fields:

| Field | Type | Description |
|---|---|---|
| `url` | string | Full URL of the property listing |
| `listingId` | string | LoopNet numeric listing ID |
| `propertyType` | string | Office, Retail, Industrial, Multifamily, Land, etc. |
| `transactionType` | string | For Sale or For Lease |
| `address` | string | Street address |
| `city` | string | City |
| `state` | string | Two-letter state abbreviation |
| `zip` | string | ZIP code |
| `price` | string | Asking price (e.g. `$2,500,000` or `$45 PSF/YR`) |
| `pricePerSqFt` | string | Price per square foot if shown |
| `size` | string | Building size (e.g. `10,000 SF`) |
| `lotSize` | string | Lot or land area (e.g. `0.5 AC`) |
| `yearBuilt` | string | Year the building was constructed |
| `capRate` | string | Capitalization rate (investment properties) |
| `tenancy` | string | Single or Multi tenant |
| `zoning` | string | Zoning classification |
| `description` | string | Full listing description text |
| `brokerName` | string | Listing broker's name |
| `brokerCompany` | string | Brokerage company name |
| `brokerPhone` | string | Broker's phone number |
| `scrapedAt` | string | ISO 8601 UTC timestamp |

#### Example output record

```json
{
  "url": "https://www.loopnet.com/Listing/123-Park-Ave-New-York-NY/12345678/",
  "listingId": "12345678",
  "propertyType": "Office",
  "transactionType": "For Sale",
  "address": "123 Park Ave",
  "city": "New York",
  "state": "NY",
  "zip": "10017",
  "price": "$8,500,000",
  "pricePerSqFt": "$850/SF",
  "size": "10,000 SF",
  "lotSize": null,
  "yearBuilt": "1968",
  "capRate": "5.2%",
  "tenancy": "Single",
  "zoning": "C6-4",
  "description": "Class A office building in Midtown Manhattan...",
  "brokerName": "John Smith",
  "brokerCompany": "CBRE",
  "brokerPhone": "(212) 555-1234",
  "scrapedAt": "2026-05-24T10:00:00.000Z"
}
```

### Pricing

$0.005 per property extracted (charged only for successfully pushed records).

| Volume | Cost |
|---|---|
| 100 properties | $0.50 |
| 1,000 properties | $5.00 |
| 10,000 properties | $50.00 |

Note: there is a 14-day delay before pricing changes take effect per Apify policy.

### Proxy & bot detection

LoopNet uses Akamai bot protection. **Residential proxies are strongly recommended** — the default input pre-selects Apify Residential proxies. Using datacenter proxies or no proxy will likely result in blocks (HTTP 403 or redirect to a CAPTCHA page).

### FAQ

**What data is publicly available on LoopNet without logging in?**
Listing address, property type, transaction type, price, and size are available without an account. Broker contact details and some additional fields (year built, cap rate) are on detail pages that are publicly accessible but may require proxy bypass of bot detection.

**Why might some fields be null?**
Not all listings include every field. Cap rate is only shown for income-producing properties. Year built and zoning may be omitted by the seller. Broker phone is sometimes obscured behind a click-to-reveal that requires JS interaction.

**How many results can I get per search URL?**
LoopNet typically shows up to 40-50 results per page and paginates up to several hundred pages for large markets. Set `maxPagesPerSearch` and `maxItems` to control volume and cost.

**Can I scrape a specific property page?**
Yes — paste the direct listing URL into `searchUrls`. The actor detects whether a URL is a search results page or a direct listing.

**Is this legal?**
This actor extracts publicly accessible commercial listing data. Users are responsible for complying with LoopNet's Terms of Service and applicable law, including restrictions on data resale and automated access.

# Actor input Schema

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

One or more LoopNet search result URLs to scrape. Paste the URL directly from your browser after applying filters on LoopNet (location, property type, price range, etc.).

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

Maximum number of properties to extract across all search URLs. Set to 0 for no limit.

## `maxPagesPerSearch` (type: `integer`):

Maximum number of search result pages to paginate through for each search URL.

## `scrapeDetailPage` (type: `boolean`):

Visit each property's detail page to extract broker contacts, year built, cap rate, zoning, and full description. Slower but produces richer data. Disable for fast metadata-only runs.

## `transactionType` (type: `string`):

Filter results by sale or lease. Only applies when the search URL returns mixed results.

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

Restrict to specific property types (case-insensitive). Leave empty to include all types. Examples: Office, Retail, Industrial, Multifamily, Land, Hotel, Healthcare.

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

Residential proxies are strongly recommended — LoopNet is protected by Akamai bot detection. Apify Residential proxies provide the best success rate.

## Actor input object example

```json
{
  "searchUrls": [
    "https://www.loopnet.com/search/commercial-real-estate/new-york-ny/for-sale/"
  ],
  "maxItems": 100,
  "maxPagesPerSearch": 10,
  "scrapeDetailPage": true,
  "transactionType": "any",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

## `properties` (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 = {
    "searchUrls": [
        "https://www.loopnet.com/search/commercial-real-estate/new-york-ny/for-sale/"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("actorzlab/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 = {
    "searchUrls": ["https://www.loopnet.com/search/commercial-real-estate/new-york-ny/for-sale/"],
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("actorzlab/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 '{
  "searchUrls": [
    "https://www.loopnet.com/search/commercial-real-estate/new-york-ny/for-sale/"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call actorzlab/loopnet-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "LoopNet & Commercial Real Estate Scraper",
        "description": "Scrape commercial property listings from LoopNet: office, retail, industrial, multifamily, land, and more. Extracts address, price, size, property type, broker contacts, and full details. No CoStar subscription required.",
        "version": "0.0",
        "x-build-id": "iEfs58rFgdbt6ea49"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/actorzlab~loopnet-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-actorzlab-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/actorzlab~loopnet-scraper/runs": {
            "post": {
                "operationId": "runs-sync-actorzlab-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/actorzlab~loopnet-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-actorzlab-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",
                "required": [
                    "searchUrls"
                ],
                "properties": {
                    "searchUrls": {
                        "title": "Search URLs",
                        "type": "array",
                        "description": "One or more LoopNet search result URLs to scrape. Paste the URL directly from your browser after applying filters on LoopNet (location, property type, price range, etc.).",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxItems": {
                        "title": "Max properties",
                        "minimum": 0,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of properties to extract across all search URLs. Set to 0 for no limit.",
                        "default": 100
                    },
                    "maxPagesPerSearch": {
                        "title": "Max pages per search URL",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Maximum number of search result pages to paginate through for each search URL.",
                        "default": 10
                    },
                    "scrapeDetailPage": {
                        "title": "Scrape detail pages",
                        "type": "boolean",
                        "description": "Visit each property's detail page to extract broker contacts, year built, cap rate, zoning, and full description. Slower but produces richer data. Disable for fast metadata-only runs.",
                        "default": true
                    },
                    "transactionType": {
                        "title": "Transaction type filter",
                        "enum": [
                            "any",
                            "sale",
                            "lease"
                        ],
                        "type": "string",
                        "description": "Filter results by sale or lease. Only applies when the search URL returns mixed results.",
                        "default": "any"
                    },
                    "propertyTypes": {
                        "title": "Property type filter",
                        "type": "array",
                        "description": "Restrict to specific property types (case-insensitive). Leave empty to include all types. Examples: Office, Retail, Industrial, Multifamily, Land, Hotel, Healthcare.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Residential proxies are strongly recommended — LoopNet is protected by Akamai bot detection. Apify Residential proxies provide the best success rate."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
