# LoopNet Scraper — CRE Listings, Prices & Details (`khadinakbar/loopnet-scraper`) Actor

Extract LoopNet commercial real estate listings from locations, search URLs, or property pages. Returns canonical URLs, prices, property types, sizes, addresses, provenance, and optional building and broker details.

- **URL**: https://apify.com/khadinakbar/loopnet-scraper.md
- **Developed by:** [Khadin Akbar](https://apify.com/khadinakbar) (community)
- **Categories:** Real estate, Lead generation, MCP servers
- **Stats:** 4 total users, 4 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $6.00 / 1,000 listing scrapeds

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/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js/docs.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## LoopNet Scraper for Commercial Real Estate Listings

Extract public LoopNet commercial real estate listings from a location search, a LoopNet search URL, or selected listing pages. Each dataset row represents one validated property listing with canonical identity, price, property type, size, location, image, provenance, and optional building and broker details.

### Best fit for this Actor

Choose this Actor for LoopNet sale and lease research, commercial property sourcing, market comparisons, and broker-enriched listing datasets. Use location and property filters for discovery, or provide listing URLs when your workflow starts from a selected property set.

### Focused standalone workflow

This Actor is designed as a focused standalone workflow for LoopNet commercial property discovery and listing-detail enrichment.

### A practical acquisition scenario

A commercial real estate analyst starts with a city, listing type, and property category. The Actor collects canonical listing records with price, size, address, and property type; the analyst then enables detail enrichment for shortlisted listings and exports broker, cap-rate, building-size, and year-built fields into an acquisition worksheet.

### Quick start input

```json
{
  "location": "Austin, TX",
  "listingType": "for-sale",
  "propertyType": "Office",
  "maxResults": 10,
  "enrichDetails": true
}
````

You can also place LoopNet search pages in `searchUrls` or canonical property pages in `startUrls`.

### What data you receive

| Field | Meaning |
| --- | --- |
| `listingId`, `url`, `name` | Canonical listing identity and title |
| `propertyType`, `propertySubtype`, `availability` | Property classification and public status |
| `price`, `priceText`, `currency`, `isAuction` | Public pricing presentation |
| `sizeValue`, `sizeUnit`, `buildingSize`, `lotSize` | Property size fields |
| `street`, `city`, `state`, `zip` | Listing location |
| `yearBuilt`, `capRate` | Enriched property details when displayed |
| `brokerName`, `brokerCompany` | Public broker fields when displayed |
| `sourceUrl`, `scrapedAt` | Provenance and collection time |

```json
{
  "listingId": 40482433,
  "url": "https://www.loopnet.com/Listing/701-E-Franklin-St-Endicott-NY/40482433/",
  "name": "Commercial Property",
  "propertyType": "Office",
  "priceText": "$1,250,000",
  "currency": "USD",
  "city": "Endicott",
  "state": "NY",
  "sourceUrl": "https://www.loopnet.com/search/example/",
  "scrapedAt": "<ISO-8601 collection time>"
}
```

### Run through the Apify API

```bash
curl -X POST "https://api.apify.com/v2/acts/khadinakbar~loopnet-scraper/runs" \
  -H "Authorization: Bearer $APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"location":"Austin, TX","listingType":"for-sale","propertyType":"Office","maxResults":10}'
```

Read the default dataset for listing rows and the default key-value store for `OUTPUT` and `RUN_SUMMARY`.

### Use with AI agents through Apify MCP

Example prompt:

> Find public LoopNet office listings for sale in Austin. Return canonical URL, price, property type, size, address, broker fields, source URL, and collection time. Read the dataset and summarize the shortlisted properties with source provenance.

Give the agent a location, listing type, property type, and focused result scope. Ask it to retain source URLs, read the dataset after completion, and report the Apify cost with the outcome.

### Pricing

This Actor uses Pay per event plus Apify platform usage. Listing records and optional detail enrichment use the events configured for the Actor. Open the live Pricing tab for current billing details and use `maxResults` or Apify run cost controls to keep each research pass focused.

### Best results

Provide a specific location and property type for discovery, or canonical listing URLs for detail-first research. Enable enrichment after the broad listing fields identify the properties that support a deeper review.

### Builder's note

I built the search parser around structured listing data first and canonical listing links as a second source because LoopNet can present the same useful property identity through different page structures. Keeping `sourceUrl` and `scrapedAt` on each row makes those observations easier to audit later.

### Responsible use

Collect public listing data you are authorized to access and follow applicable laws, LoopNet terms, and your organization's real estate data policies.

# Actor input Schema

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

One or more LoopNet search-results URLs copied from your browser (e.g. 'https://www.loopnet.com/search/office-buildings/los-angeles-ca/for-sale/'). The actor paginates each and returns every listing. This is the most reliable input — apply any filters on LoopNet, then paste the URL. Leave empty to use the location + type fields below, or startUrls for specific listings.

## `location` (type: `string`):

City and state to search when no searchUrls are given (e.g. 'Los Angeles, CA' or 'Austin, TX'). Used to build a LoopNet search URL together with 'listingType' and 'propertyType'. Leave empty if you supplied searchUrls or startUrls. NOT a ZIP code.

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

Whether to search properties for sale or for lease when building a search from 'location'. Ignored when searchUrls are provided. Defaults to for-sale.

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

Commercial property category used when building a search from 'location'. Ignored when searchUrls are provided. Defaults to All. One of: All, Office, Retail, Industrial, Multifamily, Land, Hospitality, Special Purpose, Self Storage.

## `startUrls` (type: `array`):

One or more LoopNet property URLs (e.g. 'https://www.loopnet.com/Listing/701-E-Franklin-St-Endicott-NY/40482433/') or bare numeric listing IDs. When provided, the actor scrapes exactly these detail pages instead of running a search. Leave empty to use search input.

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

Hard cap on listings collected and charged for (e.g. 100). Protects your budget. Set 0 to remove the cap and collect every match. Defaults to 100. In detail mode this caps how many startUrls are processed.

## `enrichDetails` (type: `boolean`):

When true, each search listing is enriched by visiting its detail page for broker, year built, building/lot size, cap rate, and full description (one extra page load per listing — slower and pricier). Set false for fast listing-card output (price, type, size, address, image). Defaults to false. Always on in detail mode.

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

Optional proxy override. By default the actor uses its own residential proxy tier to clear LoopNet's Akamai protection. Supply your own residential proxy here only if you have IPs LoopNet has not blocked; datacenter proxies do not work.

## Actor input object example

```json
{
  "searchUrls": [],
  "location": "Los Angeles, CA",
  "listingType": "for-sale",
  "propertyType": "All",
  "startUrls": [],
  "maxResults": 30,
  "enrichDetails": false,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

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

LoopNet commercial real estate records collected by this run.

## `summary` (type: `string`):

Machine-readable terminal outcome, record counts, warnings, and PPE counters.

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

Detailed terminal diagnostics for automation and support.

# 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 = {
    "location": "Los Angeles, CA",
    "maxResults": 30,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("khadinakbar/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 = {
    "location": "Los Angeles, CA",
    "maxResults": 30,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("khadinakbar/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 '{
  "location": "Los Angeles, CA",
  "maxResults": 30,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call khadinakbar/loopnet-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "LoopNet Scraper — CRE Listings, Prices & Details",
        "description": "Extract LoopNet commercial real estate listings from locations, search URLs, or property pages. Returns canonical URLs, prices, property types, sizes, addresses, provenance, and optional building and broker details.",
        "version": "1.0",
        "x-build-id": "YFMaxa9LTbEpSa4hH"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/khadinakbar~loopnet-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-khadinakbar-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/khadinakbar~loopnet-scraper/runs": {
            "post": {
                "operationId": "runs-sync-khadinakbar-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/khadinakbar~loopnet-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-khadinakbar-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": {
                    "searchUrls": {
                        "title": "LoopNet search URLs",
                        "type": "array",
                        "description": "One or more LoopNet search-results URLs copied from your browser (e.g. 'https://www.loopnet.com/search/office-buildings/los-angeles-ca/for-sale/'). The actor paginates each and returns every listing. This is the most reliable input — apply any filters on LoopNet, then paste the URL. Leave empty to use the location + type fields below, or startUrls for specific listings.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "location": {
                        "title": "Location",
                        "type": "string",
                        "description": "City and state to search when no searchUrls are given (e.g. 'Los Angeles, CA' or 'Austin, TX'). Used to build a LoopNet search URL together with 'listingType' and 'propertyType'. Leave empty if you supplied searchUrls or startUrls. NOT a ZIP code."
                    },
                    "listingType": {
                        "title": "For sale or lease",
                        "enum": [
                            "for-sale",
                            "for-lease"
                        ],
                        "type": "string",
                        "description": "Whether to search properties for sale or for lease when building a search from 'location'. Ignored when searchUrls are provided. Defaults to for-sale.",
                        "default": "for-sale"
                    },
                    "propertyType": {
                        "title": "Property type",
                        "enum": [
                            "All",
                            "Office",
                            "Retail",
                            "Industrial",
                            "Multifamily",
                            "Land",
                            "Hospitality",
                            "Special Purpose",
                            "Self Storage"
                        ],
                        "type": "string",
                        "description": "Commercial property category used when building a search from 'location'. Ignored when searchUrls are provided. Defaults to All. One of: All, Office, Retail, Industrial, Multifamily, Land, Hospitality, Special Purpose, Self Storage.",
                        "default": "All"
                    },
                    "startUrls": {
                        "title": "LoopNet listing URLs (detail mode)",
                        "type": "array",
                        "description": "One or more LoopNet property URLs (e.g. 'https://www.loopnet.com/Listing/701-E-Franklin-St-Endicott-NY/40482433/') or bare numeric listing IDs. When provided, the actor scrapes exactly these detail pages instead of running a search. Leave empty to use search input.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxResults": {
                        "title": "Max results",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Hard cap on listings collected and charged for (e.g. 100). Protects your budget. Set 0 to remove the cap and collect every match. Defaults to 100. In detail mode this caps how many startUrls are processed.",
                        "default": 100
                    },
                    "enrichDetails": {
                        "title": "Enrich with full property detail",
                        "type": "boolean",
                        "description": "When true, each search listing is enriched by visiting its detail page for broker, year built, building/lot size, cap rate, and full description (one extra page load per listing — slower and pricier). Set false for fast listing-card output (price, type, size, address, image). Defaults to false. Always on in detail mode.",
                        "default": false
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Optional proxy override. By default the actor uses its own residential proxy tier to clear LoopNet's Akamai protection. Supply your own residential proxy here only if you have IPs LoopNet has not blocked; datacenter proxies do not work.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ]
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
