# JLL Scraper: Commercial Property Listings for Lease & Sale (`recordsdata/jll-scraper`) Actor

Scrape property.jll.com, JLL commercial real estate listings in 14 markets: office, industrial, retail and land for lease or sale with size in m2 and sq ft, coordinates, photos, floor plans, brochures and available suites. Sitemap, market summaries, new-listing monitor. No proxy. Export JSON, CSV.

- **URL**: https://apify.com/recordsdata/jll-scraper.md
- **Developed by:** [RecordsData](https://apify.com/recordsdata) (community)
- **Categories:** Real estate, Lead generation
- **Stats:** 3 total users, 2 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $20.00 / 1,000 full 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

![RecordsData](https://api.apify.com/v2/key-value-stores/AAm3a1h3Z9nYfrvh9/records/banner?v=3)

## 🏢 JLL Scraper - Commercial Property Listings for Lease and Sale - RecordsData

> 🚀 **Export JLL commercial real estate in minutes.** Read property.jll.com, the listing portal of JLL (Jones Lang LaSalle), in 14 markets: about 13,150 offices, industrial buildings, warehouses, retail units, land plots and more for lease or sale, with size in m2 and sq ft, coordinates, photos, floor plans, brochures and the suites a building has available. No login, no browser and no proxy setup needed.

**JLL Scraper is an Apify Actor that collects public commercial property listings from property.jll.com in 14 markets (United States, Canada, Mexico, Brazil, Chile, Colombia, Argentina, Costa Rica, Peru, Uruguay, Puerto Rico and South Africa) and returns them as JSON, CSV or Excel with size in m2 and sq ft, coordinates, photos, floor plans, brochures, available suites and JLL business contacts.** The dataset schema holds 81 columns across five record types, a detailed listing carries 32 to 46 fields, and a 3-listing run finishes in about 6 seconds.

### 📋 What the JLL Scraper does

The Actor reads the same public pages every visitor of property.jll.com sees. Each page carries its data as embedded JSON, so rows are exact and no browser is needed. Four modes cover the site.

- **search**: listings for the markets, deal type (rent, sale or both), property types and places you choose. The Actor reads the search pages JLL publishes for those combinations (for example office space for rent in Houston) and opens every listing for the full row.
- **sitemap**: every listing address the site publishes in a market, newest first, with the date the site last changed it. This is the way to reach the full catalog: the United States alone has about 10,740 listings. Switch off **Open every listing** to get a cheap address list, or leave it on for full rows.
- **urls**: paste JLL listing addresses (any market prefix such as `/en-ca/` or `/pt-br/`) or search page addresses. Several kinds can be mixed.
- **market**: one summary row per search page: how many listings JLL shows, the market text JLL writes for the page and the average, median, smallest and largest size of the listings shown.

> 💡 **Why it matters:** JLL is one of the largest commercial brokers in the world, and its portal is one of the few places that shows lease and sale offers for offices, industrial and retail space in the United States, Canada and Latin America in one structure. Prices are often hidden (priceOnRequest), so size, location, type, availability dates and broker office are the data that really move a deal list.

| 🎯 Target audience | 💡 Primary use cases |
|---|---|
| Tenant representatives and brokers | Build a shortlist of available office and industrial space by city |
| Investors and lenders | Track listings, sizes and sale prices by market and type |
| Site selection and expansion teams | Compare vacant space, warehouse stock and land plots across countries |
| Proptech and data teams | Feed a CRM, a map or a dashboard with a daily listing feed |

### 📊 Output

Every row has a `recordType`: `listing` (card data from the search page, fast), `listing-detail` (full listing page), `listing-url` (sitemap address), `availability` (one suite, floor or unit of a listing) or `market-stat` (search page summary). Fields without a value are left out, never filled with `null`. Column order is fixed: image first, identity and deal next, then location, size, text, media, the JLL business data and `scrapedAt` last. Every row names its `country`, `language` and, when JLL shows a price, its `currency`.

Real `listing-detail` row (industrial building for sale, Toronto), shortened:

```json
{
  "imageUrl": "https://res.cloudinary.com/jll-global-sandbox/image/upload/v1783625120/MyListing/public/prod/upaaingijq9nhnoyx0n8.png",
  "recordType": "listing-detail",
  "title": "320-328 Nantucket Boulevard",
  "listingId": "692332",
  "url": "https://property.jll.com/en-ca/listings/320-328-nantucket-boulevard",
  "sourceSite": "property.jll.com",
  "country": "CA",
  "language": "en",
  "operation": "sale",
  "operations": ["sale"],
  "propertyType": "industrial",
  "buildingClass": "C",
  "labels": ["Sale"],
  "price": 15500000,
  "priceFormatted": "CAD 15,500,000",
  "currency": "CAD",
  "priceBasis": "unspecified",
  "priceTenure": "sale",
  "address": "320-328 Nantucket Boulevard",
  "city": "Toronto",
  "region": "Ontario",
  "state": "ON",
  "postalCode": "M1P 2P4",
  "locationDescription": "Greater Toronto Central",
  "latitude": 43.762048,
  "longitude": -79.27728,
  "areaBuilt": 3900.5,
  "areaSqft": 41985,
  "areaSourceUnit": "sq ft",
  "highlights": ["Freestanding industrial building within premium Scarborough location (Hwy 401 & Kennedy Rd)", "Flexible layout allows demising into smaller units"],
  "imageCount": 14,
  "agencyName": "JLL",
  "agencyUrl": "https://www.jll.com",
  "isPrivateSeller": false,
  "officeCities": ["Toronto"],
  "brokerCount": 2,
  "scrapedAt": "2026-10-11T13:56:24.400Z"
}
```

Real `availability` row (an office suite in Houston), shortened:

```json
{
  "recordType": "availability",
  "title": "Suite 1000, floor 10",
  "listingId": "200943",
  "availabilityId": "24360",
  "url": "https://property.jll.com/listings/20-greenway-plaza-20-greenway-plz-houston",
  "country": "US",
  "operation": "rent",
  "propertyType": "office",
  "spaceUse": "Office",
  "availabilityType": "Lease",
  "priceOnRequest": true,
  "address": "20 Greenway Plz",
  "city": "Houston",
  "region": "Texas",
  "suite": "1000",
  "floorName": "10",
  "areaBuilt": 2337.7,
  "areaSqft": 25163,
  "leaseTerm": "Negotiable",
  "availableFrom": "Immediate",
  "agencyName": "JLL"
}
```

Real `market-stat` row (office space for rent in Washington D.C.), text shortened:

```json
{
  "recordType": "market-stat",
  "title": "Office space for rent in Washington D.C.",
  "url": "https://property.jll.com/rent-office/washington-dc",
  "country": "US",
  "operation": "rent",
  "propertyType": "office",
  "city": "Washington",
  "region": "District of Columbia",
  "listingCount": 123,
  "sampleSize": 50,
  "avgArea": 402.6,
  "medianArea": 240.4,
  "minArea": 81.3,
  "maxArea": 5107.3,
  "areaUnit": "m²"
}
```

Field groups of a detailed row, with the type and a real value:

| Field | Type | Example |
|---|---|---|
| `listingId`, `url`, `title` | string | `692332`, the `/listings/` address, the building name |
| `operation`, `operations`, `propertyType`, `propertyTypes`, `labels` | string or array | `sale`, `industrial`, `Sale` |
| `price`, `currency`, `priceFormatted`, `priceBasis`, `pricePerM2`, `rentPeriod` | number or string | `15500000`, `CAD`, `per-area` |
| `priceOnRequest` | boolean | `true` when JLL hides the price |
| `address`, `city`, `region`, `state`, `postalCode`, `submarket` | string | `Toronto`, `Ontario`, `M1P 2P4` |
| `latitude`, `longitude` | number | `43.762048`, `-79.27728` |
| `areaBuilt`, `areaBuiltMax`, `areaLand`, `areaSqft`, `areaSqftMax` | number | `3900.5` m2, `41985` sq ft |
| `description`, `highlights`, `amenities`, `brochures`, `floorPlans` | text or array | listing text and PDF links |
| `images`, `imageCount`, `virtualTourUrls` | array or number | photo links, never downloaded |
| `agencyName`, `agencyPhone`, `agencyLicenseNumber`, `officeCities`, `brokerCount` | string or number | `JLL`, the business line, the license entity |

### ✨ Why choose this Actor

- **Five record types in one Actor**: cards, full listings, sitemap addresses, available suites and market summaries.
- **14 markets, 4 languages**: country and language are named on every row, and text stays in the language of the market.
- **Exact sizes**: area in m2 and in sq ft, the range maximum, and the unit JLL used. Implausible upstream values (a plot listed with billions of hectares) are dropped, not passed on.
- **Honest prices**: the price as JLL shows it, with currency, rent period and whether it is per area. Hidden prices are never guessed.
- **Business contacts only by default**: the JLL business phone, license entity and office cities come with every listing. Names and e-mails of individual brokers need a switch.
- **Monitor mode**: a scheduled run returns only listings it has not delivered before.
- **Gentle on the site**: one shared request pace of about one per second, robots.txt rules checked on every address.

### 📈 How it compares to alternatives

One other Actor on the Apify Store reads the same portal, read on 2026-10-11:

| | This Actor | rigelbytes/jll-scraper |
|---|---|---|
| Source | property.jll.com, 14 markets | property.jll.com, markets not listed |
| Fields | 81 columns, 32 to 46 per detailed listing | 24 published fields |
| Record types | Listing, detail, sitemap address, available suite, market summary | Not listed |
| Full catalog by sitemap | Yes, newest first with change date | Not listed |
| Available suites and floors | Yes, with size, lease term and date | Not listed |
| Size in m2 and sq ft | Both, with range maximum and source unit | One `area` field, unit not stated |
| Monitor for new listings | Yes | Not listed |
| Usage | New | 89 runs in total, 0 users in the last 30 days |

This Actor does not cover the white label sites JLL builds for retail and banking clients on the same platform, and it returns no personal contact data unless you switch it on.

### 🚀 How to use

1. Create a free account at [console.apify.com](https://console.apify.com) ($5 of monthly credit) and open the Actor.
2. Choose **What to collect**. For a first test keep `search`, pick a market, a deal type and a property type, and set **Maximum items** to 10.
3. Optionally name places (`houston`, `texas`, `toronto`, `sao paulo`) and add price or size limits.
4. Press **Start**. Open the dataset when the run finishes and download JSON, CSV, Excel, XML or HTML.
5. To watch a market, turn on **Only new listings**, give the search a **Monitor name** and schedule the Actor.

A minimal JSON input:

```json
{ "mode": "search", "markets": ["us"], "tenure": "rent", "propertyTypes": ["office"], "locations": ["houston"], "maxItems": 50 }
```

### 💼 Business use cases

- 🏬 **Tenant representation and brokerage**: list every available suite in a city with its size, floor, lease term and availability date, and sort by size or date.
- 📈 **Investors and lenders**: sale listings by market and type with price where JLL publishes one, plus the market summary rows for supply by city.
- 🏭 **Industrial and logistics site selection**: warehouses, industrial buildings and land in the United States, Canada, Mexico, Brazil, Chile, Colombia and Argentina, with coordinates ready for a map.
- 🤖 **Proptech and data teams**: a daily feed of new and changed listings into a CRM, a map or a data warehouse.

### 🔌 Automating the JLL Scraper

Schedule runs in Apify Console and send results to Make, Zapier or n8n, Slack or e-mail alerts, Google Sheets, Google Drive, Airbyte or any webhook. With the Python client:

```python
from apify_client import ApifyClient
client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("YOUR_USERNAME/jll-scraper").call(run_input={"mode": "search", "markets": ["us"], "locations": ["houston"], "maxItems": 30})
rows = client.dataset(run["defaultDatasetId"]).list_items().items
```

### 🌟 Beyond business use cases

- 🎓 **Research**: study how much office and industrial space is offered per city, how sizes are distributed and how listings change over weeks.
- 🧭 **Personal projects**: find a workshop, a studio or a small office near a place, with coordinates and photos.
- 🤝 **Non-profits and local government**: map available space for incubators, community projects or economic development plans.
- 🧪 **Experimentation**: test geocoding, map tools and area conversions on real commercial data.

### 🤖 Ask an AI assistant about this scraper

The Apify MCP server (`mcp.apify.com`) exposes this Actor as a tool, so Claude, ChatGPT or another MCP client can run it from a chat. The agent reads the input schema and fills the fields itself.

Example prompt: "Using the JLL Scraper, get 30 industrial listings for sale in Canada with details, sort them by size and tell me which ones show a price."

Tool description for an agent: "Collects public commercial real estate listings from property.jll.com for lease or sale in 14 markets. Input: mode (search, sitemap, urls, market), markets, tenure, propertyTypes, locations, price and size limits, maxItems. Returns typed rows with size in m2 and sq ft, coordinates, photos, brochures, available suites and JLL business data."

### Frequently Asked Questions

#### 🏢 What data can I scrape from JLL property listings?

Commercial listings for lease and sale: office, industrial, warehouse, retail, land, medical, multifamily, lab, flex R\&D and data center. Each detailed listing includes the address, coordinates, size in m2 and sq ft, the description and highlights, amenities, photos, brochures and floor plans, and the JLL office and license entity. Available suites come as their own rows when you turn on **Include available spaces**.

#### 🔎 How do I scrape JLL listings for one city?

Add the city to **Places**, for example `houston`, `chicago`, `toronto` or `sao paulo`, and pick the market. Search and market modes match the names of the search pages JLL publishes, such as office space for rent in Houston. A place with no search page returns one free error row that lists places that do have one, and sitemap mode can match the words of a listing address instead.

#### 🔢 How many listings can one search return?

Up to 50 per search page, because JLL shows at most 50 cards on a page even when it reports more (Washington D.C. office space for rent reports 123 listings and shows 50). Search by city, type and deal type to cover more, or use the sitemap mode, which has no such ceiling and lists every listing address of a market: about 13,150 across all markets and about 10,740 in the United States.

#### 🏷️ Why do most rows have no price?

JLL hides the price of most listings and shows "price on request" instead. In a check of 31 detailed listings, 5 showed a price. The Actor sets `priceOnRequest` to `true` in that case and never invents a figure. When a price is shown it keeps the currency and tells you whether it is a total, a yearly or monthly rent, or a price per sq ft or per m2.

#### 🌎 Which countries and languages are covered?

The United States, Canada (English and French), Mexico, Brazil (Portuguese and English), Chile, Colombia, Argentina, Costa Rica, Peru, Uruguay, Puerto Rico and South Africa. Every row has `country` and `language`. Text such as descriptions stays in the language of the market. Some markets publish few search pages and Chile publishes none, so for those use sitemap mode.

#### 🧩 What is the difference between listing, listing-detail and availability rows?

`listing` rows come from the search page: title, address, type, size, coordinates and photos. `listing-detail` rows open the listing page and add the description, highlights, amenities, brochures, floor plans, license data and broker count. `availability` rows list one suite, floor or unit of a building with its own size, lease term and available date.

#### 🧑 Does it return names, phones or e-mails?

By default only business data: the JLL name and website, the business phone, the license entity and region, the office cities and the number of brokers. JLL brokers are individuals, so their name, job title, business e-mail and phone are returned only when you turn on **Include broker details**. Use them in line with the privacy rules that apply to you.

#### 🔁 How do I get only new listings?

Turn on **Only new listings** and give the search a **Monitor name**. The next run skips listings it already delivered and you are not charged for skipped ones. In sitemap mode a listing the site changed since is delivered again. Schedule the Actor daily for an alert feed.

#### 🛡️ Do I need a proxy or an API key?

No. The site sits behind a bot filter that blocks plain command-line clients, but the Actor's own client is accepted from Apify servers without a proxy. In 21 cloud test runs that reached the site it made 112 requests and none was refused. The Actor keeps to about one request per second for all workers together, retries a refusal with a pause, and only if the site keeps refusing does it switch to the Apify datacenter proxy.

#### 📐 Which units and currencies are used?

Size is given in square meters (`areaBuilt`) and square feet (`areaSqft`) for every listing, plus `areaSourceUnit`, the unit JLL used. Prices keep the currency JLL shows (USD, CAD, BRL, MXN, CLP and others) next to the numeric `price`. Dates are ISO 8601.

#### 🧪 What happens if my input is wrong or nothing matches?

A wrong value, such as an unknown market or a price range without a currency, ends the run as succeeded with one free error row that says what to fix. A search with no matches ends as succeeded with no rows. Neither is charged. Free plans return up to 10 items per run and paid plans up to 1,000,000, and you can export JSON, CSV, Excel, XML, HTML or RSS.

#### ⏱️ How fast is it?

A 3-listing run finished in a median of 6.5 seconds in 18 cloud runs (slowest 16.7 seconds) at 256 MB, with a peak memory use of 58 MB. Full detail pages are read at about one per second, so 100 detailed listings take roughly two minutes.

### 🔌 Integrate with any app

Results can be pulled by API, pushed to a webhook when a run ends, or synced to Google Sheets, Airtable, BigQuery, Snowflake or a database through Apify integrations. See the Integrations tab of the Actor.

### ⚖️ Limits and legal notes

- The Actor reads public pages that need no login and follows the robots.txt rules of the site: no search queries, no pages the file disallows.
- Search depth is 50 listings per search page. Sitemap mode lists every address but needs one request per listing for full rows.
- Most listings show no price, a few have sizes only as a range, and the site sometimes shows inconsistent figures for the same building; the Actor returns what the page says.
- White label sites that JLL runs for other companies are not covered.
- The site terms reserve the rights to its content: use the data in line with them and with the privacy law that applies to you. Photos and documents are returned as links, never downloaded.

### 🔗 Recommended Actors

- [RecordsData collection](https://apify.com/RecordsData): other real estate and public data scrapers by the same team.

**🆘 Need help?** Write to <contact.punkrecordsdata@gmail.com> or open an issue in the Issues tab.

> **⚠️ Disclaimer:** This is an independent tool and is not affiliated with, endorsed by or sponsored by JLL (Jones Lang LaSalle). JLL is a trademark of its owner. It collects only publicly available data.

# Actor input Schema

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

search = listings from the property search pages JLL publishes for the markets, deal type, property types and places below (each page shows up to 50 listings). sitemap = every listing address in the markets, newest first (the way to reach the full catalog). urls = the JLL listing or search addresses you list in startUrls. market = one summary row per search page: how many listings JLL shows, its market text and area statistics.

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

Stops after this many rows (all record types together). Free plans are limited to 10 items per run.

## `markets` (type: `array`):

Which JLL country sites to read. The United States has most of the catalog (about 10,700 of 13,100 listings). Empty means the United States.

## `tenure` (type: `string`):

Rent (lease, sublease), sale, or both. Used by search, market and sitemap modes.

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

Office, industrial, retail, land and more (search, market and sitemap modes). Empty means all types. The Latin American markets also use warehouse.

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

Optional. Cities, states or neighborhoods as written in JLL addresses, for example houston, texas, sao paulo, toronto. Search and market modes match the names of JLL search pages; sitemap mode matches the words of each listing address. Empty means no place filter.

## `minPrice` (type: `integer`):

Only listings with a published price at or above this figure, in the currency below. The figure is compared as JLL shows it (often per square foot or per m2, not the total). Leave empty or 0 for no limit.

## `maxPrice` (type: `integer`):

Only listings with a published price at or below this figure, in the currency below. Leave empty or 0 for no limit.

## `priceCurrency` (type: `string`):

Three-letter code of the currency the price filter refers to, for example USD, CAD, BRL, MXN, CLP. Required when a price filter is set.

## `minAreaM2` (type: `integer`):

Only listings whose size range reaches at least this many square meters (1,000 m2 is about 10,764 sq ft). Leave empty or 0 for no limit.

## `maxAreaM2` (type: `integer`):

Only listings that offer at most this many square meters. Leave empty or 0 for no limit.

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

urls mode: JLL listing addresses (https://property.jll.com/listings/<name>, also /en-ca/, /pt-br/ and the other market prefixes) or search pages (for example https://property.jll.com/rent-office/houston). Query strings are ignored.

## `modifiedSince` (type: `string`):

sitemap mode: only listings the site sitemap reports as changed on or after this date, written YYYY-MM-DD (for example 2026-10-01). Empty means no date limit.

## `fetchDetails` (type: `boolean`):

On: open each listing page for the full description, all photos, floor plans, amenities, brochures and business contact data (listing-detail-record). Off: card data only from the search page, about twice as fast, and in sitemap mode just the address and change date (listing-record, listing-url-record).

## `includeAvailabilities` (type: `boolean`):

Also deliver one row for each space (suite, floor or unit) a listing offers, with its own size, rent, lease term and availability date (availability-record). Each space counts as one item and one extra request is made per listing.

## `includeContactDetails` (type: `boolean`):

Adds the JLL brokers shown on each listing (name, job title, office, business email and phone, license number). These are individuals, so it is off by default; the JLL business phone, license number and office cities are always included.

## `includeRaw` (type: `boolean`):

Adds a raw object with the unprocessed site fields that have no dedicated column.

## `onlyNew` (type: `boolean`):

Skip listings already delivered by an earlier run of the same search, so scheduled runs only return and charge for what is new. In sitemap mode a listing the site changed since is delivered again. The memory is stored in your own Apify account.

## `stateKey` (type: `string`):

Optional label to keep several monitors on the same search apart.

## `resetSeen` (type: `boolean`):

Clear the monitor memory for this search before the run, so everything counts as new.

## `maxScan` (type: `integer`):

Safety limit on search pages and listing pages opened in one run, whatever the number of items. Filters that match few listings can need many pages; raise it for deep scans.

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

Listing pages opened in parallel. All requests share one pace of about one per second to respect the site, so this only hides waiting time.

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

Optional. Empty means direct requests, which work. If the site keeps refusing a connection, the actor switches to the Apify datacenter proxy on its own.

## Actor input object example

```json
{
  "mode": "search",
  "maxItems": 10,
  "markets": [
    "us"
  ],
  "tenure": "any",
  "propertyTypes": [],
  "locations": [
    "houston"
  ],
  "priceCurrency": "",
  "startUrls": [
    "https://property.jll.com/rent-office/houston"
  ],
  "modifiedSince": "",
  "fetchDetails": true,
  "includeAvailabilities": false,
  "includeContactDetails": false,
  "includeRaw": false,
  "onlyNew": false,
  "stateKey": "",
  "resetSeen": false,
  "maxScan": 300,
  "maxConcurrency": 2,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `overview` (type: `string`):

Key fields per row

## `fullData` (type: `string`):

Complete dataset with all fields

# 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 = {
    "maxItems": 10,
    "markets": [
        "us"
    ],
    "locations": [
        "houston"
    ],
    "minPrice": 0,
    "maxPrice": 0,
    "minAreaM2": 0,
    "maxAreaM2": 0,
    "startUrls": [
        "https://property.jll.com/rent-office/houston"
    ],
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("recordsdata/jll-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 = {
    "maxItems": 10,
    "markets": ["us"],
    "locations": ["houston"],
    "minPrice": 0,
    "maxPrice": 0,
    "minAreaM2": 0,
    "maxAreaM2": 0,
    "startUrls": ["https://property.jll.com/rent-office/houston"],
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("recordsdata/jll-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 '{
  "maxItems": 10,
  "markets": [
    "us"
  ],
  "locations": [
    "houston"
  ],
  "minPrice": 0,
  "maxPrice": 0,
  "minAreaM2": 0,
  "maxAreaM2": 0,
  "startUrls": [
    "https://property.jll.com/rent-office/houston"
  ],
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call recordsdata/jll-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,recordsdata/jll-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/SuGB7fOnUR1M4ndyH/builds/OM1ckybEW3f3HCIKd/openapi.json