# Propiedades Scraper | Fast & Reliable | $1.5 / 1k (`fatihtahta/propiedades-scraper`) Actor

Extract structured real estate listings across Mexico from Propiedades.com with prices, full description, property details, seller data, media and more. Built for enterprise-grade real estate intelligence, lead enrichment, market analysis, and automated data pipelines.

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

## Pricing

from $1.50 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
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

## Propiedades Scraper

**Slug:** `fatihtahta/propiedades-scraper`

### Overview

Propiedades Scraper collects structured real estate listing data from Propiedades.com, including listing identity, property type, transaction type, pricing, location, features, media, listing dates, status flags, source context, and description text. [Propiedades.com](https://propiedades.com) is a major real estate marketplace in Mexico, making its public listing data useful for market research, pricing analysis, inventory monitoring, and lead discovery. The actor turns location- and filter-based searches into repeatable datasets that can be used in analytics, reporting, enrichment, and monitoring workflows. Output is normalized into JSON records so teams can run the same collection process consistently across geographies, deal types, property categories, and price or area segments. It is designed for dependable recurring data acquisition while reflecting the public data available at the time of each run.

### Why Use This Actor

- **Market research and analytics teams:** collect structured extraction outputs for pricing bands, geographic coverage, inventory movement, and market intelligence.
- **Product and content teams:** populate internal property experiences, comparison views, editorial research, and localized content workflows with normalized listing data.
- **Developers and data engineering teams:** feed repeatable collection results into downstream systems, ETL pipelines, search indexes, and operational reporting.
- **Lead generation and enrichment teams:** identify public listing opportunities and enrich CRM records with current property attributes, locations, and transaction context.
- **Monitoring and competitive tracking teams:** schedule recurring data acquisition to observe availability, pricing, listing status, and category movement over time.

### Common Use Cases

- **Market intelligence:** monitor supply, pricing, availability, property categories, locations, and size ranges across Mexican real estate markets.
- **Lead generation:** build targeted prospect lists from public property listings in specific cities, neighborhoods, municipalities, or regions.
- **Competitive monitoring:** track changes in visible inventory, pricing, listing age, media presence, and property positioning.
- **Catalog and directory building:** populate internal databases with structured public property records for search, review, or qualification.
- **Data enrichment:** add current public listing attributes to CRM, BI, valuation, or analytics datasets.
- **Recurring reporting:** schedule periodic runs for dashboards, alerts, market snapshots, or trend analysis.

### Quick Start

1. Choose one or more `location` values, such as a city, neighborhood, municipality, or region in Mexico.
2. Select the `deal_type` and `property_type` that match the target market segment.
3. Add optional filters such as bedrooms, bathrooms, parking, amenities, price range, or area range when you need a narrower dataset.
4. Set a small `limit` for the first validation run.
5. Run the actor in Apify Console and inspect the first dataset records to confirm the shape matches your use case.
6. Increase coverage, adjust filters, or schedule the actor once the output is verified.

### Input Parameters

This actor accepts location-based searches with optional deal type, property type, room, amenity, price, area, and result limit filters.

| Parameter | Type | Description | Default |
|---|---:|---|---|
| `location` | array of strings | Cities, neighborhoods, municipalities, or regions to search in Mexico. Enter one location per row. Broader locations improve discovery; specific neighborhoods produce more targeted results. | – |
| `deal_type` | string | Commercial context for the listings. Allowed values: `all`, `sale`, `sale_infonavit`, `sale_remate`, `rent`. | `all` |
| `property_type` | string | Property category to collect. Allowed values: `house`, `gated_community_house`, `apartment`, `residential_land`, `ranch`, `office`, `industrial_warehouse`, `commercial_land`, `industrial_storage`, `retail_space`, `building`, `room`, `commercial_storage`, `industrial_land`. | `apartment` |
| `min_bedroom` | string | Minimum bedrooms required. Allowed values: `1`, `2`, `3`, `4_plus`. Leave empty when bedroom count should not restrict results. | – |
| `min_bathroom` | string | Minimum bathrooms required. Allowed values: `1`, `1_5`, `2`, `2_5_plus`. Leave empty when bathroom count should not restrict results. | – |
| `min_parking` | string | Minimum parking spaces required. Allowed values: `1`, `2`, `3`, `4_plus`. Leave empty when parking availability should not restrict results. | – |
| `amenity` | string | Required amenity or furnishing characteristic. Allowed values: `amenities`, `pool`, `furnished`, `laundry_area`, `fireplace`, `garden`, `basement`, `terrace`. | `amenities` |
| `min_price` | integer | Minimum listing price to include, in Mexican pesos. Minimum value: `1000`. | – |
| `max_price` | integer | Maximum listing price to include, in Mexican pesos. Minimum value: `1000`. | – |
| `min_area` | integer | Minimum constructed area to include, in square meters. | – |
| `max_area` | integer | Maximum constructed area to include, in square meters. | – |
| `limit` | integer | Maximum number of listings to save for each provided location or input. Minimum value: `1`. Leave empty to collect all available matching listings for the configured search. | – |

### Choosing Inputs

Use `location` as the primary scope control. A broad city or municipality can improve discovery, while a specific neighborhood helps produce a cleaner market segment for comparison, reporting, or lead review.

Use `deal_type` and `property_type` to align the dataset with the commercial workflow, such as rentals, standard sales, Infonavit-eligible sales, remate sales, apartments, houses, offices, land, warehouses, or retail spaces. Add room, parking, amenity, price, and area filters when you need qualification-ready results; leave optional filters empty when the goal is broad discovery. Start with a small `limit` to validate the output shape, then increase it once you confirm the dataset matches your intended use.

### Example Inputs

#### Example: Neighborhood apartment sale validation

```json
{
  "location": ["Roma Norte"],
  "deal_type": "sale",
  "property_type": "apartment",
  "min_bedroom": "2",
  "min_price": 3000000,
  "max_price": 9000000,
  "limit": 25
}
````

#### Example: Rental monitoring in a city

```json
{
  "location": ["Guadalajara"],
  "deal_type": "rent",
  "property_type": "house",
  "min_bathroom": "2",
  "min_parking": "1",
  "limit": 50
}
```

#### Example: Broad discovery with conservative limit

```json
{
  "location": ["Monterrey", "San Pedro Garza García"],
  "deal_type": "all",
  "property_type": "retail_space",
  "amenity": "amenities",
  "min_area": 50,
  "max_area": 300,
  "limit": 40
}
```

### Output

#### Output Destination

The actor writes results to an Apify dataset as JSON records. The dataset is designed for direct consumption by analytics tools, ETL pipelines, and downstream APIs with minimal post-processing.

When multiple entity types or record shapes exist, this README documents each shape separately based on the provided Example Output.

#### Record Envelope And Stable Identifiers

Each dataset item represents a public Propiedades.com property listing. The strongest recommended idempotency key is `id`; use `url` as a secondary verification key when syncing records across repeated runs.

For deduplication and upserts, store records by `id` and update mutable fields such as pricing, listing dates, status flags, media, and description when a later run returns the same listing. Stable identifiers make records easier to merge, deduplicate, and sync across warehouses, CRMs, search indexes, and internal APIs. The `source_context.source_url` and related source context fields provide run context for traceability, but they should not replace `id` as the primary listing key.

#### Examples

##### Example: property listing

```json
{
  "id": 24058591,
  "url": "https://propiedades.com/inmuebles/casa-en-venta-roma-norte-cuauhtemoc-ciudad-de-mexico-roma-norte-df-24058591",
  "title": "Roma Norte, Cuauhtémoc, Ciudad de México",
  "property_type": "Residencial",
  "listing_type": "Casa",
  "transaction_type": "Venta",
  "pricing": {
    "price": 19500000,
    "sale_price": 19500000,
    "rental_price": 0,
    "currency": "MXN"
  },
  "location": {
    "full_address": "Roma Norte, Cuauhtémoc, Ciudad de México, Col. Roma Norte C.P. 06700, Cuauhtémoc",
    "display_address": "Roma Norte, Cuauhtémoc, Ciudad de México, Col. Roma Norte",
    "short_address": "Roma Norte, Cuauhtémoc, Ciudad de México",
    "colony": "Roma Norte",
    "municipality": "Cuauhtémoc",
    "city": "Cuauhtémoc",
    "state": "DF / CDMX",
    "postal_code": "06700",
    "coordinates": {
      "latitude": 19.4173639,
      "longitude": -99.1594532,
      "valid": false
    }
  },
  "features": {
    "bedrooms": 0,
    "bathrooms": 0,
    "size_m2": 400
  },
  "media": {
    "photo_count": 12,
    "main_image": {
      "url": "https://propiedadescom.s3.amazonaws.com/files/292x200/roma-norte-cuauhtemoc-ciudad-de-mexico-roma-norte-cuauhtemoc-df-cdmx-24058591-foto-01.jpg",
      "width": 899,
      "height": 1200
    }
  },
  "listing_dates": {
    "published_at": "2022-02-15 10:37:13",
    "modified": "22/04/2026",
    "age_text": "4 años en Propiedades.com"
  },
  "status": {
    "is_new": false,
    "off_market": false,
    "verified_whatsapp": true,
    "is_exclusive": false,
    "is_auction": false,
    "is_showroom": false,
    "is_duplicate": false,
    "is_main_duplicate": false,
    "highlighted": false
  },
  "source_details": {
    "city_id": 6,
    "state_id": 1,
    "purpose_id": 1,
    "property_type_id": 1,
    "property_subtype_id": 2,
    "product_ranking_id": 4,
    "random_value": 64.4635
  },
  "source_context": {
    "source_url": "https://propiedades.com",
    "seed_id": "ee7c8d09d185",
    "seed_type": "query",
    "seed_value": "Roma Norte",
    "page_index": 1,
    "query": "Roma Norte",
    "location_label": "Roma Norte, Cuauhtémoc, Ciudad De México",
    "direction_id": "733"
  },
  "description": "Venta de casa en el corazón de la colonia Roma, el acceso a la casa es directo sobre avenida.  ID: EB-JP6134"
}
```

### Field Reference

#### Property Listing Record

**id** *(integer, required)*: Stable listing identifier recommended for deduplication and upserts.

**url** *(string, required)*: Public listing URL.

**title** *(string, optional)*: Listing title or headline location.

**property\_type** *(string, optional)*: Broad property classification.

**listing\_type** *(string, optional)*: Listing category, such as house or apartment.

**transaction\_type** *(string, optional)*: Commercial transaction type, such as sale or rent.

**pricing.price / pricing.sale\_price / pricing.rental\_price** *(integer, optional)*: Listing price values in the record currency; availability depends on transaction type.

**pricing.currency** *(string, optional)*: Currency code, typically `MXN`.

**location.full\_address** *(string, optional)*: Full visible address text.

**location.display\_address** *(string, optional)*: Display-ready address.

**location.short\_address** *(string, optional)*: Short location label.

**location.colony** *(string, optional)*: Colony or neighborhood.

**location.municipality** *(string, optional)*: Municipality.

**location.city** *(string, optional)*: City.

**location.state** *(string, optional)*: State or regional label.

**location.postal\_code** *(string, optional)*: Postal code when available.

**location.coordinates.latitude / location.coordinates.longitude** *(number, optional)*: Geographic coordinates when available.

**location.coordinates.valid** *(boolean, optional)*: Indicates whether coordinates are marked valid in the source data.

**features.bedrooms** *(integer, optional)*: Bedroom count.

**features.bathrooms** *(number, optional)*: Bathroom count.

**features.size\_m2** *(integer, optional)*: Constructed area in square meters.

**media.photo\_count** *(integer, optional)*: Number of photos visible for the listing.

**media.main\_image.url** *(string, optional)*: Main image URL.

**media.main\_image.width / media.main\_image.height** *(integer, optional)*: Main image dimensions when available.

**listing\_dates.published\_at** *(string, optional)*: Published timestamp as returned by the source.

**listing\_dates.modified** *(string, optional)*: Last modified date as returned by the source.

**listing\_dates.age\_text** *(string, optional)*: Human-readable listing age.

**status.is\_new** *(boolean, optional)*: Indicates whether the listing is marked new.

**status.off\_market** *(boolean, optional)*: Indicates whether the listing is marked off market.

**status.verified\_whatsapp** *(boolean, optional)*: Indicates whether WhatsApp verification is shown.

**status.is\_exclusive** *(boolean, optional)*: Indicates whether the listing is marked exclusive.

**status.is\_auction** *(boolean, optional)*: Indicates whether the listing is marked as auction or remate-related.

**status.is\_showroom** *(boolean, optional)*: Indicates whether the listing is marked showroom-related.

**status.is\_duplicate / status.is\_main\_duplicate** *(boolean, optional)*: Duplicate indicators from the listing data.

**status.highlighted** *(boolean, optional)*: Indicates whether the listing is highlighted.

**source\_details.city\_id / source\_details.state\_id** *(integer, optional)*: Source-provided location identifiers.

**source\_details.purpose\_id** *(integer, optional)*: Source-provided transaction or purpose identifier.

**source\_details.property\_type\_id / source\_details.property\_subtype\_id** *(integer, optional)*: Source-provided property classification identifiers.

**source\_details.product\_ranking\_id** *(integer, optional)*: Source-provided ranking or product identifier.

**source\_details.random\_value** *(number, optional)*: Source-provided numeric value associated with the listing record.

**source\_context.source\_url** *(string, optional)*: Public source context URL associated with the record collection.

**source\_context.seed\_id** *(string, optional)*: Identifier for the input seed that produced the record.

**source\_context.seed\_type** *(string, optional)*: Type of starting input, such as query.

**source\_context.seed\_value** *(string, optional)*: Input value that produced the record.

**source\_context.page\_index** *(integer, optional)*: Result page index associated with the record.

**source\_context.query** *(string, optional)*: Query or location text used for the record.

**source\_context.location\_label** *(string, optional)*: Matched location label.

**source\_context.direction\_id** *(string, optional)*: Source-provided location direction identifier.

**description** *(string, optional)*: Listing description text.

### Data Quality, Guarantees, And Handling

- **Structured records:** results are normalized into predictable JSON objects for downstream use.
- **Best-effort extraction:** fields may vary by region, session, availability, and target-side presentation changes.
- **Optional fields:** null-check optional values in downstream code, especially media, dates, coordinates, status flags, and source-provided metadata.
- **Deduplication:** use `id` as the primary stable key and `url` as a secondary verification key when storing records over time.
- **Freshness:** results reflect the publicly available data at run time.
- **Repeated runs:** use the recommended idempotency key when syncing data into warehouses, CRMs, search indexes, or internal APIs.

### Tips For Best Results

- Start with a small `limit` to validate the output shape before scaling up.
- Use one geography or segment per run when you need cleaner reporting and easier comparison.
- Leave optional filters empty when the goal is broad market discovery.
- Add price, area, room, parking, and amenity filters gradually to understand how each field changes coverage.
- Use `deal_type` and `property_type` to keep sale, rental, residential, commercial, or industrial workflows separate.
- Schedule recurring runs for monitoring workflows instead of relying on manual one-off collection.
- Use `id` for deduplication when storing listing records over time.

### How To Run On Apify

1. Open the Actor in Apify Console.
2. Configure the available input fields for the target scope.
3. Set the maximum number of outputs to collect with `limit`.
4. Click **Start** and wait for the run to finish.
5. Open the dataset and review the first records.
6. Download results in JSON, CSV, Excel, or another supported format.

### Scheduling & Automation

#### Scheduling

**Automated Data Collection**

Schedule recurring runs to keep property datasets current for dashboards, alerts, enrichment, and operational reporting. Use separate schedules for different geographies, deal types, or property segments when you need cleaner historical comparisons.

- Navigate to **Schedules** in Apify Console
- Create a new schedule, such as daily, weekly, or custom cron
- Configure input parameters
- Enable notifications for run completion
- Add webhooks for automated processing

#### Integration Options

- **CRM enrichment:** sync listing attributes, public URLs, locations, pricing, and transaction context into account or lead records.
- **BI dashboards:** monitor pricing, availability, property categories, geographic coverage, and listing changes over time.
- **Data warehouses:** store normalized listing snapshots for historical analysis, modeling, and operational reporting.
- **Google Sheets or Airtable:** review smaller property segments, lead lists, or market samples with business users.
- **Webhooks:** trigger validation, notification, or ingestion workflows after each completed run.
- **Alerts and scheduled reporting:** notify teams when new listings, price bands, or target locations require review.

### Export Formats And Downstream Use

Apify datasets can be exported or consumed by downstream systems for operational workflows, analytics, and archival storage.

- **JSON:** for APIs, applications, and data pipelines
- **CSV or Excel:** for spreadsheet workflows and manual review
- **API access:** for automated ingestion into internal systems
- **BI and warehouses:** for reporting, dashboards, and historical analysis

### Performance

Estimated run times:

- **Small runs (< 1,000 outputs):** ~3–5 minutes
- **Medium runs (1,000–5,000 outputs):** ~5–15 minutes
- **Large runs (5,000+ outputs):** ~15–30 minutes

Execution time varies based on filters, result volume, and how much information is returned per record. Highly filtered runs can finish faster, while broad discovery or detail-rich records may take longer.

### Limitations

- Availability depends on what [Propiedades.com](https://propiedades.com) publicly exposes at run time.
- Some optional fields may be missing on sparse records or listing types that do not publish every attribute.
- Very broad searches may take longer or require higher `limit` values to collect the desired coverage.
- Target-side changes can affect field availability, labels, or naming.
- Regional, account, or availability differences may change visible results.
- Results should be treated as a run-time snapshot, not a guarantee that a listing remains available later.

### Troubleshooting

- **No results returned:** check filters, location spelling, property category, deal type, and whether the target has matching public records.
- **Fewer results than expected:** broaden filters, raise `limit`, or verify that the target contains enough matching records for the selected location and segment.
- **Some fields are empty:** optional fields depend on what each listing publicly provides.
- **Run takes longer than expected:** reduce scope, lower `limit` for validation, or split broad collection into smaller segments.
- **Output changed:** compare the current output with the field reference and report a small sample if support is needed.

### FAQ

#### What data does this actor collect?

It collects public Propiedades.com property listing records, including listing identifiers, URLs, titles, property and transaction types, pricing, location, features, media, dates, status flags, source context, and descriptions when available.

#### Can I filter by location, category, price, or other criteria?

Yes. The actor supports `location`, `deal_type`, `property_type`, bedroom, bathroom, parking, amenity, price range, area range, and `limit` inputs.

#### Can I filter by date?

No date filter is exposed in the input schema. Date-related fields may appear in output records when available from the listing data.

#### Why did I receive fewer results than my limit?

The selected location and filters may have fewer matching public listings than the requested `limit`. Broaden filters or try a wider location to improve coverage.

#### Can I schedule recurring runs?

Yes. Use Apify schedules to run the actor on a daily, weekly, or custom cadence for monitoring, reporting, and enrichment workflows.

#### How do I avoid duplicates across runs?

Use `id` as the primary idempotency key. You can also store `url` as a secondary verification field when syncing records into downstream systems.

#### Can I export the data to CSV, Excel, or JSON?

Yes. Apify datasets support common export formats including JSON, CSV, and Excel, as well as API-based consumption.

#### Does this actor collect private data?

The actor is intended to collect publicly available property listing information from Propiedades.com. Users are responsible for using the data lawfully and responsibly.

#### What should I include when reporting an issue?

Include the input used with sensitive values removed, the run ID, expected versus actual behavior, and a small output sample if it helps explain the issue.

### Compliance & Ethics

#### Responsible Data Collection

This actor collects publicly available **real estate listing** information from **https://propiedades.com** for legitimate business purposes, including:

- **Real estate** research and market analysis
- Property inventory monitoring and operational reporting
- Lead discovery, CRM enrichment, and business intelligence workflows

This section is informational and not legal advice. Users are responsible for ensuring their use of collected data complies with applicable laws, regulations, and platform terms.

#### Best Practices

- Use collected data in accordance with applicable laws, regulations, and the target site’s terms
- Respect individual privacy and personal information
- Use data responsibly and avoid disruptive or excessive collection
- Do not use this actor for spamming, harassment, or other harmful purposes
- Follow relevant data protection requirements where applicable, such as GDPR and CCPA

### Support

For help, use the actor page or Issues section. Include the input used with sensitive values redacted, the run ID, expected versus actual behavior, and a small output sample when relevant. This helps support reproduce the case and determine whether the issue is input scope, target availability, or output interpretation.

# Actor input Schema

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

Enter one specific search area per row. Use precise names shown on Propiedades, for example Roma Norte, Napoles, or San Pedro Garza Garcia. Avoid broad city names because Propiedades searches by smaller local areas.

## `deal_type` (type: `string`):

Select which deal type should be included in the results. Choose All to keep sale, rent, and special sale categories in scope.

## `property_type` (type: `string`):

Select the property category to collect. The default focuses on apartments; choose a different type when you need houses, land, offices, warehouses, retail spaces, or other property segments.

## `min_bedroom` (type: `string`):

Choose the minimum number of bedrooms required. Leave unset when bedroom count should not restrict the results.

## `min_bathroom` (type: `string`):

Choose the minimum number of bathrooms required. Leave unset to include listings regardless of bathroom count.

## `min_parking` (type: `string`):

Choose the minimum number of parking spaces required. Leave unset when parking availability should not narrow the dataset.

## `amenity` (type: `string`):

Select an amenity to require in the results. Use the default option to keep the broader amenity category in scope.

## `min_price` (type: `integer`):

Enter the lowest listing price to include, in Mexican pesos. Leave empty when lower-priced listings should remain in scope.

## `max_price` (type: `integer`):

Enter the highest listing price to include, in Mexican pesos. Leave empty when higher-priced listings should remain in scope.

## `min_area` (type: `integer`):

Enter the minimum constructed area to include, in square meters. Leave empty to include smaller listings.

## `max_area` (type: `integer`):

Enter the maximum constructed area to include, in square meters. Leave empty to include larger listings.

## `limit` (type: `integer`):

Set the maximum number of listings to save for each provided location or input. Leave empty to collect all available matching listings for the configured search.

## Actor input object example

```json
{
  "location": [
    "Roma Norte"
  ],
  "deal_type": "all",
  "property_type": "apartment",
  "amenity": "amenities",
  "limit": 100
}
```

# Actor output Schema

## `results` (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 = {
    "location": [
        "Roma Norte"
    ],
    "property_type": "apartment",
    "limit": 100
};

// Run the Actor and wait for it to finish
const run = await client.actor("fatihtahta/propiedades-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 = {
    "location": ["Roma Norte"],
    "property_type": "apartment",
    "limit": 100,
}

# Run the Actor and wait for it to finish
run = client.actor("fatihtahta/propiedades-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 '{
  "location": [
    "Roma Norte"
  ],
  "property_type": "apartment",
  "limit": 100
}' |
apify call fatihtahta/propiedades-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Propiedades Scraper | Fast & Reliable | $1.5 / 1k",
        "description": "Extract structured real estate listings across Mexico from Propiedades.com with prices, full description, property details, seller data, media and more. Built for enterprise-grade real estate intelligence, lead enrichment, market analysis, and automated data pipelines.",
        "version": "0.0",
        "x-build-id": "Bp39pukqaFgPH0dH8"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/fatihtahta~propiedades-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-fatihtahta-propiedades-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/fatihtahta~propiedades-scraper/runs": {
            "post": {
                "operationId": "runs-sync-fatihtahta-propiedades-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/fatihtahta~propiedades-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-fatihtahta-propiedades-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": {
                    "location": {
                        "title": "Add Search Areas (eg. Roma Norte, Napoles, San Pedro Garza Garcia)",
                        "type": "array",
                        "description": "Enter one specific search area per row. Use precise names shown on Propiedades, for example Roma Norte, Napoles, or San Pedro Garza Garcia. Avoid broad city names because Propiedades searches by smaller local areas.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "deal_type": {
                        "title": "Choose Deal Type",
                        "enum": [
                            "all",
                            "sale",
                            "sale_infonavit",
                            "sale_remate",
                            "rent"
                        ],
                        "type": "string",
                        "description": "Select which deal type should be included in the results. Choose All to keep sale, rent, and special sale categories in scope.",
                        "default": "all"
                    },
                    "property_type": {
                        "title": "Choose Property Type",
                        "enum": [
                            "house",
                            "gated_community_house",
                            "apartment",
                            "residential_land",
                            "ranch",
                            "office",
                            "industrial_warehouse",
                            "commercial_land",
                            "industrial_storage",
                            "retail_space",
                            "building",
                            "room",
                            "commercial_storage",
                            "industrial_land"
                        ],
                        "type": "string",
                        "description": "Select the property category to collect. The default focuses on apartments; choose a different type when you need houses, land, offices, warehouses, retail spaces, or other property segments.",
                        "default": "apartment"
                    },
                    "min_bedroom": {
                        "title": "Set Minimum Bedrooms",
                        "enum": [
                            "1",
                            "2",
                            "3",
                            "4_plus"
                        ],
                        "type": "string",
                        "description": "Choose the minimum number of bedrooms required. Leave unset when bedroom count should not restrict the results."
                    },
                    "min_bathroom": {
                        "title": "Set Minimum Bathrooms",
                        "enum": [
                            "1",
                            "1_5",
                            "2",
                            "2_5_plus"
                        ],
                        "type": "string",
                        "description": "Choose the minimum number of bathrooms required. Leave unset to include listings regardless of bathroom count."
                    },
                    "min_parking": {
                        "title": "Set Minimum Parking Spaces",
                        "enum": [
                            "1",
                            "2",
                            "3",
                            "4_plus"
                        ],
                        "type": "string",
                        "description": "Choose the minimum number of parking spaces required. Leave unset when parking availability should not narrow the dataset."
                    },
                    "amenity": {
                        "title": "Choose Required Amenity",
                        "enum": [
                            "amenities",
                            "pool",
                            "furnished",
                            "laundry_area",
                            "fireplace",
                            "garden",
                            "basement",
                            "terrace"
                        ],
                        "type": "string",
                        "description": "Select an amenity to require in the results. Use the default option to keep the broader amenity category in scope.",
                        "default": "amenities"
                    },
                    "min_price": {
                        "title": "Set Minimum Price",
                        "minimum": 1000,
                        "type": "integer",
                        "description": "Enter the lowest listing price to include, in Mexican pesos. Leave empty when lower-priced listings should remain in scope."
                    },
                    "max_price": {
                        "title": "Set Maximum Price",
                        "minimum": 1000,
                        "type": "integer",
                        "description": "Enter the highest listing price to include, in Mexican pesos. Leave empty when higher-priced listings should remain in scope."
                    },
                    "min_area": {
                        "title": "Set Minimum Area",
                        "type": "integer",
                        "description": "Enter the minimum constructed area to include, in square meters. Leave empty to include smaller listings."
                    },
                    "max_area": {
                        "title": "Set Maximum Area",
                        "type": "integer",
                        "description": "Enter the maximum constructed area to include, in square meters. Leave empty to include larger listings."
                    },
                    "limit": {
                        "title": "Set Maximum Results per Input",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Set the maximum number of listings to save for each provided location or input. Leave empty to collect all available matching listings for the configured search."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
