# ZonaProp Listing Extractor (`kawsar/zonaprop-listing-extractor`) Actor

Extract structured property data from Argentina's largest real estate portal. Paste any ZonaProp search URL by location, type, or price range and get price, surface area, rooms, GPS coordinates, images, and agency details. Paginates automatically, up to 10,000 listings per URL.

- **URL**: https://apify.com/kawsar/zonaprop-listing-extractor.md
- **Developed by:** [Kawsar](https://apify.com/kawsar) (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 $4.99 / 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.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

## ZonaProp Listing Extractor

ZonaProp Listing Extractor scrapes property listings from any ZonaProp search page and returns them as structured records. Give it one or more filtered search URLs and it pages through results automatically, collecting up to your set limit **per URL**.

### What it extracts

For each listing the actor returns:

- **ID and URL** — posting ID, posting code, and direct link to the listing page
- **Price** — amount and currency (USD or ARS) for sale or rental operations
- **Monthly expenses** — expensas amount and currency
- **Property features** — total surface, covered surface, rooms, bedrooms, bathrooms, parking spaces, toilettes, and property age
- **Location** — street address, neighborhood, city, country, and GPS coordinates (latitude and longitude)
- **Images** — list of all listing photo URLs (730×532 resolution)
- **Agency info** — agency name, profile URL, and professional license number
- **Property type** — apartment, house, office, commercial, land, and more
- **Description** — full listing description text
- **Media flags** — whether the listing includes videos or a 360-degree virtual tour
- **Timestamps** — last modified date and scrape time

### How to use

1. Go to [zonaprop.com.ar](https://www.zonaprop.com.ar) and apply your filters (location, property type, sale or rent, price range, etc.)
2. Copy the URL from your browser
3. Paste it into the **Start URLs** field in the actor input
4. Set **Max items** to however many listings you need **per URL**
5. Run the actor and download results as JSON, CSV, or Excel

#### Example input

```json
{
  "startUrls": [
    "https://www.zonaprop.com.ar/departamentos-venta-capital-federal.html",
    "https://www.zonaprop.com.ar/casas-alquiler-buenos-aires.html"
  ],
  "maxItems": 500,
  "requestTimeoutSecs": 30
}
````

With this input the actor collects up to **500 listings from each URL**, yielding up to 1,000 records in total.

#### Example output

```json
{
  "postingId": "58561169",
  "postingCode": "CAP7850638",
  "listingTitle": "Departamento en Palermo",
  "generatedTitle": "Departamento 102m2 4 Ambientes 1 Cochera",
  "listingUrl": "https://www.zonaprop.com.ar/propiedades/clasificado/departamento-en-palermo-58561169.html",
  "operationType": "Venta",
  "price": 310000,
  "priceCurrency": "USD",
  "expenses": 700000,
  "expensesCurrency": "$",
  "totalSurface": 112,
  "coveredSurface": 102,
  "rooms": 4,
  "bedrooms": 3,
  "bathrooms": 2,
  "parking": 1,
  "toilette": 1,
  "propertyAge": 50,
  "address": "Anasagasti al 2000",
  "neighborhood": "Palermo",
  "city": "Capital Federal",
  "country": "Argentina",
  "latitude": -34.5893136,
  "longitude": -58.4117838,
  "images": [
    "https://imgar.zonapropcdn.com/avisos/1/00/58/56/11/69/720x532/2038309886.jpg"
  ],
  "agencyName": "Coldwell Banker Horizon Group",
  "agencyUrl": "https://www.zonaprop.com.ar/inmobiliarias/coldwell-banker-horizon-group_17149315-inmuebles.html",
  "agencyLicense": "CUCICBA 9016",
  "propertyType": "Departamento",
  "listingDescription": "Departamento de 4 ambientes con balcon, guardacoche y baulera en palermo...",
  "modifiedDate": "2026-05-07T00:00:00-0400",
  "hasVideos": false,
  "hasTour": false,
  "scrapedAt": "2026-05-19T10:00:00+00:00",
  "error": null
}
```

### Input parameters

| Parameter | Type | Default | Description |
|---|---|---|---|
| `startUrls` | array of strings | required | One or more ZonaProp search page URLs |
| `maxItems` | integer | 30 | Maximum number of listings to collect **per URL** (1 to 10,000) |
| `requestTimeoutSecs` | integer | 30 | Per-request timeout in seconds (5 to 120) |

#### maxItems is per URL, not global

`maxItems` applies independently to **each start URL**. If you provide three URLs and set `maxItems` to 200, the actor can return up to 600 records in total — 200 from each search. This lets you collect full coverage from several different searches in one run without one large search crowding out a smaller one.

### How pagination works

ZonaProp search pages display 30 listings per page. The actor fetches the first page of each start URL, parses all listing cards, then follows the next-page link automatically until it either:

- reaches the `maxItems` limit for that URL, or
- runs out of pages (end of results).

You do not need to page through results manually or construct paginated URLs — just paste the first page URL.

### Output fields reference

| Field | Type | Description |
|---|---|---|
| `postingId` | string | Unique internal listing ID on ZonaProp |
| `postingCode` | string | Human-readable reference code (e.g. `CAP7850638`) |
| `listingTitle` | string | Listing title as shown on the search page |
| `generatedTitle` | string | Auto-generated title combining key features |
| `listingUrl` | string | Full URL to the listing detail page |
| `operationType` | string | `Venta` (sale) or `Alquiler` (rent) |
| `price` | integer | Listing price as a number |
| `priceCurrency` | string | `USD` or `ARS` |
| `expenses` | integer | Monthly expensas amount |
| `expensesCurrency` | string | Currency for expenses (usually `ARS`) |
| `totalSurface` | number | Total surface area in m² |
| `coveredSurface` | number | Covered surface area in m² |
| `rooms` | integer | Total rooms (ambientes) |
| `bedrooms` | integer | Number of bedrooms (dormitorios) |
| `bathrooms` | integer | Number of full bathrooms |
| `parking` | integer | Parking spaces (cocheras) |
| `toilette` | integer | Half-bathrooms (toilettes) |
| `propertyAge` | integer | Age of the property in years |
| `address` | string | Street address |
| `neighborhood` | string | Barrio / neighborhood |
| `city` | string | City or province |
| `country` | string | Country (Argentina) |
| `latitude` | number | GPS latitude |
| `longitude` | number | GPS longitude |
| `images` | array | List of photo URLs (730×532) |
| `agencyName` | string | Real estate agency name |
| `agencyUrl` | string | Agency profile page on ZonaProp |
| `agencyLicense` | string | Agency professional license number |
| `propertyType` | string | Property category (Departamento, Casa, Oficina, etc.) |
| `listingDescription` | string | Full listing description text |
| `modifiedDate` | string | ISO 8601 date of last modification |
| `hasVideos` | boolean | Whether the listing includes video |
| `hasTour` | boolean | Whether the listing includes a 360° virtual tour |
| `scrapedAt` | string | ISO 8601 timestamp of when the record was collected |
| `error` | string | null | Error message if extraction failed, otherwise `null` |

### Use cases

**Real estate investment research**: Collect prices, surface areas, and locations across neighborhoods to find undervalued properties and track how the market moves over time.

**Competitive market analysis**: Monitor active listings in your target area and see how prices shift week to week. Set up scheduled runs to build a time-series dataset.

**Lead generation for agencies**: Pull listing and agency details — including license numbers and profile URLs — to build a list of active sellers and landlords.

**Price index construction**: Pull thousands of listings from multiple searches to build neighborhood price benchmarks in ARS or USD. Calculate price per m² by neighborhood or property type.

**Portfolio benchmarking**: Compare your own properties against current market listings by size, location, and price per square meter.

**CRM and data pipeline integration**: Export results as JSON or CSV and load them directly into your existing tools, databases, or BI dashboards.

**Academic and journalistic research**: Track affordability trends in the Argentine property market or analyse the spatial distribution of real estate supply.

### Tips for best results

- Apply all your filters on ZonaProp before copying the URL. The actor scrapes exactly what that search returns — the URL is your only filter.
- Use multiple start URLs in one run to cover different property types, neighborhoods, or operation types simultaneously.
- `maxItems` is per URL, so you can set it high for a broad search without worrying about it consuming the budget for other URLs in the same run.
- ZonaProp shows 30 listings per page, so `maxItems: 100` means roughly 4 pages fetched per URL.
- For recurring data collection, schedule the actor to run daily or weekly and export incrementally to keep your dataset fresh.
- If you only need a specific neighborhood or price range, filter on ZonaProp first — the more specific the URL, the faster the run.

### Limitations

- The actor scrapes listing card data from ZonaProp search pages; it does not visit individual listing detail pages.
- Phone numbers and direct contact details are not available in search card data.
- ZonaProp caps search results at approximately 10,000 listings per search query regardless of pagination; use narrower search URLs (by neighborhood, price band, or property type) to avoid hitting this ceiling.
- Listings without a price set (`A consultar`) will have `price: null` and `priceCurrency: null`.

# Actor input Schema

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

One or more ZonaProp search page URLs to scrape. Apply filters directly in the ZonaProp website (location, property type, operation) and paste the resulting URL here.

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

Maximum number of listings to collect per start URL. Each URL is scraped independently up to this limit, so 2 URLs with maxItems 500 can yield up to 1,000 total records.

## `requestTimeoutSecs` (type: `integer`):

Per-request timeout in seconds. Increase if you see timeout errors on slow pages.

## Actor input object example

```json
{
  "startUrls": [
    "https://www.zonaprop.com.ar/casas-alquiler-buenos-aires.html",
    "https://www.zonaprop.com.ar/propiedades-venta-mendoza.html"
  ],
  "maxItems": 30,
  "requestTimeoutSecs": 30
}
```

# 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.zonaprop.com.ar/departamentos-venta-capital-federal.html"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("kawsar/zonaprop-listing-extractor").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.zonaprop.com.ar/departamentos-venta-capital-federal.html"] }

# Run the Actor and wait for it to finish
run = client.actor("kawsar/zonaprop-listing-extractor").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.zonaprop.com.ar/departamentos-venta-capital-federal.html"
  ]
}' |
apify call kawsar/zonaprop-listing-extractor --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "ZonaProp Listing Extractor",
        "description": "Extract structured property data from Argentina's largest real estate portal. Paste any ZonaProp search URL by location, type, or price range and get price, surface area, rooms, GPS coordinates, images, and agency details. Paginates automatically, up to 10,000 listings per URL.",
        "version": "0.0",
        "x-build-id": "qKa2idY6gnjVy5STP"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/kawsar~zonaprop-listing-extractor/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-kawsar-zonaprop-listing-extractor",
                "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/kawsar~zonaprop-listing-extractor/runs": {
            "post": {
                "operationId": "runs-sync-kawsar-zonaprop-listing-extractor",
                "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/kawsar~zonaprop-listing-extractor/run-sync": {
            "post": {
                "operationId": "run-sync-kawsar-zonaprop-listing-extractor",
                "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",
                "required": [
                    "startUrls"
                ],
                "properties": {
                    "startUrls": {
                        "title": "Start URLs",
                        "type": "array",
                        "description": "One or more ZonaProp search page URLs to scrape. Apply filters directly in the ZonaProp website (location, property type, operation) and paste the resulting URL here.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of listings to collect per start URL. Each URL is scraped independently up to this limit, so 2 URLs with maxItems 500 can yield up to 1,000 total records.",
                        "default": 30
                    },
                    "requestTimeoutSecs": {
                        "title": "Request timeout (seconds)",
                        "minimum": 5,
                        "maximum": 120,
                        "type": "integer",
                        "description": "Per-request timeout in seconds. Increase if you see timeout errors on slow pages.",
                        "default": 30
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
