# LoopNet UK Scraper - Commercial Property Listings (`studio-amba/loopnet-uk-scraper`) Actor

Scrape commercial property listings from LoopNet.co.uk — the UK's leading commercial real estate portal. Extract offices, industrial units, retail and co-working spaces for rent or sale with prices, sizes, brokers, and photos. No login or cookies needed.

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

## Pricing

from $5.00 / 1,000 result 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/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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js/docs.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/integrations/mcp.md).

If your project is in a different language, use 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 UK Scraper - Commercial Property Listings

Scrape commercial property listings from **LoopNet.co.uk**, the UK's leading commercial real estate marketplace. Extract offices, industrial units, retail spaces, and co-working locations for rent or sale — with prices, floor areas, brokers, agents, photos, and full listing descriptions.

No login, no cookies, no setup. Pick a city and a transaction type, and get structured JSON, CSV, or Excel output in minutes.

### What data does it extract?

Every listing includes:

| Field | Description | Example |
|---|---|---|
| `listingId` | LoopNet listing identifier | `30516975` |
| `name` | Property name or street address | `Exchange Quay Campus - 1 Exchange Quay` |
| `addressLine` | Locality and postcode | `Manchester, M5 3EA` |
| `postcode` | UK postcode | `M5 3EA` |
| `transactionType` | `rent` or `sale` | `rent` |
| `propertyType` | Office, Industrial, Retail, Co-working, ... | `Office` |
| `priceText` | Price as listed | `£20.00 - £24.00 sq ft pa` |
| `priceMin` / `priceMax` | Parsed price bounds (GBP) | `20` / `24` |
| `priceUnit` | Pricing basis | `per sq ft per annum` |
| `sizeText` | Floor area as listed | `4,140 - 57,091 sq ft` |
| `sizeMinSqFt` / `sizeMaxSqFt` | Parsed area bounds | `4140` / `57091` |
| `availability` | Availability note | `6 Spaces Available Now` |
| `broker` | Brokerage / listing organisation | `Till Asset Management` |
| `agent` | Listing agent name | `Nathan Lang` |
| `features` | Feature tags | `Air Conditioning, Raised Floor, ...` |
| `headline` | Marketing headline | `Manchester Office to Rent` |
| `propertyDescription` | Full listing card description | `Welcome to Exchange Quay...` |
| `imageUrl` | Primary listing photo | `https://images.loopnet.co.uk/...` |
| `url` | Direct link to the listing | `https://www.loopnet.co.uk/listing/...` |

### How to scrape LoopNet UK data

1. Choose a **transaction type**: for rent (to let) or for sale.
2. Enter a **location** — a UK city name like `london`, `manchester`, `birmingham`, `leeds`, `glasgow`, or `united kingdom` for a country-wide search.
3. Set **max results** (each search page carries ~22 listings).
4. Run the actor and download the results as JSON, CSV, Excel, or XML from the dataset tab.

That's it. The actor handles the site's bot protection and pagination automatically.

#### Example input

```json
{
    "transaction": "rent",
    "location": "london",
    "maxResults": 100
}
````

#### Using search URLs directly

Prefer to fine-tune the search on the website? Apply your filters on loopnet.co.uk (property type, size, price, submarket) and paste the result URL into `startUrls`:

```json
{
    "startUrls": [
        { "url": "https://www.loopnet.co.uk/search/commercial-property/london-england--united-kingdom/for-rent/" }
    ],
    "maxResults": 200
}
```

All filters in the URL are preserved.

#### Supported locations

Major UK cities are recognised by name: London, City of London, Manchester, Birmingham, Leeds, Liverpool, Glasgow, Edinburgh, Bristol, Sheffield, Newcastle, Nottingham, Leicester, Coventry, Bradford, Cardiff, Aberdeen, Brighton, Portsmouth, Southampton, Reading. A handful of EU cities on the same platform work too: Paris, Lyon, Marseille, Toulouse, Madrid, Barcelona, Valencia.

You can also pass any location slug taken from a loopnet.co.uk URL (the part between `/commercial-property/` and `/for-rent/`), which covers every town and submarket on the site.

#### Example output

```json
{
    "listingId": "30516975",
    "name": "Exchange Quay Campus - 1 Exchange Quay",
    "addressLine": "Manchester, M5 3EA",
    "postcode": "M5 3EA",
    "transactionType": "rent",
    "propertyType": "Office",
    "priceText": "£20.00 - £24.00 sq ft pa",
    "priceMin": 20,
    "priceMax": 24,
    "priceUnit": "per sq ft per annum",
    "currency": "GBP",
    "sizeText": "4,140 - 57,091 sq ft",
    "sizeMinSqFt": 4140,
    "sizeMaxSqFt": 57091,
    "availability": "6 Spaces Available Now",
    "broker": "Till Asset Management",
    "agent": "Nathan Lang",
    "features": ["Air Conditioning", "Natural Light", "Raised Floor"],
    "headline": "Manchester Office to Rent",
    "url": "https://www.loopnet.co.uk/listing/1-exchange-quay-manchester/30516975/"
}
```

### Use cases

- **Market research** — track asking rents and sale prices per city, submarket, or property type.
- **Lead generation** — collect broker and agent contacts behind active listings.
- **Investment sourcing** — monitor new industrial, office, or retail stock across the UK.
- **Portfolio benchmarking** — compare your asking prices against the live market.
- **PropTech products** — feed UK commercial availability into your own tools and dashboards.

### Why this scraper?

- **No login or cookies needed** — runs out of the box, nothing to configure.
- **Structured prices and sizes** — raw strings plus parsed numeric bounds and units, ready for analysis.
- **Broker and agent names included** — extracted from the listing's structured data.
- **Handles heavy bot protection** — loopnet.co.uk blocks plain scrapers; this actor ships with a built-in unblocking layer.
- **Pagination built in** — set `maxResults` and the actor walks the result pages for you.

### Pricing

This actor uses pay-per-event pricing: you pay a small fee per actor start and per result returned. A 100-listing run costs well under a dollar. There are no subscriptions and no minimums — try it with a handful of results first.

### FAQ

**Does it scrape loopnet.com (US) too?**
No. This actor targets loopnet.co.uk, the UK platform. The US site has a different structure.

**Can I filter by property type or size?**
Yes — apply the filters on loopnet.co.uk and pass the resulting URL via `startUrls`. Name-based city search returns all commercial property types.

**How fresh is the data?**
Every run fetches live pages. You get whatever is listed at the moment the run executes.

**How many listings can I get per run?**
A large city like London exposes roughly 480 listings per transaction type (~22 pages). Country-wide searches go much deeper. Requests are paced to respect the site, so very large runs take proportionally longer.

**Is this legal?**
The actor only collects publicly visible listing data — no login, no personal accounts, no paywalled content. You are responsible for how you use the data; check applicable laws and the site's terms for your use case.

### Related actors

Looking for residential or other European property data? Check the [Studio AMBA store](https://apify.com/studio-amba) for Zoopla, Homegate, Immoweb, Otodom, and 25+ other real estate scrapers.

# Actor input Schema

## `transaction` (type: `string`):

Search for commercial properties for rent (to let) or for sale.

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

UK city name (e.g. 'london', 'manchester', 'birmingham', 'leeds'), 'united kingdom' for a country-wide search, or a location slug from a loopnet.co.uk URL (e.g. 'london-england--united-kingdom'). A few EU cities work too (paris, madrid, barcelona).

## `maxResults` (type: `integer`):

Maximum number of listings to return.

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

LoopNet.co.uk search-result URLs to scrape, e.g. https://www.loopnet.co.uk/search/commercial-property/london-england--united-kingdom/for-rent/ — filters applied on loopnet.co.uk are preserved. Overrides transaction/location if provided.

## `brightDataApiKey` (type: `string`):

Optional override for the built-in unblocking service credentials. Leave empty to use the default.

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

Proxy settings. LoopNet.co.uk uses heavy bot protection; the built-in unblocking service handles it, so the default works out of the box.

## Actor input object example

```json
{
  "transaction": "rent",
  "location": "london",
  "maxResults": 20,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# 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 = {
    "transaction": "rent",
    "location": "london",
    "maxResults": 20,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("studio-amba/loopnet-uk-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 = {
    "transaction": "rent",
    "location": "london",
    "maxResults": 20,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("studio-amba/loopnet-uk-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 '{
  "transaction": "rent",
  "location": "london",
  "maxResults": 20,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call studio-amba/loopnet-uk-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "LoopNet UK Scraper - Commercial Property Listings",
        "description": "Scrape commercial property listings from LoopNet.co.uk — the UK's leading commercial real estate portal. Extract offices, industrial units, retail and co-working spaces for rent or sale with prices, sizes, brokers, and photos. No login or cookies needed.",
        "version": "0.1",
        "x-build-id": "kf4Pmv9ab1OUKrSvj"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/studio-amba~loopnet-uk-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-studio-amba-loopnet-uk-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/studio-amba~loopnet-uk-scraper/runs": {
            "post": {
                "operationId": "runs-sync-studio-amba-loopnet-uk-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/studio-amba~loopnet-uk-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-studio-amba-loopnet-uk-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "transaction": {
                        "title": "Transaction Type",
                        "enum": [
                            "rent",
                            "sale"
                        ],
                        "type": "string",
                        "description": "Search for commercial properties for rent (to let) or for sale.",
                        "default": "rent"
                    },
                    "location": {
                        "title": "Location",
                        "type": "string",
                        "description": "UK city name (e.g. 'london', 'manchester', 'birmingham', 'leeds'), 'united kingdom' for a country-wide search, or a location slug from a loopnet.co.uk URL (e.g. 'london-england--united-kingdom'). A few EU cities work too (paris, madrid, barcelona).",
                        "default": "london"
                    },
                    "maxResults": {
                        "title": "Max Results",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of listings to return.",
                        "default": 50
                    },
                    "startUrls": {
                        "title": "Start URLs",
                        "type": "array",
                        "description": "LoopNet.co.uk search-result URLs to scrape, e.g. https://www.loopnet.co.uk/search/commercial-property/london-england--united-kingdom/for-rent/ — filters applied on loopnet.co.uk are preserved. Overrides transaction/location if provided.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "brightDataApiKey": {
                        "title": "Bright Data API Key (optional)",
                        "type": "string",
                        "description": "Optional override for the built-in unblocking service credentials. Leave empty to use the default."
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Proxy settings. LoopNet.co.uk uses heavy bot protection; the built-in unblocking service handles it, so the default works out of the box.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ]
                        }
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
