# LoopNet Scraper - Commercial Real Estate, Spaces & Brokers (`topapi/loopnet-scraper`) Actor

Scrape LoopNet commercial real estate for sale, for lease or at auction by city, state or search link: price, cap rate, size, units, brokers, photos. Add the full listing page (facts, spaces with rent, broker phones, taxes) and LoopNet's broker directory with phones.

- **URL**: https://apify.com/topapi/loopnet-scraper.md
- **Developed by:** [Top Api](https://apify.com/topapi) (community)
- **Categories:** Real estate, Lead generation, Business
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.89 / 1,000 listings

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

## LoopNet Scraper - Commercial Real Estate, Spaces & Brokers

Scrape **LoopNet.com** commercial real estate **for sale, for lease and at auction** across the US: search by city, county,
state or a LoopNet search link, by property type, and get one clean row per listing with address, coordinates, property
type, price or asking rent, cap rate, building size, available space, lot size, units, year built, broker and brokerage,
and photos.

Turn on the **Full listing page** add-on for every property fact, **every available space with its rent**, all brokers
with **title and phone**, date on market, property taxes and parcel number, walk / transit / bike / drive scores, every
photo and the brochure. Pull LoopNet's **broker directory** by city or state (name, company, listing count, office and
mobile phone), and **property records** by street address (APN, land use, zoning, flood zone, census tract, 1/3/5-mile
demographics). **Monitor mode** returns only new listings and price changes on a schedule.

### What you can scrape

| Input | What you get | Charged as |
|---|---|---|
| **Locations** (`Dallas, TX`, `Dallas County, TX`, `TX`, `USA`) + search type + property type | listing rows from LoopNet's search | `listing` |
| **LoopNet links**: search pages (with the filters you set on loopnet.com), listing pages, broker pages, property-record pages | the same rows | per row type |
| **Listing ids** (`29122043`) | one row per listing, with the full listing page | `listing` + `listing-detail` |
| **Broker directory places** (`Houston, TX`, `TX`) | one row per broker | `broker` |
| **Property addresses** (`1221 N Pecan St, Abbott, TX 76621`) | one property-record row per address | `property-record` |

Search types: **for sale**, **for lease**, **auctions**. Property types: all commercial real estate, office, industrial,
retail, flex, land, multifamily, apartment buildings, hospitality, hotels, medical office, restaurant, coworking,
laboratories, warehouses, mixed use, shopping centers, self storage, mobile home parks, senior housing, health care,
specialty, auto shops, gas stations, car washes, churches, farms, residential income, commercial / industrial /
residential land, data centers, storefront, strip malls, showrooms, schools, day care and banks (types LoopNet only
lists for sale are skipped on a for-lease search, and coworking is for lease only).

### How to use

1. Type one or more **Locations** (one per line) and pick **Search type** and **Property type**, or paste **LoopNet links**.
2. Set **Max listings** (the most listing rows this run delivers and charges).
3. Optional: turn on **Full listing page**, set **Filters**, add **Broker directory** places or **Property addresses**.
4. Run. Each row appears in the dataset as it is read; export as JSON, CSV or Excel, or read it through the API.

LoopNet shows **at most 750 results per search** (30 pages of 25). For a bigger market, search several cities or
property types: each one is its own search with its own 750.

#### Example inputs

All office space for lease in two cities, with the full listing page:

```json
{
  "locations": ["Chicago, IL", "Los Angeles, CA"],
  "searchType": "for-lease",
  "propertyType": "office",
  "maxItems": 200,
  "includeListingDetails": true
}
```

Multifamily for sale in Texas at a 6%+ cap rate, under $5,000,000:

```json
{
  "locations": ["TX"],
  "searchType": "for-sale",
  "propertyType": "multifamily",
  "capRateMin": 6,
  "priceMax": 5000000,
  "maxItems": 500
}
```

A LoopNet search you filtered on the site, checked every morning for new listings and price changes:

```json
{
  "startUrls": [{ "url": "https://www.loopnet.com/search/retail-space/nashville-tn/for-lease/?sk=..." }],
  "maxItems": 0,
  "monitoringMode": true,
  "monitorName": "nashville-retail"
}
```

Brokers in Dallas with their bio and specialties, and two property records:

```json
{
  "brokerLocations": ["Dallas, TX"],
  "maxBrokers": 200,
  "includeBrokerDetails": true,
  "propertyAddresses": ["1221 N Pecan St, Abbott, TX 76621", "833 Texas St, Houston, TX 77002"]
}
```

### Input

| Field | Type | Description |
|---|---|---|
| `locations` | list | US places: `City, ST`, `County, ST`, a state (`TX` or `Texas`), `USA`, or a slug from a LoopNet link (`manhattan-ny`). |
| `searchType` | `for-sale` / `for-lease` / `auctions` | Default `for-sale`. |
| `propertyType` | select | Default `all` (all commercial real estate). |
| `startUrls` | list | LoopNet links: search pages (their `sk=` filters are kept), listing pages, broker directory pages, broker profiles, property-record pages. Listing ids work too. |
| `maxItems` | number | The most listing rows this run delivers and charges, over all searches. `0` = no limit. Default 100. |
| `includeListingDetails` | yes/no | The Full listing page add-on (below). |
| `priceMin` / `priceMax` | number | Sale price, or asking rent on a for-lease search. |
| `sizeMin` / `sizeMax` | number | Building size in SF (largest available space on lease listings). |
| `capRateMin` / `capRateMax` | number | Cap rate in %. |
| `yearBuiltMin` / `yearBuiltMax` | number | Year built. |
| `unitsMin` / `unitsMax` | number | Unit count (multifamily). |
| `listedInLastDays` | number | Listed in the last N days (uses the date on market from the listing page: turn the Full listing page on). |
| `keywords` / `excludeKeywords` | list | Keep / drop listings whose title, address, summary or description holds a word (`NNN`, `drive-thru`). |
| `strictFilters` | yes/no | Off: a listing that states no value for a filter is kept and names the filter in `unverifiedFilters`. On: dropped. |
| `excludePortfolios` | yes/no | Drop listings that sell several properties together. |
| `onlyWithPrice` | yes/no | Drop "Price Upon Request" listings. |
| `brokerLocations` | list | LoopNet broker directory for a city (`Dallas, TX`) or a state (`TX`). |
| `maxBrokers` | number | The most broker rows this run delivers and charges. Default 100. |
| `includeBrokerDetails` | yes/no | Adds each broker's bio, specialties, property types, markets, education and company website (part of the broker price). |
| `propertyAddresses` | list | US street addresses with city and state; each returns one property record. |
| `listingIds` | list | LoopNet listing ids (the number at the end of a listing link). |
| `monitoringMode` | yes/no | Only new listings and price changes since the last run with the same input (or `monitorName`). |
| `monitorName` | text | Runs with the same name share one memory. |
| `emitUnchanged` | yes/no | In monitor mode, also deliver unchanged listings (charged). |
| `resetMonitor` | yes/no | Forget what earlier runs delivered. |
| `maxItemsPerSearch` | number | A per-search limit on top of `maxItems`. |
| `maxPagesPerSearch` | number | Result pages read per search (25 listings each, up to 30). |
| `maxConcurrency` | number | Pages read at once. Default 8. |
| `proxyConfiguration` | proxy | Leave as is (see "Reliability"). |

Field names used by other LoopNet actors are accepted too (`startUrl`, `searchUrls`, `fetchFullDetails`, `fetchDetails`,
`monitorMode`, `PriceMin`, `CapRateMin`, `BuildingSizeRangeMin`, `YearBuiltMin`, `UnitCountMin`, `State` + `City`,
`addresses`, `dbState` + `dbCity`, `property_inputs`, `search_inputs`, ...), so an existing input can be pasted as is.

### Output

Every row has `recordType`: `listing`, `broker` or `property`. The dataset has three views: **Listings**, **Brokers** and
**Property records**.

#### Listing rows

Fill rates measured on real runs (1,200 Dallas + Houston listings for sale; 1,000 Los Angeles + Chicago listings for
lease with the full listing page; 1,000 Houston + Phoenix listings for sale with the full listing page). Lower numbers are
LoopNet not stating the value, not a missing read.

| Field | Fill | Description |
|---|---|---|
| `listingId`, `url`, `title`, `address`, `fullAddress` | 100% | LoopNet listing id, link, name (or address), street, one-line address |
| `city`, `state`, `zip` | 95-100% | Portfolio cards carry no city line |
| `latitude`, `longitude` | 95-100% | Coordinates |
| `searchType`, `listingType`, `isAuction` | 100% | for-sale / for-lease / auctions; LoopNet's listing type (PropertyForSale, PropertyDirectSpaceForLease, LandForSale...) |
| `propertyType`, `propertyTypeText`, `spaceUse` | 92-100% | Office, Retail, Industrial, Multifamily, Land...; the card's type line; space use on lease listings |
| `price`, `priceText`, `priceUnit`, `priceMax` | 78-96% | Sale price (USD) or asking rent; as shown ($30.00 SF/YR, Price Upon Request); rent unit; range top |
| `capRate` | 17-25% | Cap rate % (stated on investment listings) |
| `buildingSizeSf`, `spaceAvailableText`, `lotSizeAcres`, `units`, `yearBuilt` | as stated | Building SF, available space range, acres, units, year built |
| `brokerName`, `brokerNames`, `brokerCompany` | 94-100% | Listing broker(s) and brokerage |
| `imageUrl`, `images`, `imageCount` | 100% | Photos on the card |
| `summary`, `shortDescription` | 95-100% | Card summary and LoopNet's one-line description |
| `propertyId`, `marketId`, `exposureLevel`, `isPortfolio`, `startingBid`, `auctionEndsAt` | | LoopNet property id, market id, placement tier, portfolio flag, auction terms |
| `searchLabel`, `searchUrl`, `searchTotal`, `page`, `position`, `scrapedAt` | 100% | Where the row came from |

#### Full listing page add-on (`includeListingDetails`)

| Field | Fill (lease / sale) | Description |
|---|---|---|
| `description`, `descriptionSections`, `highlights`, `amenities` | 83 / 92%, 79 / 86%, 50 / 56% | Property overview / executive summary, highlights, amenities |
| `facts` | 99 / 100% | Every property fact as LoopNet lists it (label -> value) |
| `buildingClass`, `propertySubType`, `saleType`, `stories`, `yearRenovated`, `zoning`, `tenancy`, `parkingRatio`, `typicalFloorSize`, `ceilingHeight` | as stated | The main facts as their own columns |
| `askingPrice`, `pricePerSf`, `pricePerUnit`, `noi`, `occupancyPercent`, `grossRentMultiplier` | as stated | Sale terms |
| `spaces` | 65% of lease listings | Every available space: name, size, term, rent per SF per year and per month, rent per year and per month, space use, build-out, availability |
| `brokers` | 100% | Every broker: name, title, company, phone, city, state, broker id, profile link, photo |
| `brokerPhone`, `contactPhone` | 99% | First broker's phone; the listing's call number |
| `dateOnMarket`, `dateModified` | 100% | Date on market, last modified |
| `propertyTaxes`, `parcelNumber` | 80% / 65% of sale listings | Parcel number, land / improvements / total assessment, annual taxes, tax year |
| `walkScore`, `transitScore`, `bikeScore`, `driveScore` (+ labels) | 88-100% | Local Logic scores 0-100 |
| `photos`, `photoCount`, `hasVideo`, `hasVirtualTour` | 100% | Every listing photo, video and 3D tour flags |
| `attachments`, `brochureUrl` | 70-76%, 64-69% | Brochures and links |
| `financialsMasked` | 100% | `true` when LoopNet shows the financial summary to signed-in visitors only (its numbers are not delivered) |

Real row (Phoenix land for sale, with the full listing page; arrays shortened):

```json
{
  "recordType": "listing",
  "listingId": "30541074",
  "url": "https://www.loopnet.com/Listing/10444-N-Cave-Creek-Rd-Phoenix-AZ/30541074/",
  "searchType": "for-sale",
  "listingType": "LandForSale",
  "title": "Valle View at the Pointe",
  "address": "10444 N Cave Creek Rd",
  "city": "Phoenix",
  "state": "AZ",
  "zip": "85020",
  "latitude": 33.582014,
  "longitude": -112.052446,
  "propertyType": "Land",
  "priceText": "Price Upon Request",
  "lotSizeAcres": 4.76,
  "brokerName": "Matt Gehrke",
  "brokerCompany": "Allante Corp.",
  "facts": { "Sale Type": "Investment", "Property Subtype": "Residential", "Proposed Use": "Commercial, Multifamily, Apartment Units", "Total Lot Size": "4.76 AC" },
  "saleType": "Investment",
  "brokers": [{ "name": "Matt Gehrke", "company": "Allante Corp.", "phone": "(480) 479-9500", "brokerId": "e585skqb", "profileUrl": "https://www.loopnet.com/commercial-real-estate-brokers/profile/matt-gehrke/e585skqb" }],
  "brokerPhone": "(480) 479-9500",
  "dateOnMarket": "1/5/2024",
  "walkScore": 20,
  "transitScore": 30,
  "photoCount": 9,
  "detailsFetched": true
}
```

A lease listing's `spaces` (real, Los Angeles):

```json
[{ "name": "1st Floor, Ste 140", "size": "1,022 SF", "term": "Negotiable", "rentPerSfYear": 23.5, "rentPerSfMonth": 1.96,
   "rentPerYear": 24017, "rentPerMonth": 2001, "spaceUse": "Office", "buildOut": "Full Build-Out", "available": "Now" }]
```

#### Broker rows

Fill on 120 Texas brokers (directory) and 50 Houston brokers with the profile add-on.

| Field | Fill | Description |
|---|---|---|
| `brokerId`, `name`, `company`, `city`, `state`, `location`, `profileUrl`, `photoUrl`, `companyLogoUrl` | 100% | Who and where |
| `phone`, `officePhone`, `mobilePhone` | 100%, 100%, 18-19% | Phones as LoopNet lists them |
| `listingCount` | 98-99% | Active LoopNet listings |
| `headline`, `languages` | 59%, 53% | Title line, languages |
| `bio`, `specialties`, `propertyTypes`, `markets`, `education`, `companyWebsite` | 80%, 68%, 94%, 90%, 64%, 100% | With `includeBrokerDetails` |

```json
{
  "recordType": "broker",
  "brokerId": "kd4xw5cb",
  "name": "Brandon Levinson",
  "headline": "Vice President, Stream Realty Partners, LP",
  "company": "Stream Realty Partners, LP",
  "city": "Houston",
  "state": "TX",
  "listingCount": 15,
  "languages": ["English"],
  "phone": "(713) 300-0313",
  "officePhone": "(713) 300-0313",
  "profileUrl": "https://www.loopnet.com/commercial-real-estate-brokers/profile/brandon-levinson/kd4xw5cb",
  "specialties": "Investment Sales Broker, Landlord Rep, Landlord Rep (Flex), Landlord Rep (Industrial), Landlord Rep (Office), Landlord Rep (Retail)",
  "propertyTypes": "Industrial, Office, Retail",
  "markets": "Houston",
  "companyWebsite": "https://streamrealty.com/"
}
```

#### Property record rows

`propertyRecordId`, `url`, `address`, `city`, `state`, `zip`, `apn`, `legalDescription`, `landUse`, `county`, `floodZone`,
`zoning`, `lotSizeText`, `lotSizeAcres`, `totalSizeSf`, `taxYear`, `assessedYear`, `submarket`, `market`, `censusTract`,
`demographics` (1 / 3 / 5-mile population, growth, households, median household income, median home value, median year
built) and `propertyFacts` (every fact as LoopNet lists it). Real example: `1221 N Pecan St, Abbott, TX 76621` -> APN
108794, land use Commercialnec, Hill County, flood zone B and X, lot 3.03 AC, total size 145,588 SF, submarket Central
Texas Area, census 960700.

### Monitor mode

With `monitoringMode` on, the actor remembers every listing it delivers for this input (or `monitorName`). The next run
reads the same searches and delivers only:

- **NEW** listings it has not delivered before,
- **UPDATED** listings whose price changed (with `previousPrice`),
- **DETAILS**: a listing delivered earlier without the full listing page, when you now ask for it (charged the full
  listing page only, once).

Unchanged listings are not delivered or charged. A poll that finds nothing writes nothing and charges nothing. Measured:
a 73-listing search polled three times (search fields, then the full listing page, then again) delivered 73, then 73
(full listing page only), then 0.

### Pricing

Pay per event, no start fee:

| Event | Price | When |
|---|---|---|
| `listing` | **$0.00089** ($0.89 / 1,000) | each listing row |
| `listing-detail` | **$0.0018** | each listing row that carries the full listing page (a detailed listing is $0.00269 in all) |
| `broker` | **$0.0031** | each broker row |
| `property-record` | **$0.0012** | each property-record row |

You are charged only for rows delivered: never for duplicates, filtered rows, unchanged rows in monitor mode, listings
that could not be read, or the run summary. The run stops cleanly at your **maximum cost per run**, with every delivered
row charged once. Examples from real runs: 1,200 listings = $1.07; 1,000 detailed listings = $2.69; one listing = $0.00089.

### Reliability and speed

- The actor reads LoopNet's own pages (the same pages its website serves) with plain HTTP, on the run's own address. When
  an address is refused it moves to Apify datacenter, then Apify residential (US) proxies, and never re-sends a refused
  request through the same one. No login or cookies are needed.
- Speed: 1,000+ listings without the full listing page take about 10 seconds. The full listing page is one more page per
  listing: 1,000 detailed listings take about 2.5 minutes at 1 GB of memory and about 14 minutes at the default 256 MB, for
  the same cost. Raise the memory for big detailed runs.
- A restarted or migrated run continues where it stopped: rows already delivered are not delivered or charged again.
- Large runs and runs with a problem write a `RUN_SUMMARY` record to the key-value store (counts, searches, what was
  filtered, what could not be read).

### Limits

- LoopNet US (loopnet.com) only. LoopNet UK and Canada (loopnet.co.uk, loopnet.ca) are not read.
- At most 750 results per search (LoopNet's own ceiling): split big markets by city or property type.
- Filters you set on loopnet.com are kept when you paste the search link. The actor's own filters (price, size, cap rate,
  year built, units, keywords, date) are checked on each listing before it is delivered.
- ZIP codes are not a LoopNet search location: use the city, or paste a LoopNet search link.
- A listing's financial summary (income, expenses, NOI) is shown to signed-in visitors only; it is not delivered and
  `financialsMasked` says when a listing has one.
- LoopNet's results are sorted by its own "Recommended" order (premium listings first).
- Broker emails are a contact form on LoopNet, not an address, so they are not delivered.

# Actor input Schema

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

US places to search, one per line: a city with its state ("Dallas, TX"), a county ("Dallas County, TX"), a neighborhood slug from a LoopNet link ("manhattan-ny"), a state ("TX" or "Texas") or "USA". Each place is searched once per search type and property type below.

## `searchType` (type: `string`):

For sale, for lease or at auction. Other LoopNet actors' values (For_Lease, sale, lease, office-space...) are understood too.

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

LoopNet's property type. Types LoopNet only lists for sale (multifamily, hotels...) are skipped on a for-lease search; coworking is for lease only. Other LoopNet actors' values (For_Lease, sale, lease, office-space...) are understood too.

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

Links copied from loopnet.com: a search results page (filters you set on the site, kept in its sk= key, are kept), a listing page, a broker directory page or a broker profile. Plain listing ids work too.

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

The most listing rows this run delivers and charges, over all searches. 0 = no limit. LoopNet shows at most 750 results per search: split a big market by city or property type for more.

## `includeListingDetails` (type: `boolean`):

Reads each delivered listing's own page and adds: the full description and highlights, every property fact (class, year built and renovated, stories, lot, zoning, parking, ceiling height...), every available space with its size, term and rent, all brokers with title, phone and profile, the listing phone, date on market, property taxes and parcel number, walk / transit / bike / drive scores, every photo, the brochure and attachments. Charged per listing that carries it.

## `priceMin` (type: `integer`):

Sale price, or the asking rent on a for-lease search. Checked on each listing before it is delivered or charged.

## `priceMax` (type: `integer`):

Sale price, or the asking rent on a for-lease search.

## `sizeMin` (type: `integer`):

Building size, or the largest available space on a for-lease listing.

## `sizeMax` (type: `integer`):

Building size, or the largest available space.

## `capRateMin` (type: `number`):

For example 6 or 6.5.

## `capRateMax` (type: `number`):

For example 9.

## `yearBuiltMin` (type: `integer`):

Year built, as LoopNet states it.

## `yearBuiltMax` (type: `integer`):

Year built, as LoopNet states it.

## `unitsMin` (type: `integer`):

Unit count (multifamily).

## `unitsMax` (type: `integer`):

Unit count (multifamily).

## `listedInLastDays` (type: `integer`):

Keep listings put on the market in the last N days. The date on market is on the listing page, so this filter works with the Full listing page add-on on. 0 = off.

## `keywords` (type: `array`):

Keep only listings whose title, address, summary or description holds one of these words (for example "drive-thru", "NNN").

## `excludeKeywords` (type: `array`):

Drop listings holding any of these words.

## `strictFilters` (type: `boolean`):

Off: a listing that states no value for a filter (most lease listings state no cap rate) is kept and lists the filter in unverifiedFilters. On: it is dropped.

## `excludePortfolios` (type: `boolean`):

Drop listings that sell several properties together.

## `onlyWithPrice` (type: `boolean`):

Drop "Price Upon Request" listings.

## `brokerLocations` (type: `array`):

LoopNet's broker directory for a city ("Dallas, TX") or a state ("TX"): one row per broker with name, company, title line, location, listing count, languages, office and mobile phone, photo and profile link.

## `maxBrokers` (type: `integer`):

The most broker rows this run delivers and charges. 0 = no limit.

## `includeBrokerDetails` (type: `boolean`):

Reads each broker's profile page and adds the bio, specialties, property types, markets, education and company website. Part of the broker row price.

## `propertyAddresses` (type: `array`):

US street addresses ("1221 N Pecan St, Abbott, TX 76621"). Each is looked up in LoopNet's property records and returns one row: APN / parcel id, legal description, land use, county, flood zone, zoning, lot and building size, tax and assessment years, submarket, census tract and the 1 / 3 / 5-mile demographics. LoopNet property-record links (loopnet.com/property/...) work in LoopNet links too.

## `listingIds` (type: `array`):

LoopNet listing ids (the number at the end of a listing link). Each is read from its own page, with the full listing page included.

## `monitoringMode` (type: `boolean`):

Remembers every listing delivered for this input. Later runs deliver only listings that are new or whose price changed (changeType NEW / UPDATED), so a schedule charges only for what changed.

## `monitorName` (type: `string`):

Optional. Runs with the same name share one memory; empty = one memory per input.

## `emitUnchanged` (type: `boolean`):

In monitor mode, also deliver (and charge) listings that did not change (changeType UNCHANGED).

## `resetMonitor` (type: `boolean`):

Forget what earlier runs delivered for this input.

## `maxItemsPerSearch` (type: `integer`):

A per-search limit on top of Max listings. 0 = none.

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

LoopNet result pages (25 listings each) read per search, up to 30. 0 = all.

## `maxConcurrency` (type: `integer`):

Pages read at once.

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

Leave as is: the actor reads LoopNet on its own address and moves to Apify datacenter, then Apify residential (US) proxies only when an address is refused. Choose proxy groups or your own proxy URLs to read through them first.

## Actor input object example

```json
{
  "locations": [
    "Dallas, TX"
  ],
  "searchType": "for-sale",
  "propertyType": "all",
  "maxItems": 20,
  "includeListingDetails": false,
  "listedInLastDays": 0,
  "strictFilters": false,
  "excludePortfolios": false,
  "onlyWithPrice": false,
  "maxBrokers": 100,
  "includeBrokerDetails": false,
  "monitoringMode": false,
  "emitUnchanged": false,
  "resetMonitor": false,
  "maxItemsPerSearch": 0,
  "maxPagesPerSearch": 0,
  "maxConcurrency": 8,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `listings` (type: `string`):

Listing rows (search fields; the full listing page when asked).

## `brokers` (type: `string`):

No description

## `results` (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": [
        "Dallas, TX"
    ],
    "maxItems": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("topapi/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 = {
    "locations": ["Dallas, TX"],
    "maxItems": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("topapi/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 '{
  "locations": [
    "Dallas, TX"
  ],
  "maxItems": 20
}' |
apify call topapi/loopnet-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,topapi/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/9fRmyeDSUupbYHUHa/builds/3UyLxIwDcVtn5hopz/openapi.json
