# 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, 3 monthly users, 87.5% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $6.00 / 1,000 listing scrapeds

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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

Download the OpenAPI definition: https://api.apify.com/v2/actors/yhSRVZmrHxhDbr83C/builds/jXIsBNf5S1My3pScn/openapi.json