# Imobiliare.ro Scraper - Romanian Real Estate Listings & Prices (`studio-amba/imobiliare-scraper`) Actor

Scrape property listings from Imobiliare.ro, Romania's largest real estate portal. Extract prices, locations, surfaces, rooms, images, and agency details for apartments, houses, plots, and commercial properties. No login needed.

- **URL**: https://apify.com/studio-amba/imobiliare-scraper.md
- **Developed by:** [Studio Amba](https://apify.com/studio-amba) (community)
- **Categories:** Real estate
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.20 / 1,000 result scrapeds

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

## How to integrate an Actor?

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

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

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

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

# README

## Imobiliare.ro Scraper

Catch a new [Imobiliare.ro](https://www.imobiliare.ro) listing the moment it posts, filtered by city, listing type, or property type — instead of refreshing the site by hand. This actor pulls prices, surfaces, rooms, floors, images, and agency details from Romania's largest real estate portal, covering apartments, houses, land, and commercial properties across every Romanian city and county.

### Why use this actor?

Imobiliare.ro is Romania's #1 property portal, aggregating listings from agencies, developers, and private sellers nationwide. This actor lets you collect that data at scale — prices, surfaces, rooms, floor numbers, images, and agency details — without manual browsing or a login.

Use cases include market analysis, investment research, relocation planning, price monitoring across Romanian cities, academic housing studies, and competitor tracking for real estate agencies and proptech products.

### How to scrape Imobiliare.ro data

1. Go to the actor's page on the Apify Store
2. Enter a Romanian city name (e.g., "Bucuresti", "Cluj-Napoca", "Timisoara", "Iasi") or paste an Imobiliare.ro search or listing URL
3. Choose listing type (sale or rent) and property type (apartment, house, studio, land, commercial, office)
4. Click "Start" to run the scraper
5. Download results as JSON, CSV, or Excel when complete

The actor fetches pages through Bright Data's Web Unlocker to get past Imobiliare.ro's DataDome bot protection, then extracts search-page data from the site's own embedded Inertia.js JSON payload for maximum reliability — no fragile CSS scraping for the fields that matter most.

### Input

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `searchQuery` | String | No | City or region to search, e.g., "Bucuresti", "Cluj-Napoca", "Timisoara". Defaults to "Bucuresti". |
| `startUrls` | Array | No | Imobiliare.ro search result pages or individual `/oferta/...` listing URLs. Overrides `searchQuery` if provided. |
| `listingType` | String | No | `sale` (default) or `rent` |
| `propertyType` | String | No | `apartamente` (apartment, default), `garsoniere` (studio), `case-vile` (house/villa), `terenuri` (land), `spatii-comerciale` (commercial), `birouri` (office, rent only) |
| `maxResults` | Integer | No | Maximum listings to return. Hard-capped at 300 for search-based runs (see Limitations). |
| `brightDataApiKey` | String | No | Your own Bright Data API key for the Web Unlocker zone. Leave empty to use the built-in unlocking service. |

### Output

Each listing contains:

| Field | Type | Example |
|-------|------|---------|
| `title` | String | `"Apartament 2 camere decomandat, Pipera"` |
| `price` | Number | `134189` |
| `currency` | String | `"EUR"` |
| `listingType` | String | `"sale"` |
| `propertyType` | String | `"apartamente"` |
| `location` | String | `"Pipera, Sector 1"` |
| `address` | String | `"Bd. Pipera, Pipera, Sector 1"` |
| `city` | String | `"Sector 1"` |
| `county` | String | `"Bucuresti"` |
| `area` | String | `"Pipera"` |
| `rooms` | Number | `2` |
| `bathrooms` | Number | `1` (detail-page scrapes only) |
| `floor` | Number | `2` |
| `totalFloors` | Number | `5` |
| `surface` | Number | `47.3` |
| `buildYear` | Number | `2026` |
| `imageUrl` | String | Primary listing photo URL |
| `imageUrls` | Array | All listing photo URLs |
| `description` | String | Property description text |
| `agencyName` | String | `"BECALI IMOBILIARE"` |
| `agencyUrl` | String | Agency profile URL, when available |
| `sellerType` | String | `"developer"`, `"agency"`, or `"owner"` |
| `publishedDate` | String | `"2026-07-31"` (approximate on search scrapes, exact on detail-page scrapes) |
| `daysOnMarket` | Number | `5` |
| `url` | String | Full Imobiliare.ro listing URL |
| `scrapedAt` | String | ISO 8601 timestamp |

### Example output

```json
{
    "title": "BECALI IMOBILIARE - Apartamente incepand de la 110.900 EUR + TVA",
    "price": 134189,
    "currency": "EUR",
    "listingType": "sale",
    "propertyType": "apartamente",
    "location": "Pipera, Sector 1",
    "address": "Bd. Pipera, Pipera, Sector 1",
    "city": "Sector 1",
    "county": "Bucuresti",
    "area": "Pipera",
    "rooms": 2,
    "floor": 2,
    "totalFloors": 5,
    "surface": 47.3,
    "buildYear": 2026,
    "imageUrl": "https://i.roamcdn.net/prop/imo/gallery-main-900w-watermark/...",
    "description": "BECALI IMOBILIARE lanseaza pe piata imobiliara din Nordul capitalei...",
    "agencyName": "BECALI IMOBILIARE",
    "sellerType": "developer",
    "publishedDate": "2026-07-31",
    "daysOnMarket": 5,
    "url": "https://www.imobiliare.ro/oferta/apartament-de-vanzare-sector-1-pipera-2-camere-3-41530318",
    "scrapedAt": "2026-08-05T09:30:00.000Z"
}
```

### Cost estimate

This actor fetches every page through Bright Data's Web Unlocker (one request per page, not a full browser session). Approximate costs:

- **~30 results (1 search page)**: $0.01-0.03 in platform credits
- **~300 results (10 search pages)**: $0.10-0.30 in platform credits
- **Individual listing URLs (`startUrls`)**: roughly one Web Unlocker request per listing, so cost scales closer to $0.01-0.02/listing

Actual usage cost only settles once the run reports SUCCEEDED — reading the dataset from a still-running run will undercount what you'll actually be charged.

### Tips for best results

- **Start small** — test with `maxResults: 20` before running large scrapes.
- **Use specific cities** — searching for "Cluj-Napoca" returns more focused results than a broad national search.
- **Property types in Romanian** — use `apartamente`, `garsoniere`, `case-vile`, `terenuri`, `spatii-comerciale`, `birouri` for filtering.
- **Direct listing URLs get richer data** — pass an `/oferta/...` URL in `startUrls` to get an exact published date, bathroom count, and full description via the detail page, instead of the search-page preview fields.

### Limitations

- Imobiliare.ro fronts every page with DataDome bot protection. This actor routes requests through Bright Data's Web Unlocker to get past it.
- Imobiliare.ro's `robots.txt` explicitly allows crawling search-result pages 1 through 10 only (30 listings per page = 300 listings max per search). `maxResults` above 300 is capped for search-based runs. Use `startUrls` with direct listing URLs to go beyond this.
- Search-page listings include a description preview (not the full text) and an approximate publish date derived from the site's own "days on market" signal. Detail-page scrapes (via `startUrls`) return the exact published/updated date and full description.
- GPS coordinates are not available — the site's map data endpoint (`/map/*`) is disallowed by `robots.txt` and is not queried by this actor.
- The actor scrapes the public website. No login or authentication is used.
- Price data reflects the listed asking price, not the final transaction price.

### Related scrapers

- [Otodom Scraper](https://apify.com/itsnotyouitsme/otodom-scraper) — Polish real estate listings
- [Immoweb Scraper](https://apify.com/itsnotyouitsme/immoweb-scraper) — Belgium's #1 real estate portal
- [Idealista Scraper](https://apify.com/itsnotyouitsme/idealista-scraper) — Spanish real estate portal
- [Zimmo Scraper](https://apify.com/itsnotyouitsme/zimmo-scraper) — Belgian real estate listings
- [Immobiliare Scraper](https://apify.com/itsnotyouitsme/immobiliare-scraper) — Italian real estate listings
- [Aruodas Scraper](https://apify.com/itsnotyouitsme/aruodas-scraper) — Lithuanian real estate listings

### Need this data on a schedule, or a custom version?

We run this scraper as a managed service for businesses: scheduled runs,
deduplication, delta detection, and delivery to your inbox, Google Sheets,
or API — maintenance included. We can also build a custom version with your
exact fields and filters, or combine multiple sources into one feed.

See [studioamba.dev/services](https://studioamba.dev/services/) or email
<hello@studioamba.dev> for a free data sample.
We maintain 300+ European web scrapers and answer within one business day.

# Actor input Schema

## `searchQuery` (type: `string`):

City or region to search for properties, e.g., 'Bucuresti', 'Cluj-Napoca', 'Timisoara', 'Iasi'. Defaults to 'Bucuresti' if empty.

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

Imobiliare.ro search result pages or individual listing (/oferta/...) URLs. Overrides searchQuery if provided.

## `listingType` (type: `string`):

Search for properties for sale or for rent.

## `propertyType` (type: `string`):

Type of property to search for. Note: 'birouri' (offices) only exists for rent on the site. Leave empty for apartments (default).

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

Maximum number of property listings to scrape. Hard-capped at 300 for search-based runs — imobiliare.ro's robots.txt only allows crawling pages 1-10 of search results (30 listings/page). Use Start URLs with direct /oferta/ links to scrape more individual listings beyond this cap.

## `brightDataApiKey` (type: `string`):

Optional: your own Bright Data API key for the Web Unlocker zone. Leave empty to use the built-in unlocking service.

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

Legacy field, kept for backwards compatibility. Fetching now goes through the built-in Bright Data Web Unlocker, so this is ignored.

## Actor input object example

```json
{
  "searchQuery": "Bucuresti",
  "startUrls": [
    {
      "url": "https://www.imobiliare.ro/vanzare-apartamente/bucuresti"
    }
  ],
  "listingType": "sale",
  "propertyType": "apartamente",
  "maxResults": 20,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# 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 = {
    "searchQuery": "Bucuresti",
    "startUrls": [
        {
            "url": "https://www.imobiliare.ro/vanzare-apartamente/bucuresti"
        }
    ],
    "maxResults": 20,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("studio-amba/imobiliare-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 = {
    "searchQuery": "Bucuresti",
    "startUrls": [{ "url": "https://www.imobiliare.ro/vanzare-apartamente/bucuresti" }],
    "maxResults": 20,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("studio-amba/imobiliare-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "searchQuery": "Bucuresti",
  "startUrls": [
    {
      "url": "https://www.imobiliare.ro/vanzare-apartamente/bucuresti"
    }
  ],
  "maxResults": 20,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call studio-amba/imobiliare-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,studio-amba/imobiliare-scraper"
        }
    }
}

```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/icMmmImYXZxFgmSLS/builds/dC0vFDKKMGOiE2BjV/openapi.json