# ZAP Imóveis Scraper (`parsebird/zap-imoveis-scraper`) Actor

Scrape property listings from ZAP Imóveis and VivaReal: prices, condomínio, IPTU, bedrooms, area, location, amenities, lançamentos, and seller contacts. No browser required.

- **URL**: https://apify.com/parsebird/zap-imoveis-scraper.md
- **Developed by:** [ParseBird](https://apify.com/parsebird) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.59 / 1,000 listings

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/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

### ZAP Imóveis Scraper

ZAP Imóveis Scraper extracts property listings from [ZAP Imóveis](https://www.zapimoveis.com.br) and [VivaReal](https://www.vivareal.com.br) — Brazil's two largest real estate portals, both run on the same Grupo OLX backend — without a browser or a single line of scraping code.

<table><tr>
<td style="border-left:4px solid #1C1917;padding:12px 16px;font-weight:600">
Search by business type, listing type, usage type, unit type, state, city, and neighborhood — get price, condomínio, estimated IPTU, area, bedrooms, amenities, lançamento (new development) details, and seller contact, ready for analysis, lead generation, or market monitoring.
</td>
</tr></table>

<br>

##### Copy to your AI assistant

```
Use the Apify Actor "parsebird/zap-imoveis-scraper" (ZAP Imóveis Scraper) to extract property listings from zapimoveis.com.br and vivareal.com.br. Call it with the ApifyClient: `from apify_client import ApifyClient; client = ApifyClient("<APIFY_TOKEN>"); run = client.actor("parsebird/zap-imoveis-scraper").call(run_input={"portal": "ZAP", "business": ["SALE"], "listingType": ["USED"], "usageTypes": ["RESIDENTIAL"], "states": ["SP"], "cities": ["sao-paulo"], "neighborhoods": ["Pinheiros"], "maxListings": 100})`. Key inputs: portal (ZAP/VIVA_REAL), business (array: SALE/RENTAL), listingType (array: USED/DEVELOPMENT for lançamentos), usageTypes (RESIDENTIAL/COMMERCIAL), unitTypes (array, e.g. APARTMENT/HOME/PENTHOUSE), states (array of 2-letter UF codes), cities/neighborhoods (arrays of free-text names), minPrice/maxPrice (BRL integers), minArea/maxArea (m², applied client-side), minBedrooms/minParkingSpaces (integers), guarantorFreeOnly (boolean, rental only), sortBy (relevance/newest/lowest_price/highest_price/lowest_area/highest_area), maxListings (0 = unlimited), and proxyConfiguration (Brazil residential proxy recommended). Output is one JSON object per listing with listingId, portal, url, title, business, priceBRL, condominioMonthlyBRL, iptuMonthlyEstimateBRL, usableArea, bedrooms, uf/city/neighborhood, latitude/longitude, amenities, isLancamento fields, advertiserId/advertiserPhones, imageUrls, and more. Full API spec: https://apify.com/parsebird/zap-imoveis-scraper/api. Get an API token at https://console.apify.com/account/integrations.
```

### What does ZAP Imóveis Scraper do?

ZAP Imóveis Scraper is a **ZAP Imóveis and VivaReal API alternative** that calls the shared Grupo OLX search backend directly — no Puppeteer, no Playwright, no headless Chrome. It returns structured data for sale and rental listings: price, condomínio, estimated IPTU, address and GPS coordinates, bedrooms/bathrooms/suites/parking, usable and total area, amenities, publication tier, seller phone numbers, and photo galleries.

- 🏠 Search **sale (venda) and rental (aluguel)** listings, both **used/resale** and **lançamentos** (new developments/pre-construction)
- 🏢 Filter by **residential or commercial** usage, and by 14 unit types (apartamento, casa, cobertura, sala comercial, galpão, and more)
- 📍 Search any Brazilian state, city, or neighborhood (bairro)
- 💰 Filter by price, area, bedrooms, and parking spaces — and keep only guarantor-free rentals (`guarantorFreeOnly`, based on the accepted rental warranty types)
- 🏗️ Lançamento-specific fields: construction phase, developer name, estimated delivery date, and units available
- 🔀 Detects when a listing is **cross-listed on both ZAP Imóveis and VivaReal**
- 📊 Runs on the Apify platform: schedule recurring runs, trigger via API or webhook, and export results as **JSON, CSV, Excel, or HTML**

### What data can you extract from ZAP Imóveis and VivaReal?

| Field | Description |
|---|---|
| `listingId` / `url` | Stable listing ID and canonical listing URL |
| `title` / `description` | Listing title and marketing description |
| `priceBRL` / `condominioMonthlyBRL` | Asking price or monthly rent, and condomínio fee (BRL) |
| `iptuMonthlyEstimateBRL` / `totalMonthlyCostBRL` | Estimated IPTU and total monthly cost (rentals) |
| `usableArea` / `totalArea` | Usable and total area (m²) |
| `bedrooms` / `bathrooms` / `suites` / `parkingSpaces` | Room counts |
| `uf` / `city` / `neighborhood` / `zone` / `latitude` / `longitude` | Location and GPS coordinates |
| `amenities` / `buildingName` | Building/condomínio amenities and name |
| `isLancamento` / `constructorName` / `launchPhase` | New-development details |
| `advertiserId` / `advertiserPhones` | Seller/agency contact |
| `imageUrls` / `imageCount` | Photo gallery |
| `alsoOnOtherPortal` | Whether the same listing is syndicated across ZAP and VivaReal |

### How to scrape ZAP Imóveis and VivaReal

1. Open ZAP Imóveis Scraper in the [Apify Console](https://console.apify.com) and click **Try for free**.
2. Set `portal` (ZAP or VIVA\_REAL), `business` (e.g. `SALE`), and location — `states`, `cities`, and optionally `neighborhoods`.
3. Optionally narrow results with `unitTypes`, `minPrice`/`maxPrice`, `minArea`/`maxArea`, `minBedrooms`, `minParkingSpaces`, or `guarantorFreeOnly` (rentals).
4. Set `maxListings` to cap how many listings to collect, and click **Start**.
5. Download results as JSON, CSV, or Excel from the **Storage** tab, or pull them via the [Dataset API](https://docs.apify.com/api/v2#/reference/datasets).

### How much does it cost to scrape ZAP Imóveis?

ZAP Imóveis Scraper uses [pay-per-event pricing](https://docs.apify.com/platform/actors/publishing/monetize#pay-per-event-pricing) — you only pay for listings actually returned, no compute-unit math required.

| Plan | Price per listing | Price per 1,000 listings |
|---|---|---|
| Free | $0.00189 | **$1.89** |
| Bronze | $0.00179 | **$1.79** |
| Silver | $0.00169 | **$1.69** |
| Gold | $0.00159 | **$1.59** |

Example: collecting 1,000 apartment listings for sale in São Paulo costs $1.89 on the Free plan. New Apify accounts include free platform usage credit that covers testing this Actor.

### Input / Output

The input schema exposes every filter above through the Apify Console UI, or as JSON via the API — no need to hand-craft ZAP Imóveis search URLs.

```json
{
  "portal": "ZAP",
  "business": ["SALE"],
  "listingType": ["USED"],
  "usageTypes": ["RESIDENTIAL"],
  "states": ["SP"],
  "cities": ["sao-paulo"],
  "neighborhoods": ["Pinheiros"],
  "maxListings": 100
}
```

Output — one JSON object per listing:

```json
{
  "recordType": "listing",
  "listingId": "2814207417",
  "portal": "ZAP",
  "url": "https://www.zapimoveis.com.br/imovel/2814207417/",
  "title": "Apartamento com 2 quartos à venda e para alugar em Pinheiros, São Paulo",
  "business": "SALE",
  "priceBRL": 2650000,
  "condominioMonthlyBRL": 2060,
  "pricePerSqmBRL": 31176.47,
  "usableArea": 85,
  "bedrooms": 2,
  "parkingSpaces": 2,
  "uf": "SP",
  "city": "São Paulo",
  "neighborhood": "Pinheiros",
  "latitude": -23.563579,
  "longitude": -46.691607,
  "isLancamento": false,
  "advertiserPhones": ["11944822247"],
  "imageCount": 30
}
```

Results can be downloaded as **JSON, CSV, Excel, or HTML** from the Storage tab, or fetched via the [Apify API](https://docs.apify.com/api/v2).

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient("<APIFY_TOKEN>")
run = client.actor("parsebird/zap-imoveis-scraper").call(run_input={
    "portal": "ZAP",
    "business": ["SALE"],
    "states": ["SP"],
    "cities": ["sao-paulo"],
    "neighborhoods": ["Pinheiros"],
    "maxListings": 100,
})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["title"], item["priceBRL"])
```

#### JavaScript

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: '<APIFY_TOKEN>' });
const run = await client.actor('parsebird/zap-imoveis-scraper').call({
    portal: 'ZAP',
    business: ['SALE'],
    states: ['SP'],
    cities: ['sao-paulo'],
    neighborhoods: ['Pinheiros'],
    maxListings: 100,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### Use cases

- **Market research** — track average price per m² by neighborhood or city over time.
- **Lead generation** — pull seller phone numbers for a target neighborhood and price range.
- **Lançamento tracking** — monitor new developments by developer, delivery date, or construction phase.
- **Rental hunting** — filter guarantor-free rentals (`guarantorFreeOnly`) for renters without a fiador.
- **Portfolio monitoring** — re-run on a schedule to catch new listings matching your investment criteria.
- **Feed a PropTech app** — combine with [Data Deduplicator](https://apify.com/parsebird/dataset-deduplicator) to keep a clean, de-duplicated property feed.

### Is it legal to scrape ZAP Imóveis and VivaReal?

Yes. ZAP Imóveis Scraper only collects publicly available listing data, the same information any visitor sees on ZAP Imóveis or VivaReal. Scraping publicly accessible data is generally legal, but you're responsible for complying with the target site's terms of service and applicable data protection laws (such as Brazil's LGPD) for your specific use case. See Apify's [blog post on the legality of web scraping](https://blog.apify.com/is-web-scraping-legal/) for more detail.

### Related Actors

- [Imovelweb Scraper](https://apify.com/parsebird/imovelweb-scraper) — property listings from Imovelweb.com.br, Brazil's other major real estate portal
- [Data Deduplicator](https://apify.com/parsebird/dataset-deduplicator) — remove duplicate listings across multiple scraper runs
- [HTTP Request Actor](https://apify.com/parsebird/http-request-actor) — call any REST API from your Apify workflow

### FAQ

**How fresh is the data?**
Every run fetches live data directly from the ZAP Imóveis/VivaReal backend at the time it executes — nothing is cached.

**What's the difference between ZAP Imóveis and VivaReal here?**
Both portals are run by Grupo OLX and share the same search backend. Set `portal` to `ZAP` or `VIVA_REAL` to control which brand's listing URLs and headers are used; the `alsoOnOtherPortal` output field tells you when a listing is syndicated to both.

**Does this cover rentals and new developments, not just resale sales?**
Yes. Set `business` to `RENTAL` for aluguel, and `listingType` to `DEVELOPMENT` for lançamentos (pre-construction/under-construction developments).

**Why do `states` and `cities` behave as a cross-product?**
Every combination of `states` × `cities` × `neighborhoods` is searched. If you provide `states: ["SP", "RJ"]` and `cities: ["sao-paulo", "rio-de-janeiro"]`, mismatched combinations (e.g. SP + Rio de Janeiro) simply return zero results — no error, just wasted requests. For independent city/state pairs, run separate Actor calls.

**Why does a city name sometimes return zero results?**
The search API matches on the full accented Portuguese state/city name (e.g. "São Paulo"), not a 2-letter code or URL slug. 60+ major municipalities are normalized automatically from common slugs (`sao-paulo`, `rio-de-janeiro`, etc.); for an unrecognized city, provide the full accented name directly.

**Can I schedule recurring runs?**
Yes. Use Apify's built-in [Scheduler](https://docs.apify.com/platform/schedules) to run daily, weekly, or at any interval, and trigger downstream automations via webhooks.

**Can I access this via API instead of the Console?**
Yes — every input field is available through the [Apify API](https://apify.com/parsebird/zap-imoveis-scraper/api), with client libraries for Python, JavaScript/Node.js, and more.

**Found a bug or missing field?**
Please open an issue on the Actor's **Issues** tab — feedback is reviewed regularly and helps prioritize fixes.

# Actor input Schema

## `portal` (type: `string`):

ZAP Imóveis and VivaReal share the same listings backend (Grupo OLX) — pick which brand's URLs and headers to use.

## `business` (type: `array`):

Venda (sale) or aluguel (rental).

## `listingType` (type: `array`):

USED = existing resale/rental stock. DEVELOPMENT = lançamentos (new developments/pre-construction).

## `usageTypes` (type: `array`):

Residential or commercial properties.

## `unitTypes` (type: `array`):

Optional property-type filter. Leave empty to include every unit type.

## `states` (type: `array`):

2-letter Brazilian state codes to search. Leave empty to search nationwide (very broad — combine with cities/neighborhoods instead for most use cases).

## `cities` (type: `array`):

City names or slugs, e.g. "sao-paulo" or "São Paulo". 60+ major municipalities are recognized automatically; other cities are used as typed, so prefer the full accented Portuguese name (e.g. "Ribeirão Preto") if a slug returns no results.

## `neighborhoods` (type: `array`):

Bairro names, e.g. "Pinheiros". Requires exactly one city above — each neighborhood is searched against every city/state combination, so keep this to a single city for predictable results.

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

Minimum sale price or monthly rent in BRL. 0 = no minimum.

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

Maximum sale price or monthly rent in BRL. 0 = no maximum.

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

Minimum usable area. Applied to the collected results.

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

Maximum usable area. Applied to the collected results.

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

Minimum number of quartos. 0 = no minimum.

## `minParkingSpaces` (type: `integer`):

Minimum number of vagas. 0 = no minimum.

## `guarantorFreeOnly` (type: `boolean`):

For rentals, keep only listings that accept a rental guarantee alternative to a fiador (guarantor) — e.g. security deposit, insurance guarantee, or capitalization bond.

## `sortBy` (type: `string`):

Sorts the listings collected in this run. Applied after fetching, since the source API does not honor a reliable sort order.

## `maxListings` (type: `integer`):

Hard cap on total listings saved across every location/business/listing-type combination. 0 = unlimited (bounded only by Max pages per task).

## `maxPagesPerTask` (type: `integer`):

Cap on pages fetched per state/city/neighborhood/business/listing-type combination. Each page returns up to Page size listings (slightly fewer on broad searches, since a few slots go to sponsored placements); the source API stops serving results after roughly page 47 (~1,400 listings) per combination regardless of this setting.

## `pageSize` (type: `integer`):

Listings requested per page. The source API rejects values above 30.

## `requestDelayMs` (type: `integer`):

Pause between consecutive page requests, to stay well under any rate limits.

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

How many location/business/listing-type tasks to run in parallel.

## `maxRetries` (type: `integer`):

Retries per failed request (network errors or 5xx responses) with exponential backoff.

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

The ZAP Imóveis / VivaReal listings API sits behind Cloudflare bot management. A Brazil-based residential proxy is recommended for reliable results.

## Actor input object example

```json
{
  "portal": "ZAP",
  "business": [
    "SALE"
  ],
  "listingType": [
    "USED"
  ],
  "usageTypes": [
    "RESIDENTIAL"
  ],
  "unitTypes": [],
  "states": [
    "SP"
  ],
  "cities": [
    "sao-paulo"
  ],
  "neighborhoods": [],
  "minPrice": 0,
  "maxPrice": 0,
  "minArea": 0,
  "maxArea": 0,
  "minBedrooms": 0,
  "minParkingSpaces": 0,
  "guarantorFreeOnly": false,
  "sortBy": "relevance",
  "maxListings": 100,
  "maxPagesPerTask": 10,
  "pageSize": 30,
  "requestDelayMs": 500,
  "maxConcurrency": 2,
  "maxRetries": 3,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "BR"
  }
}
```

# Actor output Schema

## `dataset` (type: `string`):

No description

# 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 = {
    "portal": "ZAP",
    "business": [
        "SALE"
    ],
    "listingType": [
        "USED"
    ],
    "usageTypes": [
        "RESIDENTIAL"
    ],
    "states": [
        "SP"
    ],
    "cities": [
        "sao-paulo"
    ],
    "maxListings": 100,
    "maxPagesPerTask": 10,
    "pageSize": 30,
    "requestDelayMs": 500,
    "maxConcurrency": 2,
    "maxRetries": 3,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "BR"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("parsebird/zap-imoveis-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 = {
    "portal": "ZAP",
    "business": ["SALE"],
    "listingType": ["USED"],
    "usageTypes": ["RESIDENTIAL"],
    "states": ["SP"],
    "cities": ["sao-paulo"],
    "maxListings": 100,
    "maxPagesPerTask": 10,
    "pageSize": 30,
    "requestDelayMs": 500,
    "maxConcurrency": 2,
    "maxRetries": 3,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "BR",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("parsebird/zap-imoveis-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 '{
  "portal": "ZAP",
  "business": [
    "SALE"
  ],
  "listingType": [
    "USED"
  ],
  "usageTypes": [
    "RESIDENTIAL"
  ],
  "states": [
    "SP"
  ],
  "cities": [
    "sao-paulo"
  ],
  "maxListings": 100,
  "maxPagesPerTask": 10,
  "pageSize": 30,
  "requestDelayMs": 500,
  "maxConcurrency": 2,
  "maxRetries": 3,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "BR"
  }
}' |
apify call parsebird/zap-imoveis-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,parsebird/zap-imoveis-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/zhRrF6CrGqfj1TEwJ/builds/74PRGjDWhajJ02ydZ/openapi.json
