# LoopNet API — Commercial Real Estate Listings & Site Data (`sian.agency/loopnet-property-scraper`) Actor

LoopNet API for commercial real estate — search offices, industrial, retail, multifamily and land by location, ZIP or polygon. Dossiers with broker phones, owner info and traffic counts. For CRE investors and brokers. Independent, not affiliated with LoopNet or CoStar.

- **URL**: https://apify.com/sian.agency/loopnet-property-scraper.md
- **Developed by:** [SIÁN OÜ](https://apify.com/sian.agency) (community)
- **Categories:** Real estate, Lead generation, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.90 / 1,000 listing extracteds

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/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 API — Commercial Real Estate Listings, Broker & Site Data 🏢

[![SIÁN Agency Store](https://img.shields.io/badge/Store-SI%C3%81N%20Agency-1AE392)](https://apify.com/sian.agency?fpr=sian) [![Store-Zillow Agent Scraper](https://img.shields.io/badge/Store-Zillow%20Agent%20Scraper-1F4E79)](https://apify.com/sian.agency/zillow-agent-scraper?fpr=sian) [![Store-Property Skip Tracing](https://img.shields.io/badge/Store-Property%20Skip%20Tracing-1AE392)](https://apify.com/sian.agency/property-skip-tracing?fpr=sian) [![Store-Redfin Property Scraper](https://img.shields.io/badge/Store-Redfin%20Property%20Scraper-A02021)](https://apify.com/sian.agency/redfin-property-scraper?fpr=sian)

#### 🏢 Search commercial real estate 5 ways, then pull broker phone numbers, traffic counts and walk/transit scores no other scraper exposes

##### Built for CRE investors, brokers and site-selection analysts — not homebuyers

### 📋 Overview

**Stop guessing at commercial deals from a listing photo and a price string.** This actor searches
commercial real estate by location, ZIP, coordinates, drawn polygon or a pasted search URL, then pulls
the full listing dossier — broker names, titles and direct phone numbers, the property owner's
identity, annual average daily traffic counts by cross-street, and walk/transit/bike/drive scores.

**Why CRE professionals choose this actor:**

- ✅ **5 search inputs, 1 actor**: location, ZIP, coordinates, drawn polygon or a pasted search URL — all sharing the same full commercial filter set
- 🎯 **Site-selection intelligence**: traffic counts by cross-street and walk/transit/bike/drive scores that LoopNet's own site doesn't surface without a login
- 📞 **Direct broker contacts**: name, title, phone number and brokerage company on every dossier
- 💰 **Cheapest credible pricing in the field**: $0.0018/listing, $0.006/dossier — undercuts every competitor that actually converts users
- 🆓 **Free utility ops**: location autocomplete and the full property-type/subtype taxonomy (US, Canada, UK, France, Spain, Australia), no charge
- ✨ **Every commercial property type**: office, industrial, retail, restaurant, shopping center, multifamily, specialty, health care, hospitality, sports & entertainment, lab, land, residential income, flex — for-lease, for-sale or auction

### ✨ Features

- 🔎 **5 location-input search modes**: free-text location, ZIP code, lat/lng + radius, a drawn polygon area, or paste a LoopNet search URL
- 🏷 **Full commercial filter set**: property type/subtype, price range, lease-rate range, building/space/lot-size ranges, cap-rate range, year-built range, sort order, keywords
- 🚩 **Deal-flag filters**: sublease-only, net-leased (NNN), distressed/value-add, Opportunity Zone
- 📞 **Rich listing dossiers**: broker phone numbers, owner identity and bio, available-spaces breakdown per suite, building facts, photo gallery
- 🚦 **Traffic-count data**: annual average daily traffic (AADT) by nearby cross-street — a site-selection signal no other LoopNet scraper on Apify exposes
- 🚶 **Walk/transit/bike/drive scores**: with human-readable labels, straight from the dossier
- 🌍 **Property-type taxonomy lookup**: the full type/subtype tree for US, Canada, UK, France, Spain and Australia — free
- 🔍 **Location autocomplete**: type-ahead suggestions for building a search UI — free
- 📄 **Clean HTML run summary**: property-type, building-class and exposure-tier breakdowns plus a parsed price distribution

### 🎬 Quick Start

Pick an operation (`search`, `detail`, `autocomplete` or `propertytypes`), fill in its inputs, and run.
A default `search` run returns clean commercial listings for Los Angeles, CA in seconds.

```bash
curl -X POST https://api.apify.com/v2/acts/sian.agency~loopnet-property-scraper/runs?token=YOUR_TOKEN \
-d '{"mode": "search", "locationMode": "bylocation", "location": "Los Angeles, CA", "searchType": "For_Lease"}'
```

### 🚀 Getting Started (3 Simple Steps)

#### Step 1: Pick an operation

Choose `search` to find listings, or `detail` to pull a full dossier for one listing by id or URL.

#### Step 2: Fill in the inputs for that operation

For `search`, pick a location input type and set your filters (property type, price, cap rate, etc.).
For `detail`, paste a listing id or URL from a search result.

#### Step 3: Run the actor

Click Start (or call the API). Results land in the dataset as they're found.

**That's it! In under a minute, you'll have:**

- Clean, structured commercial listing or dossier data
- Broker contacts and traffic/walkability signals (detail mode)
- A downloadable JSON/CSV/Excel dataset

### 📥 Input Configuration

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `mode` | string | No | `search` (default), `detail`, `autocomplete`, or `propertytypes` |
| `locationMode` | string | No | search only — `bylocation` (default), `bycoordinates`, `bypolygon`, `byzip`, `byurl` |
| `location` | string | No | search + bylocation — free-text city/county/ZIP/address |
| `latitude` / `longitude` / `radiusMiles` | number | No | search + bycoordinates |
| `polygonCoords` | array | No | search + bypolygon (PAID) — array of `[lng, lat]` pairs |
| `zipCode` | string | No | search + byzip |
| `searchUrl` | string | No | search + byurl — a loopnet.com search-results URL |
| `searchType` | string | No | `For_Lease` (default), `For_Sale`, `Auctions` |
| `propertyType` / `propertySubType` | string | No | commercial property type/subtype filter |
| `priceRange` / `leaseRateRange` / `buildingSizeRange` / `spaceSizeRange` / `lotSizeRange` / `capRateRange` / `yearBuiltRange` | string | No | e.g. `"min:1000000,max:10000000"` |
| `sortOrder` | string | No | result ordering |
| `subLease` / `netLeased` / `distressed` / `opportunityZone` | boolean | No | deal-flag filters |
| `maxResultsPerQuery` | integer | No | cap on listings returned (default 40; FREE tier capped at 25) |
| `listingId` / `listingUrl` | string | No | detail mode |
| `autocompleteTerm` | string | No | autocomplete mode |
| `taxonomyCountry` | string | No | propertytypes mode — `USA` (default), `CAN`, `GBR`, `FRA`, `ESP`, `AUS` |

**Example — search by location:**

```json
{
  "mode": "search",
  "locationMode": "bylocation",
  "location": "Austin, TX",
  "searchType": "For_Sale",
  "propertyType": "Industrial",
  "capRateRange": "min:6,max:10"
}
```

**Example — full dossier by listing id:**

```json
{
  "mode": "detail",
  "listingId": "29122043"
}
```

### 📤 Output

Results are saved to the Apify dataset with fields that vary by operation:

| Field | Type | Description |
|-------|------|--------------|
| `listingId` | string | LoopNet listing id |
| `address` / `cityState` | string | Property location |
| `price` | string | Listing price or lease rate as displayed |
| `propertyType` / `buildingClass` | string | Property classification |
| `brokers` | array | Broker name(s), company, and — on detail rows — direct phone |
| `trafficCounts` | array | AADT by nearby cross-street (detail rows) |
| `walkScore` / `transitScore` / `bikeScore` / `driveScore` | number | 0-100 scores (detail rows) |
| `ownerName` / `ownerDescription` | string | Property owner identity (detail rows) |
| `availableSpaces` | array | Per-suite size/term/rate breakdown (detail rows) |
| `url` | string | Direct LoopNet listing URL |

**Example (search row):**

```json
{
  "mode": "search",
  "listingId": "29122043",
  "address": "11340 W Olympic Blvd",
  "cityState": "Los Angeles, CA",
  "price": "$3.45 /SF/MO",
  "propertyType": "Office",
  "buildingClass": "A",
  "searchType": "For_Lease",
  "brokers": [{ "name": "Keith Fielding", "company": "Lee & Associates - West LA" }],
  "url": "https://www.loopnet.com/Listing/11340-W-Olympic-Blvd-Los-Angeles-CA/29122043/"
}
```

### 💼 Use Cases & Examples

#### 1. Commercial site-selection research

**A retail chain's real estate team evaluating candidate sites before committing to a lease.**
**Input:** `detail` mode with a shortlist of listing ids · **Output:** traffic counts and walk/transit/bike/drive scores per site · **Use:** rank candidate locations by foot/vehicle traffic before a broker call.

#### 2. CRE investor deal sourcing

**An investor screening industrial properties for cap rate and building size.**
**Input:** `search` mode with `propertyType`, `capRateRange`, `buildingSizeRange` · **Output:** a filtered list of matching listings · **Use:** build a weekly deal-flow pipeline without manually paging through LoopNet.

#### 3. Broker contact list building

**A CRE data vendor building a broker outreach list by market.**
**Input:** `search` a market, then `detail` on each result · **Output:** broker name, title, phone and brokerage company per listing · **Use:** populate a CRM with verified broker contacts.

#### 4. Market inventory tracking by property type

**An analyst tracking office and lab space availability quarter over quarter.**
**Input:** `search` with `propertyType` and `searchType` · **Output:** current inventory counts and pricing by type · **Use:** feed a recurring market report.

#### 5. Building a commercial listings feed

**A CRE platform syndicating listings into its own product.**
**Input:** scheduled `search` runs across target markets · **Output:** a clean JSON feed of active listings · **Use:** power a search UI or alert system without scraping LoopNet directly.

### 🔗 Integration Examples

#### JavaScript/Node.js

```javascript
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: 'YOUR_TOKEN' });

const run = await client.actor('sian.agency/loopnet-property-scraper').call({
  mode: 'search',
  locationMode: 'bylocation',
  location: 'Los Angeles, CA'
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items[0]);
```

#### Python

```python
from apify_client import ApifyClient
client = ApifyClient('YOUR_TOKEN')

run = client.actor('sian.agency/loopnet-property-scraper').call(
    run_input={'mode': 'search', 'locationMode': 'bylocation', 'location': 'Los Angeles, CA'}
)

for item in client.dataset(run['defaultDatasetId']).iterate_items():
    print(item)
```

#### cURL

```bash
curl -X POST 'https://api.apify.com/v2/acts/sian.agency~loopnet-property-scraper/runs?token=YOUR_TOKEN' \
-H 'Content-Type: application/json' \
-d '{"mode": "search", "locationMode": "bylocation", "location": "Los Angeles, CA"}'
```

#### Automation Workflows

1. **Trigger**: schedule a recurring market check
2. **HTTP Request**: call this actor's API with your saved filters
3. **Process**: handle the returned JSON listings/dossiers
4. **Action**: sync to your CRM, alert on new inventory, or refresh a dashboard

### 📊 Performance & Pricing

#### FREE Tier (Try It Now)

- **25 results** per run — full feature access, same data quality
- No credit card required
- Perfect for testing filters before a production run

#### PAID Tier (Production Ready)

- **Unlimited** results per run
- Pay-per-result: only charged for successful listings/dossiers pushed

💰 **Cheapest credible pricing in the field** — $0.0018/listing and $0.006/dossier, undercutting every
LoopNet scraper on Apify that actually has real user traction.

🔗 [View current pricing](https://apify.com/sian.agency/loopnet-property-scraper?fpr=sian)

### ❓ Frequently Asked Questions

**Q: How many listings can I get per run?**
A: FREE tier: 25. PAID tier: unlimited, capped only by `maxResultsPerQuery`.

**Q: Can I search a drawn area instead of a location name?**
A: Yes — `locationMode: "bypolygon"` with an array of `[longitude, latitude]` pairs (PAID tier).

**Q: Does the detail dossier really include broker phone numbers?**
A: Yes — direct phone, title and brokerage company for every broker on the listing.

**Q: What if a listing id doesn't exist?**
A: The actor detects an empty/not-found dossier and fails that run cleanly without charging you.

**Q: Is the property-type taxonomy free?**
A: Yes — `autocomplete` and `propertytypes` operations are never charged.

**Q: What countries does the property-type taxonomy cover?**
A: United States, Canada, United Kingdom, France, Spain and Australia.

**Q: How long does a run take?**
A: A single search page returns in a few seconds; detail dossiers are near-instant.

### 🐛 Troubleshooting

**No results for my search**

- Broaden your filters — a narrow price/cap-rate/size range plus a small market can return zero matches
- Confirm `searchType` matches your intent (`For_Lease` vs `For_Sale` vs `Auctions`)

**Detail run fails with "not found"**

- Double-check the `listingId` came from a real search result — ids are never guessed
- The listing may have been leased/sold and removed from LoopNet

**Polygon search returns a TierError**

- `locationMode: "bypolygon"` requires a PAID Apify account

### ⚖️ Is it legal to scrape data?

Our actors are ethical and do not extract any private user data, such as email addresses, gender, or
location. They only extract what is publicly listed. We therefore believe that our actors, when used
for ethical purposes by Apify users, are safe.

However, you should be aware that your results could contain personal data (such as a broker's public
business phone number). Personal data is protected by the **GDPR** in the European Union and by other
regulations around the world. You should not scrape personal data unless you have a legitimate reason
to do so. If you're unsure whether your reason is legitimate, consult your lawyers.

You can also read Apify's blog post on the [legality of web scraping](https://blog.apify.com/is-web-scraping-legal/).

### ⚠️ Trademark Disclaimer

"LoopNet" is a registered trademark of CoStar Group, Inc. This actor is an independent, unofficial
tool and is not affiliated with, endorsed by, or sponsored by CoStar Group, Inc. or LoopNet. All
product and company names are trademarks™ or registered® trademarks of their respective holders. Use
of them does not imply any affiliation with or endorsement by them.

### 🤝 Support

[![Telegram Support](https://img.shields.io/badge/Telegram-Support%20Group-0088cc?logo=telegram)](https://t.me/+vyh1sRE08sAxMGRi)

**Join our active support community**

- For issues or questions, open an issue in the actor's repository
- Check [SIÁN Agency Store](https://apify.com/sian.agency?fpr=sian) for more automation tools
- 📧 <apify@sian-agency.online>

***

**Built by [SIÁN Agency](https://www.sian-agency.online)** | **[More Tools](https://apify.com/sian.agency?fpr=sian)**

# Actor input Schema

## `mode` (type: `string`):

Pick what to fetch from LoopNet. Each mode reads its own dedicated input fields below — fields outside the chosen mode are ignored.

• **search** — commercial listings by location, ZIP, coordinates, polygon or URL (default; the bulk op)
• **detail** — one full listing dossier (broker phones, owner, traffic counts, walk/transit scores) by id or URL
• **autocomplete** — location type-ahead suggestions (free)
• **propertytypes** — the full commercial property-type/subtype taxonomy (free)

## `locationMode` (type: `string`):

How you're specifying where to search. Each option reads its own field below.

• **bylocation** — free-text city, county, ZIP or address (default)
• **bycoordinates** — center lat/lng + radius
• **bypolygon** — a drawn area (bounding box)
• **byzip** — a specific US ZIP code
• **byurl** — paste a loopnet.com search-results URL

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

Free-text location — city, county, ZIP or address. Examples: 'Los Angeles, CA', 'Austin, TX', '90064'.

## `latitude` (type: `number`):

Center latitude of the search radius, e.g. 34.0522.

## `longitude` (type: `number`):

Center longitude of the search radius, e.g. -118.2437.

## `radiusMiles` (type: `number`):

Search radius around the center point, in miles.

## `polygonCoords` (type: `array`):

Array of at least 3 \[longitude, latitude] pairs forming the area to search. LoopNet searches the bounding box of this area. Example: \[\[-118.45,34.05],\[-118.40,34.05],\[-118.40,34.00],\[-118.45,34.00]]. PAID tier only.

## `zipCode` (type: `string`):

A single US ZIP code to search, e.g. '90064'.

## `searchUrl` (type: `string`):

Paste a loopnet.com search-results URL, e.g. https://www.loopnet.com/search/office-space/los-angeles-ca/for-lease/. Filters are parsed from the URL itself.

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

Which slice of LoopNet inventory to search. Applies to all Search Input Types except URL (which encodes it in the URL itself).

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

Commercial property type(s). Comma-separate multiple values, e.g. 'Office,Industrial'. Leave blank for all types. See the 'propertytypes' operation for the full subtype taxonomy.

## `propertySubType` (type: `string`):

Narrow to a subtype, e.g. 'warehouse', 'data\_center', 'medical\_office', 'strip\_center'. Resolves to its parent type and keyword-narrows the search. Run the 'propertytypes' operation for the full valid list.

## `priceRange` (type: `string`):

Sale price in USD. Format: 'min:1000000', 'max:10000000', or 'min:1000000,max:10000000'.

## `leaseRateRange` (type: `string`):

Asking lease rate, $ per square foot. Format: 'min:15', 'max:60', or 'min:15,max:60'.

## `buildingSizeRange` (type: `string`):

Total building size in square feet. Format: 'min:5000', 'max:200000', or 'min:5000,max:200000'.

## `spaceSizeRange` (type: `string`):

Available space size in square feet. Format: 'min:1000', 'max:50000', or 'min:1000,max:50000'.

## `lotSizeRange` (type: `string`):

Lot size in acres. Format: 'min:0.5', 'max:10', or 'min:0.5,max:10'.

## `capRateRange` (type: `string`):

Capitalization rate, percent (For Sale / investment listings). Format: 'min:5', 'max:12', or 'min:5,max:12'.

## `yearBuiltRange` (type: `string`):

Building construction year. Format: 'min:1990', 'max:2020', or 'min:1990,max:2020'.

## `sortOrder` (type: `string`):

How to order search results.

## `keywords` (type: `string`):

Free-text keyword filter, e.g. 'corner lot', 'drive-thru'.

## `subLease` (type: `boolean`):

Only return sublease spaces.

## `netLeased` (type: `boolean`):

Only return net-leased (NNN) investment listings.

## `distressed` (type: `boolean`):

Only return distressed or value-add listings.

## `opportunityZone` (type: `boolean`):

Only return listings inside a designated Opportunity Zone.

## `maxResultsPerQuery` (type: `integer`):

Hard cap on listings returned for this search. We auto-paginate (25 listings/page, LoopNet's own page size) until this cap is reached or the search is fully drained. FREE tier is always capped at 25.

## `startPage` (type: `integer`):

1-based page number to start pagination from. Default 1 (first page). Useful for resuming a large pull.

## `listingId` (type: `string`):

The numeric LoopNet listing id — from a search result's `listingId` field, or the number in a LoopNet listing URL, e.g. '29122043'. Provide either Listing ID or Listing URL.

## `listingUrl` (type: `string`):

A full LoopNet listing URL, e.g. https://www.loopnet.com/Listing/11340-W-Olympic-Blvd-Los-Angeles-CA/29122043/.

## `autocompleteTerm` (type: `string`):

Partial location text to get type-ahead suggestions for, e.g. 'Los Angeles'.

## `taxonomyCountry` (type: `string`):

Country to fetch the commercial property-type/subtype taxonomy for.

## Actor input object example

```json
{
  "mode": "search",
  "locationMode": "bylocation",
  "location": "Los Angeles, CA",
  "latitude": 34.0522,
  "longitude": -118.2437,
  "radiusMiles": 5,
  "zipCode": "90064",
  "searchUrl": "https://www.loopnet.com/search/office-space/los-angeles-ca/for-lease/",
  "searchType": "For_Lease",
  "priceRange": "min:1000000,max:10000000",
  "leaseRateRange": "min:15,max:60",
  "buildingSizeRange": "min:5000,max:200000",
  "spaceSizeRange": "min:1000,max:50000",
  "lotSizeRange": "min:0.5,max:10",
  "capRateRange": "min:5,max:12",
  "yearBuiltRange": "min:1990,max:2020",
  "sortOrder": "Recommended",
  "subLease": false,
  "netLeased": false,
  "distressed": false,
  "opportunityZone": false,
  "maxResultsPerQuery": 40,
  "startPage": 1,
  "listingId": "29122043",
  "listingUrl": "https://www.loopnet.com/Listing/11340-W-Olympic-Blvd-Los-Angeles-CA/29122043/",
  "autocompleteTerm": "Los Angeles",
  "taxonomyCountry": "USA"
}
```

# Actor output Schema

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

Structured LoopNet commercial listings, dossiers, locations or taxonomy rows.

## `htmlReport` (type: `string`):

HTML summary with run stats and per-query totals.

# 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"
};

// Run the Actor and wait for it to finish
const run = await client.actor("sian.agency/loopnet-property-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" }

# Run the Actor and wait for it to finish
run = client.actor("sian.agency/loopnet-property-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"
}' |
apify call sian.agency/loopnet-property-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

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