# Imovelweb Brazil Scraper (`solidcode/imovelweb-br-scraper`) Actor

\[💰 $1.3 / 1K] Extract real estate listings from Imovelweb Brazil — apartments, houses, land, and commercial for sale, rent, temporary stay, and new developments. Get price, beds, baths, area, address, GPS, photos, videos, amenities, seller/agency, and contact details.

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

## Pricing

from $1.30 / 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.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are 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/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

## Imovelweb Brazil Scraper

Pull real estate listings from Imovelweb Brazil (imovelweb.com.br) at scale — asking price and condo fees, bedrooms, bathrooms and area in m², full-address and GPS coordinates, photo galleries, and advertiser contacts including WhatsApp. Search apartments, houses, land, and commercial property for sale, for rent, for temporary stay, or as new developments (lançamentos). Built for Brazilian real estate investors, agencies, proptech teams, and market researchers who need clean, structured listing data without copy-pasting from the site one card at a time.

### Why This Scraper?

- **Four deal types in one actor** — for sale (venda), for rent (aluguel), temporary stay (temporada), and new developments (lançamentos), switched with a single dropdown.
- **14 property types** — apartment, house, condo house, penthouse, flat, studio (kitnet), land, country house, farm, office, retail/shop, warehouse, whole building, or garage.
- **GPS coordinates on every listing** — exact latitude and longitude, ready to map or geo-join, alongside street, neighborhood, city, state (UF), and CEP.
- **Owner-vs-agency advertiser filter** — pull direct-owner listings only, real-estate-agency listings only, or both, and every row is tagged with which one it is.
- **Seven numeric range filters** — minimum/maximum price in R$, minimum/maximum bedrooms, minimum bathrooms, minimum parking spaces, and minimum/maximum total area in m².
- **Paste a URL or build a search** — drop in any imovelweb.com.br search or listing link and every filter is read straight from it, or build a search from scratch with plain dropdowns and number fields. The scraper handles both.
- **Full media on every row** — photo gallery URLs plus video links and virtual-tour, video, and floor-plan availability flags.
- **Advertiser contacts included** — agency or owner name, license, profile link and logo, phone, and WhatsApp number where the listing publishes them.
- **Flat one-row-per-property output** — 40+ fields per listing in a single flat row that drops straight into Sheets, Excel, or a database, with no nested objects to untangle.

### Use Cases

**Market Research**
- Map inventory by city, neighborhood, or state across Brazil
- Compare apartment vs. house pricing in the same district
- Track new-development (lançamento) supply in growth corridors
- Measure listing counts and median asking prices per neighborhood

**Investment Analysis**
- Compute price per m² across neighborhoods using totalArea and usableArea
- Benchmark asking prices against condo fees (condomínio) and IPTU
- Identify undervalued listings within a tight price and area band
- Build comparables (comps) sets for a target CEP or district

**Lead Generation**
- Build advertiser contact lists with agency name, phone, and WhatsApp
- Isolate direct-owner listings to reach sellers without an intermediary
- Target real-estate agencies by volume of active listings
- Feed fresh listings into a CRM as they appear

**Proptech & Data Enrichment**
- Power a property portal or valuation model with live Brazilian inventory
- Enrich an existing property database with coordinates and media
- Feed dashboards that track supply, pricing, and days-on-market
- Trigger alerts when new listings match a saved search

**Price Benchmarking**
- Compare rent (aluguel) vs. temporary-stay (temporada) pricing per area
- Track asking-price changes for a fixed neighborhood over time
- Segment the market by property type, room count, and area

### Getting Started

#### Search by Location

The simplest way to start — one city and a result cap:

```json
{
    "location": ["São Paulo SP"],
    "maxResults": 100
}
````

#### Filtered Search

For-sale apartments in a price and room band, agencies only:

```json
{
    "location": ["Pinheiros São Paulo"],
    "dealType": "venda",
    "propertyTypes": ["apartamento"],
    "publisherType": "agency",
    "minPrice": 800000,
    "maxPrice": 1500000,
    "minBedrooms": 2,
    "minArea": 70,
    "maxResults": 100
}
```

#### Paste Imovelweb URLs

Already built a search on the site? Paste the link and every filter is read from it:

```json
{
    "startUrls": [
        "https://www.imovelweb.com.br/apartamentos-venda-sao-paulo-sp.html",
        "https://www.imovelweb.com.br/casas-aluguel-rio-de-janeiro-rj.html"
    ],
    "maxResults": 250
}
```

Each URL returns roughly its first ~100-120 listings, so this two-URL run collects up to ~240. To go deeper, split each search into narrower ones (by neighborhood, price band, or property type) and add them here — each added search returns its own ~120-listing batch.

#### Advanced Search

Rentals across multiple cities with the full filter set:

```json
{
    "location": ["Belo Horizonte MG", "Copacabana Rio de Janeiro"],
    "dealType": "aluguel",
    "propertyTypes": ["apartamento", "cobertura", "flat"],
    "publisherType": "all",
    "minPrice": 2000,
    "maxPrice": 8000,
    "minBedrooms": 2,
    "maxBedrooms": 4,
    "minBathrooms": 2,
    "minParking": 1,
    "minArea": 60,
    "maxArea": 200,
    "maxResults": 300
}
```

This run fans out across two cities and three property types (six searches), each returning up to ~120 listings, so it can reach several hundred rows in one go.

### Input Reference

#### What to Scrape

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `startUrls` | string\[] | `["https://www.imovelweb.com.br/apartamentos-venda-sao-paulo-sp.html"]` | Paste one or more imovelweb.com.br search-result or individual listing URLs. Every filter is read straight from each URL, so the Search Filters below are ignored for these. |
| `location` | string\[] | `[]` | Where to search — a Brazilian city, neighborhood, or state, e.g. "São Paulo SP", "Copacabana Rio de Janeiro", or "Belo Horizonte MG". Each location is searched separately. |

#### Search Filters

Apply only when `startUrls` is empty.

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `dealType` | select | `For sale` | For sale, For rent, Temporary stay, or New developments (lançamentos). |
| `propertyTypes` | multi-select | `[]` (all) | One or more of 14 types: Apartment, House, Condo house, Penthouse, Flat, Studio (Kitnet), Land / lot, Country house, Farm, Office, Retail / shop, Warehouse, Whole building, Garage. |
| `publisherType` | select | `All advertisers` | All advertisers, Real estate agencies only, or Direct owners only. |

#### Price, Rooms & Size

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `minPrice` | integer | — | Only listings at or above this price, in Brazilian Reais (R$). |
| `maxPrice` | integer | — | Only listings at or below this price, in Brazilian Reais (R$). |
| `minBedrooms` | integer | — | Minimum number of bedrooms. |
| `maxBedrooms` | integer | — | Maximum number of bedrooms. |
| `minBathrooms` | integer | — | Minimum number of bathrooms. |
| `minParking` | integer | — | Minimum number of parking spaces. |
| `minArea` | integer | — | Minimum total area, in square meters (m²). |
| `maxArea` | integer | — | Maximum total area, in square meters (m²). |

#### Options

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `maxResults` | integer | `100` | Maximum listings to collect across all URLs and locations. Each individual search returns roughly its first ~100-120 listings, so add more locations or URLs to reach higher totals. Set to 0 for unlimited (bounded by how deep each search can be read). |

### Output

Each listing is one flat row. Here is a representative result:

```json
{
    "id": "3022824235",
    "postingCode": "3022824235",
    "url": "https://www.imovelweb.com.br/propriedades/clacod-3022824235.html",
    "title": "Apartamento à Venda - Pinheiros, 2 Quartos, 118 m²",
    "description": "Excelente apartamento em Pinheiros, próximo ao metrô, com 2 dormitórios, sala ampla, varanda e 1 vaga de garagem...",
    "dealType": "Venda",
    "propertyType": "Apartamento",
    "postingType": "PROPERTY",
    "price": 1200000,
    "currency": "BRL",
    "priceText": "R$ 1.200.000",
    "condoFee": 950,
    "iptu": 320,
    "bedrooms": 2,
    "bathrooms": 2,
    "suites": 1,
    "parkingSpaces": 1,
    "totalArea": 118,
    "usableArea": 73,
    "age": "10",
    "street": "Rua dos Pinheiros",
    "neighborhood": "Pinheiros",
    "city": "São Paulo",
    "state": "SP",
    "postalCode": "05422-001",
    "latitude": -23.5580084,
    "longitude": -46.6755559,
    "images": [
        "https://imgbr.imovelwebcdn.com/avisos/1/30/22/82/42/35/1200x1200/example1.jpg"
    ],
    "videos": [],
    "amenities": ["Piscina", "Academia", "Portaria 24h", "Varanda"],
    "hasVideos": false,
    "hasTour": false,
    "hasPlans": true,
    "publishedAt": "2026-05-28",
    "updatedAt": "2026-07-10",
    "isFeatured": true,
    "publisherType": "agency",
    "seller": {
        "id": 12345,
        "name": "ZIMMERMANN IMÓVEIS",
        "license": "CRECI 12345-J",
        "url": "https://www.imovelweb.com.br/imobiliarias/zimmermann-imoveis.html",
        "logo": "https://imgbr.imovelwebcdn.com/empresas/logo.jpg"
    },
    "phones": ["5511999998888"],
    "whatsapp": "5511999998888"
}
```

#### Core Fields

| Field | Type | Description |
|-------|------|-------------|
| `id` | string | Stable Imovelweb listing/posting ID |
| `postingCode` | string | Listing reference code |
| `url` | string | Canonical listing URL |
| `title` | string | Listing title |
| `description` | string | Listing description text |
| `dealType` | string | Deal type: Venda, Aluguel, Temporada, or Lançamento |
| `propertyType` | string | Apartamento, Casa, Terreno, etc. |
| `postingType` | string | PROPERTY or DEVELOPMENT (new development) |
| `isFeatured` | boolean | Whether the listing is sponsored/featured |
| `publishedAt` | string | Publication date |
| `updatedAt` | string | Last-updated date |

#### Price & Costs

| Field | Type | Description |
|-------|------|-------------|
| `price` | number | Numeric price |
| `currency` | string | Currency code (e.g. BRL) |
| `priceText` | string | Price exactly as shown on the site |
| `condoFee` | number | Monthly condominium fee (condomínio) if present |
| `iptu` | number | IPTU property tax if present |

#### Rooms & Size

| Field | Type | Description |
|-------|------|-------------|
| `bedrooms` | integer | Number of bedrooms |
| `bathrooms` | integer | Number of bathrooms |
| `suites` | integer | Number of en-suite bedrooms |
| `parkingSpaces` | integer | Number of parking spaces |
| `totalArea` | number | Total area (m²) |
| `usableArea` | number | Usable area (m²) |
| `age` | string | Property age where published |

#### Address & Location

| Field | Type | Description |
|-------|------|-------------|
| `street` | string | Street/address label |
| `neighborhood` | string | Neighborhood (bairro) |
| `city` | string | City |
| `state` | string | State (UF) |
| `postalCode` | string | CEP if present |
| `latitude` | number | Latitude |
| `longitude` | number | Longitude |

#### Media & Amenities

| Field | Type | Description |
|-------|------|-------------|
| `images` | string\[] | Photo gallery URLs (up to 8 per search listing) |
| `videos` | string\[] | Video URLs where present |
| `amenities` | string\[] | Amenity and feature labels (e.g. Piscina, Academia) |
| `hasVideos` | boolean | Whether the listing has video |
| `hasTour` | boolean | Whether the listing has a virtual tour |
| `hasPlans` | boolean | Whether the listing has floor plans |

#### Advertiser & Contact

| Field | Type | Description |
|-------|------|-------------|
| `publisherType` | string | agency or owner |
| `seller` | object | Advertiser: name, license, id, profile URL, logo |
| `phones` | string\[] | Contact phone number(s) |
| `whatsapp` | string | WhatsApp number where the listing publishes it |

### Tips for Best Results

- **Start small** — set `maxResults` to 50-100 on your first run to confirm the data matches your needs, then scale up.
- **Split searches to go deeper** — each search returns roughly its first ~100-120 listings, because Imovelweb limits how deep an automated search can page. A single whole-city query therefore surfaces about 120 listings, not the whole market. To gather more, split into narrower searches — by neighborhood (bairro), price band, or property type — and run them together; each one returns its own ~120-listing batch, so ten tight searches collect roughly ten times what one broad query returns.
- **Paste a URL when you need a filter we don't list** — any filter you can set on the site (recency, in-unit features, transit proximity) is honored when you paste the finished search URL into `startUrls`.
- **Use the advertiser filter for cleaner leads** — set `publisherType` to Direct owners only to reach sellers directly, or Real estate agencies only to build an agency contact list.
- **Combine locations in one run** — list several cities or neighborhoods in `location` and each is searched separately, then merged into one deduplicated dataset.
- **Filter by property type to cut noise** — selecting only the types you care about avoids paying for listings you'll discard later.
- **Compare totalArea with usableArea** — the gap between them reveals balcony/common-area loading and sharpens any price-per-m² comparison.

### Pricing

**From $1.30 per 1,000 results** — a flat pay-per-result rate that undercuts other Imovelweb actors on the market. No compute or time-based charges — you pay per result, plus a small fixed per-run start fee. Bronze, Silver, and Gold subscribers pay progressively less; the table below shows total cost at each discount tier.

| Results | No discount | Bronze | Silver | Gold |
|---------|-------------|--------|--------|------|
| 100 | $0.16 | $0.15 | $0.14 | $0.13 |
| 1,000 | $1.55 | $1.45 | $1.40 | $1.30 |
| 10,000 | $15.50 | $14.50 | $14.00 | $13.00 |
| 100,000 | $155 | $145 | $140 | $130 |

A "result" is any property row in the output dataset. Platform fees (compute, storage) are additional and depend on your Apify 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 Imovelweb's Terms of Service. Do not use extracted data for spam, harassment, or any unlawful purpose, and handle any personal contact data in line with Brazil's LGPD and other applicable privacy regulations.

# Actor input Schema

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

Paste one or more imovelweb.com.br URLs — either search-result pages (for example https://www.imovelweb.com.br/apartamentos-venda-sao-paulo-sp.html) or individual listing pages. The scraper reads every filter straight from each URL, so the Search Filters below are ignored for these. Use this when you already built a search on the site.

## `location` (type: `array`):

Where to search. Enter a Brazilian city, neighborhood, or state — for example 'São Paulo SP', 'Copacabana Rio de Janeiro', or 'Belo Horizonte MG'. Each location is searched separately. Leave empty to search all of Brazil, or when you are pasting URLs above.

## `dealType` (type: `string`):

Whether to find properties for sale, for rent, for a temporary stay, or new developments (lançamentos). Only applies when you build a search below (not when pasting URLs).

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

Which kinds of property to include. Leave empty to include all types.

## `publisherType` (type: `string`):

Filter listings by who posted them: everyone, real estate agencies only, or direct owners only. 'Direct owners only' is applied by the site; 'Real estate agencies only' is applied after retrieval to the listings read, so a run using it may return fewer results.

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

Only include listings at or above this price, in Brazilian Reais. Leave empty for no minimum.

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

Only include listings at or below this price, in Brazilian Reais. Leave empty for no maximum.

## `minBedrooms` (type: `integer`):

Only include listings with at least this many bedrooms. Leave empty for any.

## `maxBedrooms` (type: `integer`):

Only include listings with no more than this many bedrooms. Applied after retrieval to the listings read; listings that don't report a bedroom count are excluded, and very restrictive values may return fewer results. Leave empty for any.

## `minBathrooms` (type: `integer`):

Only include listings with at least this many bathrooms. Applied after retrieval to the listings read; listings that don't report a bathroom count are excluded, and very restrictive values may return fewer results. Leave empty for any.

## `minParking` (type: `integer`):

Only include listings with at least this many parking spaces. Applied after retrieval to the listings read; listings that don't report parking are excluded, and very restrictive values may return fewer results. Leave empty for any.

## `minArea` (type: `integer`):

Only include listings with at least this much total area, in square meters. Applied after retrieval to the listings read; listings that don't report an area are excluded, and very restrictive values may return fewer results. Leave empty for no minimum.

## `maxArea` (type: `integer`):

Only include listings with no more than this much total area, in square meters. Applied after retrieval to the listings read; listings that don't report an area are excluded. Leave empty for no maximum.

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

Maximum number of listings to collect across all URLs and locations. Set to 0 for unlimited (bounded by how deep each search can be read). Note: Imovelweb gates deep pagination, so each individual search or URL returns roughly its first 100–120 listings (about 4 pages). To collect more, split the search into several narrower ones — by neighborhood, price band, or property type — and each returns its own ~120; add them as separate locations or URLs in one run.

## Actor input object example

```json
{
  "startUrls": [
    "https://www.imovelweb.com.br/apartamentos-venda-sao-paulo-sp.html"
  ],
  "location": [],
  "dealType": "venda",
  "propertyTypes": [],
  "publisherType": "all",
  "maxResults": 100
}
```

# Actor output Schema

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

Table of scraped listings with key fields.

## `details` (type: `string`):

All fields including rooms, area, address, coordinates, media, seller, and contacts.

# 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": [
        "https://www.imovelweb.com.br/apartamentos-venda-sao-paulo-sp.html"
    ],
    "location": [],
    "dealType": "venda",
    "propertyTypes": [],
    "publisherType": "all",
    "maxResults": 100
};

// Run the Actor and wait for it to finish
const run = await client.actor("solidcode/imovelweb-br-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": ["https://www.imovelweb.com.br/apartamentos-venda-sao-paulo-sp.html"],
    "location": [],
    "dealType": "venda",
    "propertyTypes": [],
    "publisherType": "all",
    "maxResults": 100,
}

# Run the Actor and wait for it to finish
run = client.actor("solidcode/imovelweb-br-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": [
    "https://www.imovelweb.com.br/apartamentos-venda-sao-paulo-sp.html"
  ],
  "location": [],
  "dealType": "venda",
  "propertyTypes": [],
  "publisherType": "all",
  "maxResults": 100
}' |
apify call solidcode/imovelweb-br-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Imovelweb Brazil Scraper",
        "description": "[💰 $1.3 / 1K] Extract real estate listings from Imovelweb Brazil — apartments, houses, land, and commercial for sale, rent, temporary stay, and new developments. Get price, beds, baths, area, address, GPS, photos, videos, amenities, seller/agency, and contact details.",
        "version": "1.0",
        "x-build-id": "moTjhbkSA5WUhn6dJ"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/solidcode~imovelweb-br-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-solidcode-imovelweb-br-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~imovelweb-br-scraper/runs": {
            "post": {
                "operationId": "runs-sync-solidcode-imovelweb-br-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~imovelweb-br-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-solidcode-imovelweb-br-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": "Imovelweb URLs",
                        "type": "array",
                        "description": "Paste one or more imovelweb.com.br URLs — either search-result pages (for example https://www.imovelweb.com.br/apartamentos-venda-sao-paulo-sp.html) or individual listing pages. The scraper reads every filter straight from each URL, so the Search Filters below are ignored for these. Use this when you already built a search on the site.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "location": {
                        "title": "Locations",
                        "type": "array",
                        "description": "Where to search. Enter a Brazilian city, neighborhood, or state — for example 'São Paulo SP', 'Copacabana Rio de Janeiro', or 'Belo Horizonte MG'. Each location is searched separately. Leave empty to search all of Brazil, or when you are pasting URLs above.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "dealType": {
                        "title": "Deal Type",
                        "enum": [
                            "venda",
                            "aluguel",
                            "temporada",
                            "lancamento"
                        ],
                        "type": "string",
                        "description": "Whether to find properties for sale, for rent, for a temporary stay, or new developments (lançamentos). Only applies when you build a search below (not when pasting URLs)."
                    },
                    "propertyTypes": {
                        "title": "Property Types",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Which kinds of property to include. Leave empty to include all types.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "apartamento",
                                "casa",
                                "casa-condominio",
                                "cobertura",
                                "flat",
                                "kitnet",
                                "terreno",
                                "sitio-chacara",
                                "fazenda",
                                "sala-comercial",
                                "loja-ponto-comercial",
                                "galpao-deposito",
                                "predio-inteiro",
                                "garagem"
                            ],
                            "enumTitles": [
                                "Apartment (Apartamento)",
                                "House (Casa)",
                                "Condo house (Casa em condomínio)",
                                "Penthouse (Cobertura)",
                                "Flat",
                                "Studio (Kitnet)",
                                "Land / lot (Terreno)",
                                "Country house (Sítio / Chácara)",
                                "Farm (Fazenda)",
                                "Office (Sala comercial)",
                                "Retail / shop (Loja / Ponto comercial)",
                                "Warehouse (Galpão / Depósito)",
                                "Whole building (Prédio inteiro)",
                                "Garage (Garagem)"
                            ]
                        }
                    },
                    "publisherType": {
                        "title": "Advertiser Type",
                        "enum": [
                            "all",
                            "agency",
                            "owner"
                        ],
                        "type": "string",
                        "description": "Filter listings by who posted them: everyone, real estate agencies only, or direct owners only. 'Direct owners only' is applied by the site; 'Real estate agencies only' is applied after retrieval to the listings read, so a run using it may return fewer results."
                    },
                    "minPrice": {
                        "title": "Minimum Price (R$)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only include listings at or above this price, in Brazilian Reais. Leave empty for no minimum."
                    },
                    "maxPrice": {
                        "title": "Maximum Price (R$)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only include listings at or below this price, in Brazilian Reais. Leave empty for no maximum."
                    },
                    "minBedrooms": {
                        "title": "Minimum Bedrooms",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only include listings with at least this many bedrooms. Leave empty for any."
                    },
                    "maxBedrooms": {
                        "title": "Maximum Bedrooms",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only include listings with no more than this many bedrooms. Applied after retrieval to the listings read; listings that don't report a bedroom count are excluded, and very restrictive values may return fewer results. Leave empty for any."
                    },
                    "minBathrooms": {
                        "title": "Minimum Bathrooms",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only include listings with at least this many bathrooms. Applied after retrieval to the listings read; listings that don't report a bathroom count are excluded, and very restrictive values may return fewer results. Leave empty for any."
                    },
                    "minParking": {
                        "title": "Minimum Parking Spaces",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only include listings with at least this many parking spaces. Applied after retrieval to the listings read; listings that don't report parking are excluded, and very restrictive values may return fewer results. Leave empty for any."
                    },
                    "minArea": {
                        "title": "Minimum Area (m²)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only include listings with at least this much total area, in square meters. Applied after retrieval to the listings read; listings that don't report an area are excluded, and very restrictive values may return fewer results. Leave empty for no minimum."
                    },
                    "maxArea": {
                        "title": "Maximum Area (m²)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only include listings with no more than this much total area, in square meters. Applied after retrieval to the listings read; listings that don't report an area are excluded. Leave empty for no maximum."
                    },
                    "maxResults": {
                        "title": "Max Results",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum number of listings to collect across all URLs and locations. Set to 0 for unlimited (bounded by how deep each search can be read). Note: Imovelweb gates deep pagination, so each individual search or URL returns roughly its first 100–120 listings (about 4 pages). To collect more, split the search into several narrower ones — by neighborhood, price band, or property type — and each returns its own ~120; add them as separate locations or URLs in one run."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
