# Imovirtual Scraper (`solidcode/imovirtual-scraper`) Actor

\[💰 $2.5 / 1K] Extract property listings from Imovirtual, Portugal's leading real-estate portal. Search by location, buy/rent, property type, price, area and rooms — or paste search URLs — to get prices, areas, locations, photos and agency contacts.

- **URL**: https://apify.com/solidcode/imovirtual-scraper.md
- **Developed by:** [SolidCode](https://apify.com/solidcode) (community)
- **Categories:** Real estate, Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.50 / 1,000 results

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 a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.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/platform/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

## Imovirtual Scraper

Pull property listings from Imovirtual — Portugal's leading real-estate portal — at scale: prices in euros, living area in m², T0–T5+ room counts, full photo galleries, agency details, GPS-free address data, and new-development flags for every for-sale and for-rent listing across the country. Built for Portugal property investors, estate agents, relocation services, and proptech analysts who need a clean, structured Imovirtual dataset without hand-copying listings from the portal one page at a time.

### Why This Scraper?

- **Two ways to search — no URL building required** — fill in a guided builder (location, buy/rent, type, price, area, rooms) or paste Imovirtual search URLs straight from your browser. Most competing tools accept URLs only.
- **Nine property categories** — apartments, houses, land, commercial spaces, garages, rooms, warehouses, new developments, or "any type" — each mapped to Imovirtual's own Portuguese categories (Apartamento, Moradia, Terreno, Empreendimento…).
- **Buy and rent in one actor** — flip a single dropdown between Comprar (for sale) and Arrendar (for rent); rent rows carry the monthly euro price in the same field.
- **Server-side price, area, and room filters** — set min/max price (€), min/max living area (m²), and multi-select T0–T5+ room counts; filters run on Imovirtual itself, so you only collect — and only pay for — listings that match.
- **Thousands of listings per search** — smooth pagination walks every results page with built-in deduplication; a single run pulled 3,793 listings without duplicates.
- **Full listing record on every row** — title, total price, price per m², living area, terrain area, rooms, floor, address, city, region, and the largest-resolution image URLs, all in one flat row.
- **Agency vs. private-owner intelligence** — every row flags whether it came from an agency (with agency name and type) or a private seller, plus promoted and exclusive-offer markers.
- **New-development detection** — empreendimento (new-construction) projects are flagged with `isDevelopment` and a development name, so you can separate off-plan inventory from resale stock.
- **Clean, analysis-ready output** — euro prices as numbers, ISO-8601 timestamps for created and bumped dates, null fields stripped, and consistent camelCase field names.

### Use Cases

**Real-Estate Investment & Acquisition**
- Compare asking prices and price-per-m² across Lisboa, Porto, and the Algarve
- Surface new-development (empreendimento) projects for off-plan opportunities
- Benchmark sale vs. rent yields by collecting both transaction types for one area
- Track terrain area and floor data when sourcing land or building plots

**Lead Generation for Agents**
- Build prospect lists of private-owner listings ripe for an agency mandate
- Map competing agencies by name and type across a target district
- Monitor exclusive and promoted listings to gauge competitor activity
- Feed fresh listing inventory straight into your CRM

**Market & Price Analysis**
- Track median price-per-m² movements by city and property type over time
- Measure inventory volume by district, room count, or price band
- Compare apartment vs. house vs. land pricing across Portuguese regions
- Build price-band histograms from min/max-filtered searches

**Relocation & Property Services**
- Assemble shortlists filtered by location, budget, and T-typology room count
- Generate area-by-area rental availability reports for incoming clients
- Pull listing photos and addresses for relocation briefing packs

**Proptech & Data Products**
- Power a Portuguese property portal, valuation model, or comparison tool
- Refresh an existing listings database with current prices and bump dates
- Build alerting on new listings within a price and area window

### Getting Started

#### Search by Location

The simplest run — just name a city or district:

```json
{
    "location": "Lisboa",
    "maxResults": 100
}
````

#### Filtered Buy Search

Apartments for sale in Porto, priced €200k–€350k, with two or three rooms:

```json
{
    "transaction": "buy",
    "propertyType": "apartment",
    "location": "Porto",
    "priceMin": 200000,
    "priceMax": 350000,
    "rooms": ["1", "2"],
    "maxResults": 300
}
```

#### Rent Search with a Price Band

Properties to rent in Lisboa up to €1,500/month:

```json
{
    "transaction": "rent",
    "propertyType": "apartment",
    "location": "Lisboa",
    "priceMax": 1500,
    "areaMin": 60,
    "maxResults": 200
}
```

#### Paste Imovirtual Search URLs

Already filtered on the site? Copy the URL from your browser — its baked-in filters are used exactly as-is, and the guided fields are ignored:

```json
{
    "startUrls": [
        "https://www.imovirtual.com/pt/resultados/comprar/moradia/faro",
        "https://www.imovirtual.com/pt/resultados/arrendar/apartamento/lisboa"
    ],
    "maxResults": 500
}
```

### Input Reference

#### What to Scrape

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `startUrls` | string\[] | `[]` | Paste one or more Imovirtual search-results URLs. The fastest way to get exactly what you see on the site. When provided, the guided "Build a Search" fields below are ignored. Up to 50 URLs. |

#### Build a Search

Used only when no `startUrls` are provided.

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `transaction` | select | `buy` | For Sale (Comprar) or For Rent (Arrendar). |
| `location` | string | `Lisboa` | City or district to search (e.g. "Lisboa", "Porto", "Faro"). Accents are accepted and recommended. |
| `propertyType` | select | `apartment` | Apartment, House, Land, Commercial space, Garage, Room, Warehouse, New development, or Any type. |

#### Filters

Applied to the Imovirtual search itself, so you only collect matching listings.

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `priceMin` | integer | null | Minimum price in € — monthly rent when renting, total price when buying. |
| `priceMax` | integer | null | Maximum price in €. |
| `areaMin` | integer | null | Minimum living area in m². |
| `areaMax` | integer | null | Maximum living area in m². |
| `rooms` | string\[] | `[]` | Room counts in Portuguese T-typology — T0 (studio) through T5+. Multi-select; combined with OR. |

#### Limits

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `maxResults` | integer | `100` | Maximum listings per search or URL. Results come in full pages, so the last page may overshoot by a few rows. Set to `0` for no cap (an internal safety limit of 50,000 then applies). |

### Output

Each listing becomes one flat row. Here's a representative result:

```json
{
    "id": "67890123",
    "title": "Apartamento T2 com varanda no centro de Lisboa",
    "url": "https://www.imovirtual.com/pt/anuncio/apartamento-t2-com-varanda-no-centro-de-lisboa-ID67890123",
    "slug": "apartamento-t2-com-varanda-no-centro-de-lisboa-ID67890123",
    "transaction": "buy",
    "propertyType": "apartment",
    "estate": "FLAT",
    "totalPrice": 285000,
    "currency": "EUR",
    "pricePerSqm": 3958,
    "area": 72,
    "rooms": 2,
    "floor": 3,
    "address": "Rua da Prata 45",
    "city": "Lisboa",
    "region": "Lisboa",
    "images": [
        "https://ireland.apollo.olxcdn.com/v1/files/example1/image;s=1280x1024",
        "https://ireland.apollo.olxcdn.com/v1/files/example2/image;s=1280x1024"
    ],
    "agencyName": "Lisboa Prime Imobiliária",
    "agencyType": "AGENCY",
    "isPrivateOwner": false,
    "isPromoted": true,
    "isExclusive": false,
    "isDevelopment": false,
    "shortDescription": "Apartamento totalmente renovado, com varanda e excelente exposição solar...",
    "dateCreated": "2026-04-12T09:14:00Z",
    "pushedUpAt": "2026-05-28T07:02:00Z",
    "searchQuery": "buy apartment Lisboa",
    "scrapedAt": "2026-05-30T10:41:05Z"
}
```

#### Core Fields

| Field | Type | Description |
|-------|------|-------------|
| `id` | string | Imovirtual listing identifier |
| `title` | string | Listing title |
| `url` | string | Canonical listing URL |
| `slug` | string | URL slug |
| `transaction` | string | `buy` or `rent` |
| `propertyType` | string | Normalized type: apartment, house, land, commercial, garage, room, warehouse, development |
| `estate` | string | Imovirtual's raw estate category (e.g. `FLAT`, `HOUSE`) |
| `shortDescription` | string | Short listing description |

#### Price & Specs

| Field | Type | Description |
|-------|------|-------------|
| `totalPrice` | number | Total price in € — sale price, or monthly rent for rent listings |
| `currency` | string | Price currency (EUR) |
| `pricePerSqm` | number | Price per m² in € |
| `area` | number | Living area in m² |
| `terrainArea` | number | Plot / terrain area in m², when applicable |
| `rooms` | number | Number of rooms |
| `floor` | number/string | Floor (number, or `cellar` / `attic`) |

#### Location & Media

| Field | Type | Description |
|-------|------|-------------|
| `address` | string | Street address when published |
| `city` | string | City |
| `region` | string | Region / province |
| `images` | string\[] | Listing photo URLs at the largest available resolution |

#### Listing Source & Flags

| Field | Type | Description |
|-------|------|-------------|
| `agencyName` | string | Listing agency name (absent for private sellers) |
| `agencyType` | string | Agency type |
| `isPrivateOwner` | boolean | True when posted by a private owner |
| `isPromoted` | boolean | Promoted / featured listing |
| `isExclusive` | boolean | Exclusive-offer listing |
| `isDevelopment` | boolean | New-construction / development project |
| `developmentTitle` | string | Development name, when applicable |

#### Dates & Provenance

| Field | Type | Description |
|-------|------|-------------|
| `dateCreated` | string | First-published date (ISO 8601) |
| `pushedUpAt` | string | Last bump / refresh date (ISO 8601) |
| `searchQuery` | string | The location and transaction that produced this row |
| `scrapedAt` | string | ISO-8601 timestamp of data collection |

Empty fields are removed from each row, so a listing without a development name or terrain area simply omits those keys.

### Tips for Best Results

- **Start small, then scale.** Set `maxResults` to 50–100 on your first run to confirm the data fits your needs, then raise it — or set it to `0` to pull an entire search.
- **Use district names, not regions.** "Lisboa", "Porto", and "Faro" resolve cleanly; broad region names like "Algarve" don't map to a search and return nothing. For a sub-district like a council, paste a search URL from the portal instead.
- **Remember the Portuguese T-typology.** Room counts follow the "T" system: T0 is a studio, T1 has one bedroom, and so on up to T5+. Pick the `rooms` values that match the typology you want, and combine several to widen the net.
- **Rent prices live in `totalPrice`.** For rent searches, the monthly euro amount is in `totalPrice` — there's no separate rent field to read.
- **Filter at the source to control cost.** Price, area, and room filters narrow the search on Imovirtual itself, so tighter filters mean fewer rows collected and a cheaper run.
- **Paste URLs for pixel-perfect filters.** Any filter you can set on the site — including ones not exposed in the guided builder — carries through when you paste the search URL. The URL's filters win over the guided fields.
- **Separate new builds from resale.** Filter on `isDevelopment` downstream (or set `propertyType` to "New development") to isolate off-plan empreendimento inventory.

### Pricing

**$2.50 per 1,000 results** — below the typical market rate for Imovirtual extraction, with the guided search builder included at no extra charge.

| Results | Estimated Cost |
|---------|----------------|
| 100 | $0.25 |
| 1,000 | $2.50 |
| 10,000 | $25.00 |
| 100,000 | $250.00 |

A "result" is any listing row in the output dataset. **No compute charges — you only pay per result returned.** Standard Apify platform fees depend on your plan.

### Integrations

Export data in JSON, CSV, Excel, XML, or RSS. Connect to 1,500+ apps via:

- **Zapier** / **Make** / **n8n** — Workflow automation
- **Google Sheets** — Direct spreadsheet export
- **Slack** / **Email** — Notifications on new results
- **Webhooks** — Trigger custom APIs on run completion
- **Apify API** — Full programmatic access

### Legal & Ethical Use

This actor is designed for legitimate real-estate research, market analysis, and lead generation. You are responsible for complying with applicable laws and Imovirtual's Terms of Service, including any rules on the reuse of listing content and personal data. Do not use collected data for spam, harassment, or any unlawful purpose, and respect data-protection regulations when handling agency or owner contact information.

# Actor input Schema

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

Paste one or more Imovirtual search-results URLs (for example https://www.imovirtual.com/pt/resultados/comprar/apartamento/lisboa). This is the fastest way to get exactly the results you see on the site. When you provide URLs here, the guided 'Build a Search' fields below are ignored.

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

Are you looking for properties to buy or to rent? Used only when no Search URLs are provided.

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

City or region to search — for example 'Lisboa', 'Porto', 'Algarve' or 'Cascais'. Accents are accepted and recommended.

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

Filter by property category. Mirrors Imovirtual's own categories. Choose 'Any' to include all types.

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

Only include listings at or above this price in euros — monthly rent when renting, total price when buying. Leave empty for no minimum. Used only with the guided 'Build a Search' fields; when you paste Search URLs, the URL controls the filters.

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

Only include listings at or below this price in euros. Leave empty for no maximum.

## `areaMin` (type: `integer`):

Only include properties with living area at or above this many square metres. Leave empty for no minimum.

## `areaMax` (type: `integer`):

Only include properties with living area at or below this many square metres. Leave empty for no maximum.

## `rooms` (type: `array`):

Only include listings with these room counts (Portuguese 'T' typology — T0 is a studio). Select several to combine. Leave empty for any number of rooms.

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

Maximum number of listings to collect per search or URL. Use 50-100 for a quick scan or a higher number for deep research. Results are collected in full pages, so the final page may overshoot this number by a few rows. Set to 0 for no cap (an internal safety limit of 50,000 is then applied).

## Actor input object example

```json
{
  "startUrls": [],
  "transaction": "buy",
  "location": "Lisboa",
  "propertyType": "apartment",
  "rooms": [],
  "maxResults": 100
}
```

# Actor output Schema

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

Table of scraped listings with price, area, rooms, location and URL.

## `detail` (type: `string`):

All extracted fields for every listing.

# 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 = {
    "startUrls": [],
    "transaction": "buy",
    "location": "Lisboa",
    "propertyType": "apartment",
    "rooms": [],
    "maxResults": 100
};

// Run the Actor and wait for it to finish
const run = await client.actor("solidcode/imovirtual-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 = {
    "startUrls": [],
    "transaction": "buy",
    "location": "Lisboa",
    "propertyType": "apartment",
    "rooms": [],
    "maxResults": 100,
}

# Run the Actor and wait for it to finish
run = client.actor("solidcode/imovirtual-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 '{
  "startUrls": [],
  "transaction": "buy",
  "location": "Lisboa",
  "propertyType": "apartment",
  "rooms": [],
  "maxResults": 100
}' |
apify call solidcode/imovirtual-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Imovirtual Scraper",
        "description": "[💰 $2.5 / 1K] Extract property listings from Imovirtual, Portugal's leading real-estate portal. Search by location, buy/rent, property type, price, area and rooms — or paste search URLs — to get prices, areas, locations, photos and agency contacts.",
        "version": "1.0",
        "x-build-id": "SDLEE3OvqYTtfs3XD"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/solidcode~imovirtual-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-solidcode-imovirtual-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/solidcode~imovirtual-scraper/runs": {
            "post": {
                "operationId": "runs-sync-solidcode-imovirtual-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/solidcode~imovirtual-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-solidcode-imovirtual-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": {
                    "startUrls": {
                        "title": "Search URLs",
                        "maxItems": 50,
                        "type": "array",
                        "description": "Paste one or more Imovirtual search-results URLs (for example https://www.imovirtual.com/pt/resultados/comprar/apartamento/lisboa). This is the fastest way to get exactly the results you see on the site. When you provide URLs here, the guided 'Build a Search' fields below are ignored.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "transaction": {
                        "title": "Buy or Rent",
                        "enum": [
                            "buy",
                            "rent"
                        ],
                        "type": "string",
                        "description": "Are you looking for properties to buy or to rent? Used only when no Search URLs are provided.",
                        "default": "buy"
                    },
                    "location": {
                        "title": "Location",
                        "type": "string",
                        "description": "City or region to search — for example 'Lisboa', 'Porto', 'Algarve' or 'Cascais'. Accents are accepted and recommended.",
                        "default": "Lisboa"
                    },
                    "propertyType": {
                        "title": "Property Type",
                        "enum": [
                            "any",
                            "apartment",
                            "house",
                            "land",
                            "commercial",
                            "garage",
                            "room",
                            "warehouse",
                            "development"
                        ],
                        "type": "string",
                        "description": "Filter by property category. Mirrors Imovirtual's own categories. Choose 'Any' to include all types.",
                        "default": "apartment"
                    },
                    "priceMin": {
                        "title": "Minimum Price (€)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only include listings at or above this price in euros — monthly rent when renting, total price when buying. Leave empty for no minimum. Used only with the guided 'Build a Search' fields; when you paste Search URLs, the URL controls the filters."
                    },
                    "priceMax": {
                        "title": "Maximum Price (€)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only include listings at or below this price in euros. Leave empty for no maximum."
                    },
                    "areaMin": {
                        "title": "Minimum Area (m²)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only include properties with living area at or above this many square metres. Leave empty for no minimum."
                    },
                    "areaMax": {
                        "title": "Maximum Area (m²)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only include properties with living area at or below this many square metres. Leave empty for no maximum."
                    },
                    "rooms": {
                        "title": "Rooms",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Only include listings with these room counts (Portuguese 'T' typology — T0 is a studio). Select several to combine. Leave empty for any number of rooms.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "0",
                                "1",
                                "2",
                                "3",
                                "4",
                                "5"
                            ],
                            "enumTitles": [
                                "T0 (studio)",
                                "T1 (1 room)",
                                "T2 (2 rooms)",
                                "T3 (3 rooms)",
                                "T4 (4 rooms)",
                                "T5+ (5 or more rooms)"
                            ]
                        },
                        "default": []
                    },
                    "maxResults": {
                        "title": "Max Results",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum number of listings to collect per search or URL. Use 50-100 for a quick scan or a higher number for deep research. Results are collected in full pages, so the final page may overshoot this number by a few rows. Set to 0 for no cap (an internal safety limit of 50,000 is then applied).",
                        "default": 100
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
