# 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
- **Features:** Limited permissions
- **Stats:** 8 total users, 1 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/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## How to integrate an Actor?

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

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

### What is 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.

### 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 with Apify platform usage included. 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.

For standard location, property-type, and sale/lease searches without detail enrichment, the Actor uses a bounded public-index route first and accepts only canonical LoopNet listing identities. This avoids spending through a browser chain when LoopNet's Akamai edge is blocking it. A pasted custom search URL, detail mode, or enrichment still uses LoopNet directly so its exact filters and page-level fields are preserved.

Use `useUnblocker: true` only when you specifically need to probe a direct browser response through Apify Unblocker. It remains a bounded two-attempt diagnostic path because Unblocker proxy usage is metered separately and does not provide a sticky session. Check `RUN_SUMMARY.providers` to see which route supplied the result.

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

### Continue the workflow

- Then use [Property Finder UAE Agent Scraper](https://apify.com/khadinakbar/propertyfinder-agent-scraper) to extend LoopNet Scraper for Commercial Real Estate Listings with a neighboring property research source when the brief calls for Propertyfinder data.
- Then use [Idealista Scraper — Spain, Italy & Portugal Property Listings](https://apify.com/khadinakbar/idealista-scraper) to extend LoopNet Scraper for Commercial Real Estate Listings with a neighboring property research source when the brief calls for Idealista data.

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

# Changelog

This Actor's version history is a separate document: https://apify.com/khadinakbar/loopnet-scraper/changelog.md

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

## `useUnblocker` (type: `boolean`):

Optional diagnostic probe for an Akamai-blocked LoopNet browser request. Normal structured listing-card searches use the validated public-index route first; enable this only when you specifically need to test a direct browser response. It limits direct attempts to two and Unblocker usage is metered separately by Apify.

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

Optional browser-mode proxy override. Structured listing-card searches use the validated public-index route first; this setting applies when the actor must visit LoopNet directly (for custom search URLs, enrichment, or detail mode). Supply only residential proxies that 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": 1,
  "enrichDetails": false,
  "useUnblocker": 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": 1,
    "useUnblocker": false,
    "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": 1,
    "useUnblocker": False,
    "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(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "location": "Los Angeles, CA",
  "maxResults": 1,
  "useUnblocker": false,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call khadinakbar/loopnet-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,khadinakbar/loopnet-scraper"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

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