# LoopNet Auctions Scraper - CRE Auction Listings & Bids (`parseforge/loopnet-auctions-scraper`) Actor

Reads every commercial real estate auction listed on LoopNet, where the Ten-X auction platform now runs: address, property type, size, auction close time, and on request the live starting bid, current bid, bid increment, reserve status and the listing brokers.

- **URL**: https://apify.com/parseforge/loopnet-auctions-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** Real estate, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.45 / 1,000 commercial auctions

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#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

[![ParseForge](https://raw.githubusercontent.com/ParseForge/apify-assets/main/banner.jpg)](https://apify.com/parseforge?fpr=vmoqkp)

### LoopNet Auctions Scraper - CRE Auction Listings & Bids

**Scrape every commercial real estate auction running on LoopNet, with the live bidding, not just the listing.** Each row carries the property, address, type, size and the exact auction close time, and on request the starting bid, current bid, bid increment, reserve status, view count and the brokers with their direct numbers. No login, no API key. Export to CSV, JSON, Excel or XML.

Ten-X, the online CRE auction platform, moved its auctions onto LoopNet. `ten-x.com/commercial/properties/` no longer exists: it answers 503 at the edge, to a real browser as much as to a script, because the section is gone rather than blocked. The auctions themselves are alive and running at `loopnet.com/search/commercial-real-estate/usa/auctions/`, and that is what this Actor reads.

| Who uses it | What they scrape LoopNet auctions for |
|---|---|
| CRE investors and funds | Every asset going to auction this month, with the bid where it stands right now |
| Distressed and special situations desks | Reserve-not-met sales and the increments they are moving in |
| Brokers | What competing assets in their market are closing at, and who is listing them |
| Appraisers and analysts | Live auction comps by property type and state |
| Lenders and servicers | Collateral coming to market, filtered to a state and a price band |

### What it does

This Actor walks LoopNet's auction search and returns one flat row per auction. Every row carries:

- 🏢 **Property:** name, property type, street, city, state, postal code, country, and the size with its unit (square feet or acres).
- ⏰ **The auction:** the exact close time as LoopNet's own countdown states it, availability, and the current bid where LoopNet publishes one on the search page.
- 🔗 **Links:** the listing URL and the search it came from, plus the hero image.
- 💰 **Optional live economics:** starting bid, current bid, bid increment, sale status, reserve status and total views, read from the auction banner on the listing itself.
- 👤 **Optional brokers:** the listing agents and their direct phone numbers.
- 📄 **Optional:** the full marketing description, LoopNet's own category path, and the raw structured record.

Results export to CSV, JSON, Excel or XML, or stream from the API.

### What you can do with LoopNet auction data

**⏱️ Watch a sale as it moves.**

Run on a schedule with `includeAuctionDetail` and every row carries the current bid, the increment and whether the reserve has been met, timestamped.

**📍 Cover one state.**

Set `locations` to `["ny"]` or `["tx"]` and get every auction in that state. A location can also be a city, as `los-angeles-ca`.

**🏗️ Filter to a property type and a price band.**

`propertyTypes` plus `minCurrentBidUsd` and `maxCurrentBidUsd` narrow to, say, multifamily above two million.

**📅 Take only what closes this month.**

`endsAfter` and `endsBefore` cut the list to a window.

### Why choose this scraper

| | What you get |
|---|---|
| **The auction, not the listing** | Every other LoopNet Actor on the Store returns listings. This one returns the sale: starting bid, current bid, bid increment, reserve status and the exact close time, read from the auction banner. |
| **Where Ten-X actually went** | If you came looking for a Ten-X scraper, this is the same inventory. Ten-X auctions are on LoopNet now and the old commercial listing paths are gone. |
| **The close time is right** | The banner carries two identical countdowns, one for the start of the sale and one for its end, and Angular hides the one that does not apply. Reading the first one on the page returns the start dressed as the end. This reads the visible one, and the timestamp attribute rather than a clock that is ticking while the page parses. |
| **It knows when the list ends** | LoopNet does not 404 a page past the last result, it serves page one again. The run detects the repeat and stops instead of billing you for the same 43 rows four times. |
| **No proxy** | Measured from the Apify container: a real browser is served without any proxy, eight pages out of eight in one session. That saving is in the price. |
| **Optional blocks, billed only when they return** | Auction detail, brokers, description and category path are each a checkbox. Untouched blocks are neither fetched nor billed. |

### How it compares

| Feature | ParseForge LoopNet Auctions | memo23/loopnet-scraper-ppe | piotrv1001/loopnet-listings-scraper | crawlerbros/loopnet-scraper |
|---|---|---|---|---|
| Auction search as the target | Yes | No | No | No |
| Current bid, starting bid, increment | Yes | No | No | No |
| Reserve status and sale status | Yes | No | No | No |
| Exact auction close time | Yes | No | No | No |
| Broker names and phones | Yes | Partial | Partial | Partial |
| Stops when paging wraps | Yes | Unknown | Unknown | Unknown |
| Price per row | $0.005 | $0.0015 | $0.002 | Per start |

The listings Actors are cheaper per row and they should be: a listing row is a listing row. What you are paying the difference for here is the auction state, which none of them carry.

### What a LoopNet auction looks like

```json
{
  "rowType": "auction",
  "listingId": "41178250",
  "name": "7901 Beverly Blvd",
  "propertyType": "Land",
  "street": "7901 Beverly Blvd",
  "city": "Los Angeles",
  "state": "CA",
  "postalCode": "90048",
  "country": "US",
  "currentBidUsd": 7000000,
  "currency": "USD",
  "availability": "InStock",
  "auctionEndsAt": "2026-09-02T16:35:28-04:00",
  "summary": "Favorable Zoning | Coveted Central LA Lot. Auction ends 09/02/2026 16:35:28 -04:00. Current bid $7000000",
  "sizeValue": "066",
  "sizeUnit": "AC",
  "startingBidUsd": "Not Disclosed",
  "bidIncrementUsd": 500000,
  "auctionStatus": "In Progress",
  "reserveStatus": "Reserve Not Met",
  "totalViews": 711865,
  "brokers": [{ "name": "Jeff Gray", "phone": "3108746920" }],
  "listingUrl": "https://www.loopnet.com/Listing/7901-Beverly-Blvd-Los-Angeles-CA/41178250/",
  "scrapedAt": "2026-09-02T20:34:31.000Z"
}
```

A field the source does not publish comes back as `Not Disclosed`, never as `null` and never missing.

**One thing to know about `currentBidUsd` on the search page.** LoopNet publishes a bid in the search results for only a handful of auctions: measured, 1 in 43. The bid is on the listing page, which is why `includeAuctionDetail` exists and why the auction fields are worth the extra page open.

### Configure the run

| Input | What it does |
|---|---|
| `locations` | LoopNet location slugs: `usa`, a state code such as `ny`, or a city such as `los-angeles-ca`. |
| `maxPagesPerSearch` | Pages per location. The run stops earlier when LoopNet repeats page one. |
| `maxItems` | Stop after this many auctions. |
| `searchUrls` | Full LoopNet search URLs, to carry over filters set in LoopNet's own interface. |
| `propertyTypes`, `states` | Client side filters on the returned rows. |
| `minCurrentBidUsd`, `maxCurrentBidUsd` | Bid band. Note that auctions with no published bid are dropped by these. |
| `endsAfter`, `endsBefore` | ISO dates for the auction close. |
| `includeAuctionDetail`, `includeBrokers`, `includeFullDescription`, `includeBreadcrumb`, `includeRawJsonLd` | The optional blocks. The first four open the listing page. |
| `proxyMode`, `countryCode` | Off by default, measured. |
| `pagesPerSession`, `maxBrowsers` | How many pages a browser walks, and the ceiling on browser launches. |

### Pricing

Pay per event.

| Event | What it is |
|---|---|
| Auction | One auction row. This is the price you compare. |
| Search page read | One results page that produced at least one row you kept. |
| Browser session | One real browser opened and warmed through the site defence. LoopNet refuses a plain HTTP client outright, so this is the actual cost of reading it at all, billed once per launch rather than hidden inside every row. |
| Listing page opened | One listing page opened, which is what the optional blocks need. |
| Live auction economics, Brokers, Full description, Category path | One per optional block, charged only when that block returned something. |

### Free users

Apify free plan runs are capped at 10 rows. Paid plans run to `maxItems`.

### Run it

```json
{
  "locations": ["usa"],
  "maxPagesPerSearch": 4,
  "includeAuctionDetail": true,
  "includeBrokers": true,
  "maxItems": 150
}
```

That is the whole national auction book: LoopNet listed 139 open commercial auctions when this was measured.

### Use with AI agents (MCP)

The Actor is exposed over Apify's MCP server, so an agent can ask for, say, every multifamily auction in Texas closing this month with the bid where it stands, and get structured rows back.

### Troubleshooting

**Zero rows.** The site refuses plain HTTP clients and needs the real browser this Actor already uses. If a run comes back empty, raise `maxBrowsers`: the run is allowed to replace a blocked browser, but only up to that ceiling.

**Fewer rows than `maxItems`.** The national auction book is small, around 139 open sales. A state search is smaller still. The log prints the total LoopNet reports.

**`startingBidUsd` is empty.** LoopNet hides the panels that do not apply, and a sale that has already taken a bid stops showing a starting bid. The row says `Not Disclosed` rather than guessing.

### FAQ

**Is this Ten-X?** Yes, the same auctions. Ten-X moved its commercial auctions to LoopNet; the old `ten-x.com` listing paths are gone and answer 503.

**How many auctions are there?** 139 open across the United States when this was measured. It moves with the sale calendar.

**Can I watch one auction?** Put its listing URL in `searchUrls`, or filter by `states` and `propertyTypes` and schedule the run.

**Does it need a proxy?** No. Measured: no proxy, eight pages out of eight in one browser session.

### Related actors

- [BigIron Auction Scraper](https://apify.com/parseforge/bigiron-auctions-scraper?fpr=vmoqkp)
- [Florida RealForeclose Auctions Scraper](https://apify.com/parseforge/florida-realforeclose-auctions-scraper?fpr=vmoqkp)
- [DealStream Listings Scraper](https://apify.com/parseforge/dealstream-listings-scraper?fpr=vmoqkp)

# Actor input Schema

## `locations` (type: `array`):

LoopNet location slugs to read the auction search for: "usa" for the whole country, a state code such as "ny" or "tx", or a city such as "los-angeles-ca". One search is walked per entry.

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

How many result pages to walk per location. The run stops earlier on its own when LoopNet starts repeating page one, which is how it signals the end of the list.

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

Stop after this many auctions.

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

Full LoopNet search URLs to read instead of building them from the locations above. Use this to carry over filters you set in LoopNet's own interface.

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

Keep only these property types, matched as a substring: Land, Office, Multifamily, Industrial, Retail, Hospitality, Specialty.

## `states` (type: `array`):

Keep only auctions in these two letter state codes, for example CA, NY, TX.

## `minCurrentBidUsd` (type: `integer`):

Keep only auctions whose current bid is at least this. Note that most search results carry no bid until the sale opens, so this filter also drops those.

## `maxCurrentBidUsd` (type: `integer`):

Keep only auctions whose current bid is at most this.

## `endsAfter` (type: `string`):

ISO date, for example 2026-09-15.

## `endsBefore` (type: `string`):

ISO date, for example 2026-10-31.

## `includeAuctionDetail` (type: `boolean`):

Opens each listing and reads the auction banner: starting bid, current bid, bid increment, sale status, reserve status, total views and the exact close time. This is the block the search results cannot give you, and it is what separates an auction feed from a listings feed.

## `includeBrokers` (type: `boolean`):

The listing agents, with their direct phone numbers.

## `includeFullDescription` (type: `boolean`):

The complete marketing description from the listing page. The search result carries only a truncated line.

## `includeBreadcrumb` (type: `boolean`):

LoopNet's own category and geography path for the property.

## `includeRawJsonLd` (type: `boolean`):

LoopNet's own schema.org record for the listing, untouched, for fields this Actor does not map.

## `proxyMode` (type: `string`):

Measured from the Apify container: LoopNet serves a real browser with no proxy at all, eight pages out of eight in one session. Turn a proxy on only if a run starts getting blocked.

## `countryCode` (type: `string`):

Two letter country code used when a proxy is on.

## `pagesPerSession` (type: `integer`):

How many pages one browser walks before it is replaced. The measured session held at least eight without a challenge.

## `maxBrowsers` (type: `integer`):

The most browsers a run may open. Each launch is billed, so this is the ceiling on that part of the cost.

## Actor input object example

```json
{
  "locations": [
    "usa"
  ],
  "maxPagesPerSearch": 3,
  "maxItems": 20,
  "searchUrls": [],
  "propertyTypes": [],
  "states": [],
  "includeAuctionDetail": false,
  "includeBrokers": false,
  "includeFullDescription": false,
  "includeBreadcrumb": false,
  "includeRawJsonLd": false,
  "proxyMode": "none",
  "countryCode": "US",
  "pagesPerSession": 20,
  "maxBrowsers": 6
}
```

# Actor output Schema

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

No description

## `csv` (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 = {
    "locations": [
        "usa"
    ],
    "maxPagesPerSearch": 3,
    "maxItems": 20,
    "searchUrls": [],
    "propertyTypes": [],
    "states": [],
    "endsAfter": "",
    "endsBefore": ""
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/loopnet-auctions-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 = {
    "locations": ["usa"],
    "maxPagesPerSearch": 3,
    "maxItems": 20,
    "searchUrls": [],
    "propertyTypes": [],
    "states": [],
    "endsAfter": "",
    "endsBefore": "",
}

# Run the Actor and wait for it to finish
run = client.actor("parseforge/loopnet-auctions-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 '{
  "locations": [
    "usa"
  ],
  "maxPagesPerSearch": 3,
  "maxItems": 20,
  "searchUrls": [],
  "propertyTypes": [],
  "states": [],
  "endsAfter": "",
  "endsBefore": ""
}' |
apify call parseforge/loopnet-auctions-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,parseforge/loopnet-auctions-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/9ijkiautXGaN0XvZC/builds/Z1PNmDih7YeYKuvi4/openapi.json