# Imot.bg Bulgaria Real Estate Scraper (`solidcode/imot-bg-scraper`) Actor

\[💰 $3.0 / 1K] Extract Bulgarian real estate from imot.bg — apartments, houses, land & commercial, for sale or rent, with price, area, rooms, location, photos, descriptions & agency contacts. Search by city & type or paste imot.bg URLs.

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

## Pricing

from $3.00 / 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

## Imot.bg Bulgaria Real Estate Scraper

Pull live property listings from imot.bg — Bulgaria's largest real-estate portal — with prices, area, room counts, neighborhoods, full photo sets, and direct agency phone numbers. Filter by city, sale or rent, and six property categories, or paste a saved imot.bg search straight from your browser. Built for real-estate investors, proptech platforms, and market analysts who need fresh, structured Bulgarian property data without copying listings off the site by hand.

### Why This Scraper?

- **Six property categories in one run** — Apartments, Houses & Villas, Land & Plots, Commercial, Garages & Parking, or Any. Houses & Villas pulls villas, houses and floor-of-a-house listings; Commercial pulls offices, shops and business premises — each mapped to the right imot.bg section automatically.
- **Room-count granularity from studio to 5+** — pick any mix of 1-room (studio), 2, 3, 4, and 5+ room apartments; results from every selected size are merged and de-duplicated by listing ID.
- **Direct agency contacts** — every detailed listing returns the agency or private-seller name plus a working phone number and profile link, with a private-seller flag so you can separate owners from brokers.
- **City, region, and country-wide coverage** — search Sofia, Plovdiv, Varna, Burgas, Ruse, Stara Zagora, Pleven and any other Bulgarian town, step up to oblast (region) level, or leave the city blank to sweep the whole country.
- **EUR price filtering on sale and rent** — set a minimum and maximum in euros (monthly rent for rentals); "price by request" listings are kept rather than silently dropped.
- **Full Cyrillic fidelity** — Bulgarian neighborhood, district, and description text comes back correctly decoded, not mangled into question marks.
- **Construction details that drive valuation** — detailed runs add construction type (brick, panel, EPK), heating, floor and total floors, and year built — the fields appraisers and investors actually price on.
- **Up to 50,000 listings per run** — automatic pagination walks every results page; set Max Results to 0 for an unlimited sweep guarded by a 50,000-row ceiling.
- **Paste-a-search power mode** — build any filtered search on imot.bg, copy the address bar, and the scraper reproduces it exactly, preserving filters the guided fields don't expose.

### Use Cases

**Market Research**
- Track asking prices and price-per-square-meter across Sofia, Plovdiv, and Varna neighborhoods.
- Measure supply by property type and room count in a given oblast.
- Build time-series datasets by re-running a saved search on a schedule.

**Investment Analysis**
- Compare yields by filtering sale and rent listings in the same neighborhood.
- Screen land plots at the region level for development opportunities.
- Filter on construction type and year built to target renovation or new-build stock.

**Lead Generation**
- Collect agency names and direct phone numbers for outreach to active brokers.
- Separate private sellers from agencies using the private-seller flag.
- Build a contact list of listing agents in a target city.

**Price Monitoring**
- Set EUR price bands to watch a specific segment of the market.
- Detect new listings entering a price range over repeated runs.
- Benchmark price-per-square-meter against your own portfolio.

**Portal & App Data**
- Feed a property-comparison site or aggregator with structured imot.bg inventory.
- Enrich a CRM with photos, descriptions, and contact details per listing.

### Getting Started

#### Apartments for sale in Sofia

```json
{
  "city": "Sofia",
  "listingType": "sale",
  "propertyType": "apartment",
  "maxResults": 100
}
````

#### Two- and three-room rentals under €600 in Plovdiv

```json
{
  "city": "Plovdiv",
  "listingType": "rent",
  "propertyType": "apartment",
  "rooms": ["2", "3"],
  "priceMax": 600,
  "maxResults": 200
}
```

#### Full details from a saved imot.bg search

```json
{
  "startUrls": [
    "https://www.imot.bg/obiavi/prodazhbi/grad-varna/tristaen"
  ],
  "includeDetails": true,
  "maxResults": 500
}
```

### Input Reference

#### Search

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `listingType` | string | `"sale"` | `For Sale` or `For Rent`. Ignored when Start URLs are provided. |
| `propertyType` | string | `"any"` | One of `Any`, `Apartments`, `Houses & Villas`, `Land & Plots`, `Commercial`, `Garages & Parking`. Ignored when Start URLs are provided. |
| `city` | string | `"Sofia"` | City to search, e.g. `Sofia`, `Plovdiv`, `Varna`, `Burgas`, `Ruse`. Leave empty to search the whole country. |

#### Filters

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `priceMin` | integer | *none* | Keep listings at or above this price in EUR (monthly rent for rentals). "By request" listings are kept. |
| `priceMax` | integer | *none* | Keep listings at or below this price in EUR. "By request" listings are kept. |
| `rooms` | array | `[]` | Apartment room counts to include: `1 room (studio)`, `2 rooms`, `3 rooms`, `4 rooms`, `5+ rooms`. Applies to apartments only; ignored for Houses, Land, Commercial, and Garages. |

#### Advanced & Output

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `startUrls` | array | `[]` | Paste imot.bg search-result or individual listing URLs. Overrides the guided fields above. |
| `includeDetails` | boolean | `false` | Open each listing page for the full description, complete photo set, construction type, heating, floor, year built, and contact details. |
| `maxResults` | integer | `100` | Maximum listings to collect. Set `0` for unlimited (a 50,000-row ceiling still applies). |

### Output

Each listing is one record. Search-card data is always present; the detail fields fill in when **Include Full Listing Details** is on.

```json
{
  "listingId": "1n12345678",
  "listingUrl": "https://www.imot.bg/obiava-1n12345678-tristaen-grad-sofiya",
  "title": "Тристаен, Лозенец",
  "listingType": "sale",
  "propertyType": "apartment",
  "price": 185000,
  "priceCurrency": "EUR",
  "priceFormatted": "185 000 EUR",
  "pricePerSqm": 2100,
  "area": 88,
  "rooms": "Тристаен",
  "floor": "4",
  "totalFloors": 6,
  "constructionType": "Тухла",
  "heatingType": "ТЕЦ",
  "yearBuilt": 2018,
  "city": "София",
  "neighborhood": "Лозенец",
  "description": "Просторен тристаен апартамент...",
  "imageThumbnail": "https://imotstatic2.imot.bg/.../1.jpg",
  "imageUrls": ["https://imotstatic2.imot.bg/.../1.jpg", "..."],
  "agencyName": "Address Real Estate",
  "agencyPhone": "0888123456",
  "agencyUrl": "https://www.imot.bg/.../agency",
  "isPrivateSeller": false,
  "publishedDate": "2024-05-10",
  "scrapedAt": "2024-05-12T08:30:00Z"
}
```

#### Core Fields

| Field | Type | Description |
|-------|------|-------------|
| `listingId` | string | Stable imot.bg listing identifier (used for de-duplication). |
| `listingUrl` | string | Direct link to the listing page. |
| `title` | string | Listing headline. |
| `listingType` | string | `sale` or `rent`. |
| `propertyType` | string | Property category of the listing (`apartment`, `house`, `land`, `commercial`, `garage`), derived from the listing itself. |
| `rooms` | string | Room description (e.g. Тристаен / 3-room). |
| `area` | number | Floor area in square meters. |
| `scrapedAt` | string | ISO 8601 timestamp of collection. |

#### Price

| Field | Type | Description |
|-------|------|-------------|
| `price` | number | Numeric price; `null` for "by request" listings. |
| `priceCurrency` | string | `EUR` or `BGN`. |
| `priceFormatted` | string | Price as shown on the site. |
| `pricePerSqm` | number | Price per square meter when available. |

#### Location

| Field | Type | Description |
|-------|------|-------------|
| `city` | string | City name (Cyrillic). |
| `neighborhood` | string | Neighborhood / quarter. |
| `district` | string | District, when listed. |
| `address` | string | Street address, when listed. |

#### Details (when enabled)

| Field | Type | Description |
|-------|------|-------------|
| `floor` | string | Floor of the unit. |
| `totalFloors` | number | Total floors in the building. |
| `constructionType` | string | Construction type (brick, panel, EPK). |
| `heatingType` | string | Heating type. |
| `yearBuilt` | number | Year the building was completed. |
| `description` | string | Full listing description. |
| `imageThumbnail` | string | Primary photo URL. |
| `imageUrls` | array | All photo URLs for the listing. |
| `publishedDate` | string | Date the listing was published. |

#### Contact (when enabled)

| Field | Type | Description |
|-------|------|-------------|
| `agencyName` | string | Agency or seller name. |
| `agencyPhone` | string | Direct contact phone number. |
| `agencyUrl` | string | Link to the agency or seller profile. |
| `isPrivateSeller` | boolean | `true` for private owners, `false` for agencies. |

### Tips for Best Results

- **Land searches are region-level.** imot.bg lists plots by oblast, not city — choose `Land & Plots` and the search automatically steps up to the surrounding region, so expect region-wide results.
- **Price filtering is in euros.** Set `priceMin` / `priceMax` in EUR; for rentals these bound the monthly rent. Listings priced "by request" are always kept so you don't lose premium stock.
- **Room counts apply to apartments only.** The `rooms` filter is ignored for Houses, Land, Commercial, and Garages — those searches return their full results regardless of room count, so use `propertyType` to target them.
- **Paste a saved search for exact filters.** Build the search on imot.bg with any filters you like, copy the address bar into `startUrls`, and every filter is reproduced precisely — including ones the guided fields don't cover.
- **Turn on Include Full Listing Details for contacts and photos.** Names, phone numbers, full galleries, and construction data only appear when detail mode is on; leave it off for fast, inexpensive price-and-area sweeps.
- **Leave the city blank for a national view.** An empty city searches all of Bulgaria — ideal for country-wide market snapshots.
- **Set Max Results to 0 for a complete sweep.** Pagination runs to the natural end of the results, capped at 50,000 rows to keep runs bounded.

### Pricing

**From $3.00 per 1,000 results** — flat pay-per-result, undercutting comparable Bulgarian property scrapers. Bronze, Silver, and Gold subscribers pay progressively less; the table below shows total cost at each discount tier.

| Results | No discount | Bronze | Silver | Gold |
|---------|-------------|--------|--------|------|
| 100 | $0.36 | $0.34 | $0.32 | $0.30 |
| 1,000 | $3.60 | $3.40 | $3.20 | $3.00 |
| 10,000 | $36.00 | $34.00 | $32.00 | $30.00 |
| 100,000 | $360.00 | $340.00 | $320.00 | $300.00 |

A "result" is one listing record pushed to your dataset. No compute or time-based charges — you pay per result, plus a small fixed per-run start fee.

### Integrations

Export data in JSON, CSV, Excel, XML, or RSS. Connect to 1,500+ apps via:

- **Zapier** / **Make** / **n8n** — Workflow automation
- **Google Sheets** — Direct spreadsheet export
- **Slack** / **Email** — Notifications on new results
- **Webhooks** — Trigger custom APIs on run completion
- **Apify API** — Full programmatic access

### Legal & Ethical Use

This scraper collects publicly available listing information from imot.bg. Use the data responsibly and in line with imot.bg's terms of service and applicable laws. Contact details are provided for legitimate business communication only — respect privacy regulations (including GDPR) and anti-spam rules when contacting agencies or sellers, and do not use the data for unsolicited bulk messaging. You are responsible for how you use the collected data.

# Actor input Schema

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

Choose whether to collect listings that are for sale or for rent. Ignored when Start URLs are provided.

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

Filter by property category. Choose 'Any' to include all types. Ignored when Start URLs are provided.

## `city` (type: `string`):

City to search in Bulgaria, e.g. 'Sofia', 'Plovdiv', 'Varna', 'Burgas', 'Ruse'. Leave empty to search the whole country. Ignored when Start URLs are provided.

## `priceMin` (type: `integer`):

Only keep listings at or above this price, in euros. For rentals this is the monthly rent. Listings shown as 'by request' (no numeric price) are kept, so a very narrow price band can still return some by-request listings, and may stop scanning early after several pages with nothing in range. Leave empty for no minimum.

## `priceMax` (type: `integer`):

Only keep listings at or below this price, in euros. For rentals this is the monthly rent. Listings shown as 'by request' (no numeric price) are kept, so a very narrow price band can still return some by-request listings, and may stop scanning early after several pages with nothing in range. Leave empty for no maximum.

## `rooms` (type: `array`):

Number of rooms to include. Rooms applies to apartments only — it is ignored when Property Type is Houses, Land, Commercial, or Garages (those searches are unaffected by this filter). Leave empty for any size.

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

Power-user input. Paste imot.bg search-result URLs (build a filtered search on imot.bg and copy the address bar) or individual listing URLs. When provided, these override the For Sale/Rent, Property Type, City, and Filter settings above — any filters you set on the imot.bg site are preserved this way.

## `includeDetails` (type: `boolean`):

Open each listing's own page to add the full description, the complete photo set, construction type, heating, floor, year built, and the agency or private-seller contact details. Turn off (the default) for faster, cheaper runs that still return everything on the search card — price, area, rooms, location, a thumbnail, and the title. Slower when on: it makes one extra request per listing.

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

Maximum number of listings to collect across all searches and URLs. Set 0 for unlimited (an internal upper limit of 50,000 rows per run still applies to prevent runaway pagination). Results are collected in full pages, so the final page may overshoot this cap by a few records.

## Actor input object example

```json
{
  "listingType": "sale",
  "propertyType": "any",
  "city": "Sofia",
  "rooms": [],
  "startUrls": [],
  "includeDetails": false,
  "maxResults": 100
}
```

# Actor output Schema

## `overview` (type: `string`):

Table of property listings with price, location, and key attributes.

## `detailed` (type: `string`):

Per-listing detail view: price/m², floor, construction, heating, year, agency contact, and photo.

# 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 = {
    "listingType": "sale",
    "propertyType": "any",
    "city": "Sofia",
    "rooms": [],
    "startUrls": [],
    "includeDetails": false,
    "maxResults": 100
};

// Run the Actor and wait for it to finish
const run = await client.actor("solidcode/imot-bg-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 = {
    "listingType": "sale",
    "propertyType": "any",
    "city": "Sofia",
    "rooms": [],
    "startUrls": [],
    "includeDetails": False,
    "maxResults": 100,
}

# Run the Actor and wait for it to finish
run = client.actor("solidcode/imot-bg-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 '{
  "listingType": "sale",
  "propertyType": "any",
  "city": "Sofia",
  "rooms": [],
  "startUrls": [],
  "includeDetails": false,
  "maxResults": 100
}' |
apify call solidcode/imot-bg-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Imot.bg Bulgaria Real Estate Scraper",
        "description": "[💰 $3.0 / 1K] Extract Bulgarian real estate from imot.bg — apartments, houses, land & commercial, for sale or rent, with price, area, rooms, location, photos, descriptions & agency contacts. Search by city & type or paste imot.bg URLs.",
        "version": "1.0",
        "x-build-id": "lTUL37i5SKO5nLiDy"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/solidcode~imot-bg-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-solidcode-imot-bg-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/solidcode~imot-bg-scraper/runs": {
            "post": {
                "operationId": "runs-sync-solidcode-imot-bg-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/solidcode~imot-bg-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-solidcode-imot-bg-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": {
                    "listingType": {
                        "title": "For Sale or For Rent",
                        "enum": [
                            "sale",
                            "rent"
                        ],
                        "type": "string",
                        "description": "Choose whether to collect listings that are for sale or for rent. Ignored when Start URLs are provided.",
                        "default": "sale"
                    },
                    "propertyType": {
                        "title": "Property Type",
                        "enum": [
                            "any",
                            "apartment",
                            "house",
                            "land",
                            "commercial",
                            "garage"
                        ],
                        "type": "string",
                        "description": "Filter by property category. Choose 'Any' to include all types. Ignored when Start URLs are provided.",
                        "default": "any"
                    },
                    "city": {
                        "title": "City",
                        "type": "string",
                        "description": "City to search in Bulgaria, e.g. 'Sofia', 'Plovdiv', 'Varna', 'Burgas', 'Ruse'. Leave empty to search the whole country. Ignored when Start URLs are provided."
                    },
                    "priceMin": {
                        "title": "Minimum Price (EUR)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only keep listings at or above this price, in euros. For rentals this is the monthly rent. Listings shown as 'by request' (no numeric price) are kept, so a very narrow price band can still return some by-request listings, and may stop scanning early after several pages with nothing in range. Leave empty for no minimum."
                    },
                    "priceMax": {
                        "title": "Maximum Price (EUR)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only keep listings at or below this price, in euros. For rentals this is the monthly rent. Listings shown as 'by request' (no numeric price) are kept, so a very narrow price band can still return some by-request listings, and may stop scanning early after several pages with nothing in range. Leave empty for no maximum."
                    },
                    "rooms": {
                        "title": "Number of Rooms",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Number of rooms to include. Rooms applies to apartments only — it is ignored when Property Type is Houses, Land, Commercial, or Garages (those searches are unaffected by this filter). Leave empty for any size.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "1",
                                "2",
                                "3",
                                "4",
                                "5+"
                            ],
                            "enumTitles": [
                                "1 room (studio)",
                                "2 rooms",
                                "3 rooms",
                                "4 rooms",
                                "5+ rooms"
                            ]
                        },
                        "default": []
                    },
                    "startUrls": {
                        "title": "Start URLs",
                        "type": "array",
                        "description": "Power-user input. Paste imot.bg search-result URLs (build a filtered search on imot.bg and copy the address bar) or individual listing URLs. When provided, these override the For Sale/Rent, Property Type, City, and Filter settings above — any filters you set on the imot.bg site are preserved this way.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "includeDetails": {
                        "title": "Include Full Listing Details",
                        "type": "boolean",
                        "description": "Open each listing's own page to add the full description, the complete photo set, construction type, heating, floor, year built, and the agency or private-seller contact details. Turn off (the default) for faster, cheaper runs that still return everything on the search card — price, area, rooms, location, a thumbnail, and the title. Slower when on: it makes one extra request per listing.",
                        "default": false
                    },
                    "maxResults": {
                        "title": "Max Results",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum number of listings to collect across all searches and URLs. Set 0 for unlimited (an internal upper limit of 50,000 rows per run still applies to prevent runaway pagination). Results are collected in full pages, so the final page may overshoot this cap by a few records.",
                        "default": 100
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
