# MyHome.ie Property Scraper (`automation-lab/myhome-ie-property-scraper`) Actor

Scrape MyHome.ie property listings for prices, addresses, beds, baths, BER ratings, images, agents, and listing URLs.

- **URL**: https://apify.com/automation-lab/myhome-ie-property-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Real estate
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.60 / 1,000 result extracteds

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

## MyHome.ie Property Scraper

Extract Irish property listings from MyHome.ie search results for market research, lead generation, portfolio monitoring, and property data workflows.

This actor turns public MyHome.ie search pages into structured records you can export, filter, schedule, and connect to the rest of your Apify workflows.

### What does MyHome.ie Property Scraper do?

MyHome.ie Property Scraper collects public property listing data from MyHome.ie search pages and saves it into an Apify dataset.

It reads listing cards from MyHome.ie pages such as Dublin homes for sale, Cork rentals, Galway apartments, or commercial property searches.

The actor returns clean rows with listing URLs, prices, addresses, beds, baths, sizes, BER ratings, images, agency details, and crawl metadata.

It is designed for repeatable market snapshots rather than one-off manual copying.

You can run it once for a quick CSV export or schedule it to build a historical property inventory dataset.

### Who is it for?

#### 🏘️ Estate agents and letting agents

Use the actor to monitor competing stock in your target county or town.

Typical workflows:

- Track new residential sale listings in Dublin, Cork, Galway, Limerick, or another county.
- Compare asking prices for similar property types.
- Watch competing agencies and identify market movement.
- Export weekly inventory snapshots for internal review.

#### 📈 Property investors and buyers' agents

Use the output to build shortlists and watch asking-price changes across areas.

Typical workflows:

- Collect all listings matching a county search.
- Compare bedrooms, floor sizes, and listed prices.
- Feed listing rows into a valuation or deal-screening spreadsheet.
- Schedule recurring runs to spot new opportunities quickly.

#### 📊 Analysts, journalists, and researchers

Use repeatable structured data for housing-market reporting and local market analysis.

Typical workflows:

- Build county-level supply snapshots.
- Compare sale versus rental inventory.
- Export search-card data to BI tools.
- Document the source URL and scrape timestamp for every row.

#### 🧪 Proptech and data teams

Use the actor as a source connector for Irish real-estate products.

Typical workflows:

- Feed matching, alerting, or enrichment pipelines.
- Test property classification and pricing models.
- Join MyHome.ie rows with your own CRM or geospatial data.
- Trigger downstream automation when a matching listing appears.

#### 🧭 Relocation and corporate-housing teams

Use the actor to prepare location shortlists for clients moving to Ireland.

Typical workflows:

- Collect rental listings in selected counties.
- Share CSV exports with consultants.
- Compare areas by price range and property attributes.
- Refresh searches before client calls.

### Why use this actor?

MyHome.ie is one of Ireland's important property marketplaces.

Manual copying is slow, inconsistent, and hard to repeat.

This actor gives you repeatable structured output that can be exported to JSON, CSV, Excel, Google Sheets, or your own API pipeline.

It also records the original search URL, page number, and scrape timestamp so each row can be traced back to the run context.

### What data can you extract?

| Field | Description |
|---|---|
| `listingId` | Numeric MyHome.ie listing identifier when available |
| `url` | Absolute listing brochure URL |
| `title` | Listing title derived from the address |
| `address` | Address text shown on the search card |
| `price` | Displayed price, including POA or rent text |
| `priceAmount` | Numeric euro price when it can be parsed |
| `currency` | EUR when a euro price is present |
| `beds` | Bedroom count when shown |
| `baths` | Bathroom count when shown |
| `size` | Floor size text when shown |
| `berRating` | BER rating from the card image alt text |
| `propertyType` | Property type detected from visible card text |
| `agentName` | Selling or letting agency name |
| `agentLogoUrl` | Agency logo URL |
| `imageUrls` | Listing photo URLs visible in the card |
| `county` | County or final address area |
| `listingType` | Sale, rent, or unknown |
| `propertyCategory` | Residential, commercial, or unknown |
| `searchUrl` | Search result URL that produced the row |
| `pageNumber` | Result page number |
| `scrapedAt` | Timestamp of the run |

### How much does it cost to scrape MyHome.ie property listings?

This actor uses pay-per-event pricing.

You pay a small run-start fee plus a per-listing fee for each saved result.

The default input is intentionally small so your first run is inexpensive.

The current platform pricing is:

| Event | Free users | Bronze | Silver | Gold | Platinum | Diamond |
|---|---:|---:|---:|---:|---:|---:|
| Run started | $0.005 | $0.005 | $0.005 | $0.005 | $0.005 | $0.005 |
| Result extracted | $0.00115 | $0.00100 | $0.00078 | $0.00060 | $0.00040 | $0.00028 |

Example run costs before Apify platform plan limits or external workflow costs:

| Example | Input | Approx. Free-user actor charge |
|---|---|---:|
| Smoke test | 20 listings | about $0.028 |
| County snapshot | 100 listings | about $0.120 |
| Larger monitoring run | 500 listings | about $0.580 |

A free-plan Apify user can usually run small smoke tests and county snapshots within the monthly free credits, but exact availability depends on your Apify plan, other actors you run, and platform pricing at the time of use.

For larger jobs, raise `maxItems` and `maxPages` after confirming that the output matches your needs.

### Input options

You can use exact MyHome.ie search URLs or structured fields.

`startUrls` is best when you already configured filters on MyHome.ie.

Structured fields are best for simple county searches.

The main inputs are:

- `startUrls` — one or more MyHome.ie search URLs.
- `county` — county name for structured search construction.
- `listingType` — sale or rent.
- `propertyCategory` — residential or commercial.
- `maxItems` — maximum listings to save across all searches.
- `maxPages` — maximum result pages to fetch per search.

### Start URL examples

Use a full search URL when you need exact MyHome.ie filters.

Examples:

- `https://www.myhome.ie/residential/dublin/property-for-sale`
- `https://www.myhome.ie/residential/cork/property-to-rent`
- `https://www.myhome.ie/commercial/dublin/property-for-sale`

This is the safest option for narrow searches because the URL already contains the site's own filter structure.

### Structured search examples

Set `county` to `Dublin`, `listingType` to `sale`, and `propertyCategory` to `residential` to scrape Dublin residential sale listings.

Set `county` to `Cork`, `listingType` to `rent`, and `propertyCategory` to `residential` to scrape Cork rental listings.

Set `county` to `Dublin`, `listingType` to `sale`, and `propertyCategory` to `commercial` to scrape Dublin commercial sale listings.

Structured searches are convenient for simple county-level runs.

For advanced MyHome.ie filters, paste a `startUrls` value instead.

### How to scrape MyHome.ie in 5 steps

1. Open the actor on Apify.
2. Add one or more MyHome.ie search URLs, or keep the prefilled Dublin search.
3. Set `maxItems` and `maxPages`.
4. Run the actor.
5. Download the dataset or connect it to your workflow.

For a first test, keep `maxItems` around 20 and `maxPages` at 1.

For monitoring, schedule the same input daily or weekly and compare datasets over time.

### Output example

```json
{
  "listingId": "4996315",
  "url": "https://www.myhome.ie/residential/brochure/8-westmill-place-swords-county-dublin/4996315",
  "title": "8 Westmill Place, Swords, County Dublin",
  "address": "8 Westmill Place, Swords, County Dublin",
  "price": "€550,000",
  "priceAmount": 550000,
  "currency": "EUR",
  "beds": 3,
  "baths": 3,
  "size": "105m²",
  "propertyType": "Semi-Detached House",
  "agentName": "PropertyTeam Paul Reddy",
  "listingType": "sale",
  "propertyCategory": "residential"
}
````

### Tips for better results

- Use MyHome.ie search URLs when you need exact filters.
- Start with one page and 20 listings for a quick smoke test.
- Increase `maxPages` for broader market snapshots.
- Use separate runs for different counties so the output is easier to compare.
- Export to CSV for spreadsheet analysis.
- Schedule recurring runs with the same input if you need a consistent time series.
- Keep the original `searchUrl` field when joining rows in downstream tools.

### Integration workflow ideas

#### Google Sheets review workflow

Run the actor, export the dataset to Google Sheets, and add analyst notes beside each listing.

This is useful for estate-agent market reviews and investor shortlists.

#### CRM or lead workflow

Send rows with matching price, area, or property type criteria into your CRM.

Use `url`, `address`, `agentName`, and `priceAmount` as matching fields.

#### Market dashboard workflow

Schedule county runs and load the dataset into a BI tool.

Group by `county`, `listingType`, `propertyCategory`, beds, and price bands.

#### Alert workflow

Use Make, Zapier, or an Apify webhook to trigger a notification when a scheduled run finishes.

Then filter the dataset for listings below a target price or in a target location.

### API usage with Node.js

```js
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/myhome-ie-property-scraper').call({
  startUrls: [{ url: 'https://www.myhome.ie/residential/dublin/property-for-sale' }],
  maxItems: 20,
  maxPages: 1
});
console.log(run.defaultDatasetId);
```

### API usage with Python

```python
from apify_client import ApifyClient

client = ApifyClient('YOUR_APIFY_TOKEN')
run = client.actor('automation-lab/myhome-ie-property-scraper').call(run_input={
    'startUrls': [{'url': 'https://www.myhome.ie/residential/dublin/property-for-sale'}],
    'maxItems': 20,
    'maxPages': 1,
})
print(run['defaultDatasetId'])
```

### API usage with cURL

```bash
curl -X POST 'https://api.apify.com/v2/acts/automation-lab~myhome-ie-property-scraper/runs?token=YOUR_APIFY_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"startUrls":[{"url":"https://www.myhome.ie/residential/dublin/property-for-sale"}],"maxItems":20,"maxPages":1}'
```

### MCP usage with Claude Code and Claude Desktop

Use this actor through Apify MCP from Claude Desktop, Claude Code, Cursor, or any MCP-compatible client.

MCP server URL:

`https://mcp.apify.com/?tools=automation-lab/myhome-ie-property-scraper`

Claude Code setup with the required HTTP transport form:

```bash
claude mcp add --transport http apify-myhome-ie "https://mcp.apify.com/?tools=automation-lab/myhome-ie-property-scraper"
```

Claude Desktop JSON server configuration:

```json
{
  "mcpServers": {
    "apify-myhome-ie": {
      "url": "https://mcp.apify.com/?tools=automation-lab/myhome-ie-property-scraper"
    }
  }
}
```

Example prompts showing MCP usage:

- "Run the MyHome.ie Property Scraper for Dublin homes for sale and summarize price ranges."
- "Get 50 Cork rental listings and export them to CSV."
- "Compare MyHome.ie residential listings from Dublin and Galway."
- "Find commercial MyHome.ie listings in Dublin and return address, price, and agency name."
- "Schedule a weekly run for this MyHome.ie URL and tell me what changed."

### Data quality notes

The actor extracts data visible on MyHome.ie search cards.

Some fields may be missing when MyHome.ie does not show them on the card.

`priceAmount` is omitted for POA and other non-numeric prices.

Image arrays may contain only the photos included in the server-rendered card.

The actor does not claim to enrich listings with hidden detail-page fields unless those values are visible in the search-card HTML.

### Limits and pagination

`maxPages` controls how many result pages are fetched per search URL.

`maxItems` controls the total number of saved listings across all searches.

The actor de-duplicates listings by listing ID.

If MyHome.ie has fewer listings for the selected filters than your `maxItems` value, the run will finish with fewer rows.

If a page structure changes, use the Support tab on the actor page to report the affected URL.

### Troubleshooting

#### Why did a run return fewer rows than expected?

Check whether the selected MyHome.ie search page has enough listings and whether `maxPages` is high enough.

If you used structured fields, try creating the exact search on MyHome.ie and pasting the search URL into `startUrls`.

#### Why is a field empty?

The value likely was not visible in the search-card HTML.

For example, some cards may not show a BER rating, size, bathroom count, or numeric price.

#### Why is `priceAmount` missing for a listing?

MyHome.ie sometimes displays POA, rent text, or other non-numeric price strings.

The actor preserves the original `price` text and only fills `priceAmount` when a numeric euro price can be parsed.

#### How do I get exact filters?

Create the filtered search on MyHome.ie, copy the URL from your browser, and paste it into `startUrls`.

That approach is more precise than reconstructing every filter from structured fields.

### Legality and responsible use

This actor extracts publicly available listing information from web pages.

You are responsible for using the data lawfully and respecting MyHome.ie terms, privacy rules, and applicable regulations.

Do not scrape personal data you are not allowed to process.

Do not use the output for unlawful discrimination, spam, or other prohibited activities.

If you process property data at scale, consult your legal team about retention, purpose limitation, and downstream use.

### Related scrapers

Other automation-lab actors that may fit nearby workflows:

- https://apify.com/automation-lab/zillow-scraper
- https://apify.com/automation-lab/booking-scraper
- https://apify.com/automation-lab/google-maps-lead-finder

Use them when your workflow needs US property data, hospitality data, or local business leads alongside Irish property listings.

### FAQ

#### Does it open every listing detail page?

No. The MVP extracts listing-card data from search pages for speed and reliability.

#### Can I scrape rentals?

Yes. Use a rental search URL or set `listingType` to `rent`.

#### Can I scrape commercial properties?

Yes. Use a commercial MyHome.ie URL or set `propertyCategory` to `commercial`.

#### Can I scrape multiple counties in one run?

Yes. Add multiple `startUrls`, or run separate structured searches for cleaner comparisons.

#### How do I avoid duplicate rows?

The actor de-duplicates listings by `listingId` during a run.

#### Can I schedule recurring monitoring?

Yes. Use Apify schedules with the same input and compare dataset exports over time.

### Changelog

#### 0.1

Initial version for MyHome.ie search-result property listings.

### Support

If you need a new field, detail-page extraction, or a different Irish property source, open an issue on the actor page.

# Actor input Schema

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

MyHome.ie search result URLs to scrape. If provided, these override the structured county/type fields.

## `county` (type: `string`):

Irish county or area slug used when Start URLs are empty, for example Dublin, Cork, Galway, or Limerick.

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

Choose whether to scrape properties for sale or to rent.

## `propertyCategory` (type: `string`):

Choose residential or commercial property search pages.

## `minPrice` (type: `integer`):

Optional minimum price filter added to generated MyHome.ie URLs.

## `maxPrice` (type: `integer`):

Optional maximum price filter added to generated MyHome.ie URLs.

## `maxPages` (type: `integer`):

Maximum result pages to crawl for each Start URL or generated search.

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

Maximum number of property listings to save.

## `maxRequestRetries` (type: `integer`):

Number of retry attempts for failed page requests.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.myhome.ie/residential/dublin/property-for-sale"
    }
  ],
  "county": "Dublin",
  "listingType": "sale",
  "propertyCategory": "residential",
  "maxPages": 1,
  "maxItems": 20,
  "maxRequestRetries": 3
}
```

# Actor output Schema

## `propertyListings` (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 = {
    "startUrls": [
        {
            "url": "https://www.myhome.ie/residential/dublin/property-for-sale"
        }
    ],
    "county": "Dublin",
    "listingType": "sale",
    "propertyCategory": "residential",
    "maxPages": 1,
    "maxItems": 20,
    "maxRequestRetries": 3
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/myhome-ie-property-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 = {
    "startUrls": [{ "url": "https://www.myhome.ie/residential/dublin/property-for-sale" }],
    "county": "Dublin",
    "listingType": "sale",
    "propertyCategory": "residential",
    "maxPages": 1,
    "maxItems": 20,
    "maxRequestRetries": 3,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/myhome-ie-property-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 '{
  "startUrls": [
    {
      "url": "https://www.myhome.ie/residential/dublin/property-for-sale"
    }
  ],
  "county": "Dublin",
  "listingType": "sale",
  "propertyCategory": "residential",
  "maxPages": 1,
  "maxItems": 20,
  "maxRequestRetries": 3
}' |
apify call automation-lab/myhome-ie-property-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "MyHome.ie Property Scraper",
        "description": "Scrape MyHome.ie property listings for prices, addresses, beds, baths, BER ratings, images, agents, and listing URLs.",
        "version": "0.1",
        "x-build-id": "T8bFyekC8fdXzqjxa"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~myhome-ie-property-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-myhome-ie-property-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/automation-lab~myhome-ie-property-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-myhome-ie-property-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/automation-lab~myhome-ie-property-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-myhome-ie-property-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": {
                    "startUrls": {
                        "title": "Start URLs",
                        "type": "array",
                        "description": "MyHome.ie search result URLs to scrape. If provided, these override the structured county/type fields.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "county": {
                        "title": "County / area",
                        "type": "string",
                        "description": "Irish county or area slug used when Start URLs are empty, for example Dublin, Cork, Galway, or Limerick.",
                        "default": "Dublin"
                    },
                    "listingType": {
                        "title": "Listing type",
                        "enum": [
                            "sale",
                            "rent"
                        ],
                        "type": "string",
                        "description": "Choose whether to scrape properties for sale or to rent.",
                        "default": "sale"
                    },
                    "propertyCategory": {
                        "title": "Property category",
                        "enum": [
                            "residential",
                            "commercial"
                        ],
                        "type": "string",
                        "description": "Choose residential or commercial property search pages.",
                        "default": "residential"
                    },
                    "minPrice": {
                        "title": "Minimum price",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Optional minimum price filter added to generated MyHome.ie URLs."
                    },
                    "maxPrice": {
                        "title": "Maximum price",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Optional maximum price filter added to generated MyHome.ie URLs."
                    },
                    "maxPages": {
                        "title": "Max pages per search",
                        "minimum": 1,
                        "maximum": 50,
                        "type": "integer",
                        "description": "Maximum result pages to crawl for each Start URL or generated search.",
                        "default": 3
                    },
                    "maxItems": {
                        "title": "Max listings",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of property listings to save.",
                        "default": 50
                    },
                    "maxRequestRetries": {
                        "title": "Max request retries",
                        "minimum": 0,
                        "maximum": 10,
                        "type": "integer",
                        "description": "Number of retry attempts for failed page requests.",
                        "default": 3
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
