# Mitula Property Search Scraper (`stealth_mode/mitula-property-search-scraper`) Actor

Scrape property listings from Mitula across all countries. This scraper extracts comprehensive real estate data including bedrooms, bathrooms, floor area, locations, images, and more — perfect for market analysis, property aggregation, and real estate research.

- **URL**: https://apify.com/stealth\_mode/mitula-property-search-scraper.md
- **Developed by:** [Stealth mode](https://apify.com/stealth_mode) (community)
- **Categories:** Automation, Developer tools, Real estate
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
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

## Mitula Property Search Scraper: Extract Real Estate Data Globally

---

### What Is Mitula.com?

Mitula is a global real estate search platform operating across multiple countries, aggregating property listings for rent and sale. Each country has its own domain (e.g., `casas.mitula.com.co` for Colombia), featuring thousands of residential and commercial properties. Collecting this property data manually is labor-intensive — the **Mitula Property Search Scraper** automates extraction, delivering structured property records instantly.

---

### Overview

The **Mitula Property Scraper** extracts detailed property listings from Mitula search results pages, transforming property data into clean, machine-readable records. It is ideal for:

- **Real estate professionals** tracking market trends and inventory
- **Property investors** analyzing regional markets and pricing patterns
- **Data analysts** building datasets for real estate intelligence
- **Platform developers** aggregating property data for comparison sites
- **Market researchers** studying housing availability across regions

The scraper handles multiple URLs, scales to hundreds of listings per page, and includes robust error handling via configurable failure tolerance.

---

### Input Format

The scraper accepts a JSON configuration object:

```json
{
  "urls": [
    "https://casas.mitula.com.co/casas/arriendo-st-antioquia?page=2"
  ],
  "ignore_url_failures": true,
  "max_items_per_url": 200,
  "proxy": {
    "useApifyProxy": true,
    "apifyProxyGroups": ["RESIDENTIAL"],
    "apifyProxyCountry": "US"
  }
}
````

| Field | Description |
|---|---|
| `urls` | Array of Mitula property search result URLs (e.g., category pages with filters applied) |
| `max_items_per_url` | Maximum properties to extract per URL (e.g., `200` for large result sets) |
| `ignore_url_failures` | If `true`, scraper continues even if some URLs fail; if `false`, stops on error |
| `proxy` | Proxy configuration for reliable data collection without bot detection |
| `proxy.apifyProxyCountry` | Set to match the target country (e.g., `CO` for Colombia, `ES` for Spain) |

> **Best Practice:** Use Mitula URLs with filters already applied (location, price range, property type) to narrow results and reduce unnecessary data collection.

***

### Output Format

**Example Output:**

```json
{
  "listing_id": "24301-256-7424-ed57f1d61107-b0c2-19e1874-f43e",
  "source_id": 0,
  "position": 4,
  "agency": {
    "name": "SC Bienes Raices",
    "id": "019dff43-b74a-733e-8b6c-d609f21f8ccb"
  },
  "operations": [
    {
      "operation_type": "RENT",
      "price": {
        "value": 6800000,
        "currency": "COP"
      }
    }
  ],
  "property_type": "apartment",
  "location_ids": [
    {
      "id": "mitula-CO-distrito-0000134742",
      "level": "mitula-distrito"
    },
    {
      "id": "mitula-CO-poblacion-0000014158",
      "level": "mitula-poblacion"
    },
    {
      "id": "mitula-CO-provincia-0000213274",
      "level": "mitula-provincia"
    }
  ],
  "number_of_bathrooms": 4,
  "number_of_bedrooms": 4,
  "floor_area": 147,
  "points_of_interest": [],
  "image": "https://img.mitula.com/eyJidWNrZXQiOiJwcmQtbGlmdWxsY29ubmVjdC1iYWNrZW5kLWIyYi1pbWFnZXMiLCJrZXkiOiJpbmdlc3Rlci8wMTllMTc3NC1mMzNlLTczMjQtYWZjMi1lZDU3ZjFkNjEwMDcvOTZiYjM2ZjIzYzg3OGRkYWEyMTM1Y2UxMTBhMTRmMTg2NDhiMWM5YWIyMTM1ZWIwYjlkOTc0NjNhZjUxMDgxZi5qcGVnIiwiYnJhbmQiOiJtaXR1bGEiLCJlZGl0cyI6eyJyb3RhdGUiOm51bGwsInJlc2l6ZSI6eyJ3aWR0aCI6MzgwLCJoZWlnaHQiOjIzMCwiZml0IjoiY292ZXIifX19",
  "name": "Apartamento amplio en el Poblado los parra",
  "description": "Amplio apartamento en renta en El Poblado – Cerca a San Fernando Plaza ✨\nVive con comodidad y excelente ubicación en este exclusivo apartamento de 147 m², ubicado en piso 7, a pocos minutos de San Fernando Plaza. Cuenta con 3 habitaciones, todas con baño y Vestier; la habitación principal se destaca por su vestier doble. Además, dispone de baño social.\nSu zona social ofrece una sala comedor-amplia, espacio para estudio o sala de TV, cocina integral abierta, zona de ropas, y habitación con baño de servicio. Incluye parqueadero doble.\nLa unidad residencial ofrece excelentes zonas comunes: piscina para adultos y niños, gimnasio, salón social, parqueadero para visitantes y portería 24/7.\n\nUna opción ideal para quienes buscan amplitud, confort y una ubicación estratégica en El Poblado.",
  "number_of_bathrooms_total": 4,
  "address": {
    "@type": "PostalAddress",
    "address_region": "Antioquia",
    "address_locality": "Medellín",
    "street_address": "Calle 1b Sur #38-90, El Poblado, Medellín, Antioquia, Colombia",
    "address_country": {
      "@type": "Country",
      "name": "CO"
    }
  },
  "floor_size": {
    "@type": "QuantitativeValue",
    "value": "147",
    "unit_code": "MTK"
  },
  "geo": {
    "@type": "GeoCoordinates",
    "latitude": "6.2019456",
    "longitude": "-75.5701562"
  },
  "from_url": "https://casas.mitula.com.co/casas/arriendo-st-antioquia"
}
```

Each scraped property returns a structured record with 17 core fields:

#### Core Identification

| Field | Meaning |
|---|---|
| `Listing ID` | Unique identifier for the property listing within Mitula |
| `Source ID` | Internal source tracking identifier |
| `Position` | Position/ranking of the property on the search results page |
| `Agency` | Real estate agency or owner managing the listing |

#### Property Characteristics

| Field | Meaning |
|---|---|
| `Property Type` | Category of the property (e.g., apartment, house, land, commercial) |
| `Number Of Bedrooms` | Total count of bedrooms in the property |
| `Number Of Bathrooms` | Total count of bathrooms in the property |
| `Number Of Bathrooms Total` | Full bathroom count including half-baths |
| `Floor Area` | Living space in square meters or local units |
| `Floor Size` | Alternative field for property size measurement |
| `Address` | Street address of the property |
| `Location IDs` | Geographic location identifiers used by Mitula's system |

#### Content & Media

| Field | Meaning |
|---|---|
| `Name` | Property title or listing name as displayed |
| `Description` | Full text description of the property, features, and amenities |
| `Image` | URL to the primary property image or image gallery |
| `Points Of Interest` | Nearby landmarks, amenities, and facilities (schools, transit, shops) |

#### Geolocation

| Field | Meaning |
|---|---|
| `Geo` | Geographic coordinates (latitude/longitude) or geospatial data |

#### Metadata

| Field | Meaning |
|---|---|
| `Operations` | Listing operation type (e.g., rental, sale, exchange) |

***

### How to Use

1. **Find search URLs** — On Mitula, navigate to a property search page and apply filters (location, price, type). Copy the full URL.
2. **Prepare your input** — Paste URLs into the `urls` array. Adjust `max_items_per_url` based on expected result set size (e.g., `200` for large markets).
3. **Configure proxy** — Select the country code matching your target region for reliable collection and to avoid IP blocks.
4. **Set error handling** — Use `ignore_url_failures: true` for batch runs to handle occasional page issues gracefully.
5. **Run the scraper** — Start the actor and monitor progress in the logs.
6. **Export data** — Download results as JSON, CSV, or Excel for analysis in spreadsheets, databases, or BI tools.

**Tips:**

- Use narrower search filters (e.g., specific neighborhoods) to ensure high-quality results in fewer API calls.
- For multi-country scraping, run separate jobs per country to optimize proxy routing.
- Store `Geo` coordinates for map visualizations and distance-based analysis.

***

### Use Cases & Business Value

- **Market intelligence:** Monitor property availability and pricing trends by location and type
- **Investment analysis:** Compare properties, identify opportunities, track price movements over time
- **Property aggregation:** Feed Mitula data into independent real estate platforms and comparison tools
- **Academic research:** Study housing markets, vacancy rates, and affordability across regions
- **Lead generation:** Build targeted property lists for real estate agents and investors

The Mitula Property Scraper transforms weeks of manual data collection into minutes, enabling data-driven real estate decisions at scale.

***

### Conclusion

The **Mitula Property Search Scraper** is a powerful tool for anyone needing structured property data from global markets. With support for all country sites, flexible scaling, and detailed 17-field output, it unlocks competitive insights and accelerates real estate workflows. Start scraping today and transform property search data into actionable intelligence.

# Actor input Schema

## `urls` (type: `array`):

Add the URLs of the property list urls you want to scrape. You can paste URLs one by one, or use the Bulk edit section to add a prepared list.

## `ignore_url_failures` (type: `boolean`):

If true, the scraper will continue running even if some URLs fail to be scraped.

## `max_items_per_url` (type: `integer`):

The maximum number of items to scrape per URL.

## `proxy` (type: `object`):

Select proxies to be used by your scraper.

## Actor input object example

```json
{
  "urls": [
    "https://casas.mitula.com.co/casas/arriendo-st-antioquia?page=2"
  ],
  "ignore_url_failures": true,
  "max_items_per_url": 20,
  "proxy": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}
```

# 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 = {
    "urls": [
        "https://casas.mitula.com.co/casas/arriendo-st-antioquia?page=2"
    ],
    "ignore_url_failures": true,
    "max_items_per_url": 20,
    "proxy": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "US"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("stealth_mode/mitula-property-search-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 = {
    "urls": ["https://casas.mitula.com.co/casas/arriendo-st-antioquia?page=2"],
    "ignore_url_failures": True,
    "max_items_per_url": 20,
    "proxy": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "US",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("stealth_mode/mitula-property-search-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 '{
  "urls": [
    "https://casas.mitula.com.co/casas/arriendo-st-antioquia?page=2"
  ],
  "ignore_url_failures": true,
  "max_items_per_url": 20,
  "proxy": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}' |
apify call stealth_mode/mitula-property-search-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Mitula Property Search Scraper",
        "description": "Scrape property listings from Mitula across all countries. This scraper extracts comprehensive real estate data including bedrooms, bathrooms, floor area, locations, images, and more — perfect for market analysis, property aggregation, and real estate research.",
        "version": "0.0",
        "x-build-id": "XUiJg4rjocPQieMkO"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/stealth_mode~mitula-property-search-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-stealth_mode-mitula-property-search-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/stealth_mode~mitula-property-search-scraper/runs": {
            "post": {
                "operationId": "runs-sync-stealth_mode-mitula-property-search-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/stealth_mode~mitula-property-search-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-stealth_mode-mitula-property-search-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": {
                    "urls": {
                        "title": "URLs of the property list urls to scrape",
                        "type": "array",
                        "description": "Add the URLs of the property list urls you want to scrape. You can paste URLs one by one, or use the Bulk edit section to add a prepared list.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "ignore_url_failures": {
                        "title": "Continue running even if some URLs fail to be scraped",
                        "type": "boolean",
                        "description": "If true, the scraper will continue running even if some URLs fail to be scraped."
                    },
                    "max_items_per_url": {
                        "title": "Max items per URL",
                        "type": "integer",
                        "description": "The maximum number of items to scrape per URL."
                    },
                    "proxy": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Select proxies to be used by your scraper."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
