# MyHome.ie Homes Scraper (`axiomworks/myhome-property-scraper`) Actor

Extract MyHome.ie home listings for sale or rent, including addresses, prices, beds, baths, property types, coordinates, photos and listing dates. The Actor reads structured data embedded in search pages and supports county searches or supplied search URLs.

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

## Pricing

from $2.23 / 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/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

**Returns:** one row per MyHome.ie property listing with id, title, priceText, price, beds, baths, berRating and propertyType.
**Input:** `{"mode": "sale", "county": "galway", "maxItems": 20}`
**Best for:** Irish property market research, rental price monitoring, estate agent lead lists.

```json
{
  "id": "5035957",
  "title": "142 Manor Court, Western Distributor Road, Knocknacarra, Galway City",
  "priceText": "€325,000",
  "price": 325000,
  "beds": 2,
  "propertyType": "Apartment",
  "refreshedOn": "2026-10-14T12:14:27.8970000+01:00"
}
```

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

MyHome.ie Property Scraper is a MyHome.ie scraper and property API for Ireland. It collects listings from the public search result pages of MyHome.ie, for properties for sale and properties to rent, in any county or area. Each listing becomes one clean dataset row with the address, price, number of bedrooms and bathrooms, BER energy rating, property type, floor area, estate agency, coordinates, main photo and the date the listing went live.

You can search in two ways. The simple way is to pick a mode (sale or rent) and a county such as dublin, cork or galway. The flexible way is to paste one or more MyHome.ie search URLs, including URLs with filters, and the scraper follows the pages of each one. The scraper stops as soon as it has collected the number of listings you asked for in `maxItems`.

The data is read directly from the structured data that MyHome.ie embeds in its search pages, so there is no page rendering, no browser and no login. That keeps runs fast and cheap. The Galway prefill returned 20 listings from one page in the local verification run. Runtime depends on the search, filters and site response; narrow filters can require more pages.

This Actor is not affiliated with or endorsed by MyHome.ie. It only reads publicly visible listing pages.

### What data can you get?

Every record contains the fields below. Fields that a listing does not provide are returned as null, never as placeholder text.

| Field | Type | Description |
|---|---|---|
| id | string | MyHome.ie property ID, unique within a run |
| sourceUrl | string | Search results page the record came from |
| url | string | Property brochure page on MyHome.ie |
| listingType | string | ResidentialForSale or LettingsToRent |
| title | string | Full display address |
| address | string | Short street address |
| eircode | string | Irish postcode when listed |
| priceText | string | Price as displayed, for example "Price on Application" or "€2,500 / month" |
| price | number | Number parsed from the price text, monthly for rentals |
| beds | number | Number of bedrooms, null when the listing does not state it |
| baths | number | Number of bathrooms, null when the listing does not state it |
| priceChange | string | Latest price change shown on the listing, null if none |
| agentPhone | string | Agent phone number, null when not shown |
| hasVideo | boolean | Whether the listing has a video |
| berRating | string | Building Energy Rating such as A3 or C1 |
| propertyType | string | Detached House, Apartment, Semi-Detached and so on |
| status | string | Listing status such as ForSale or ToLet |
| sizeSqm | number | Floor area in square metres, converted from square feet when the listing gives feet |
| agencyName | string | Estate agency or advertiser |
| agentName | string | Negotiator name when listed |
| latitude | number | Latitude of the property |
| longitude | number | Longitude of the property |
| mainPhoto | string | URL of the main photo |
| photoCount | number | Number of photos on the listing |
| listedOn | string | ISO date-time when the listing was activated |
| refreshedOn | string | Last refreshed timestamp reported by MyHome.ie, with original timezone |
| openViewings | array | Public viewing entries, with original dates and formatted times; \[] when none are published |
| agencyPhone | string | Estate agency phone number |
| agencyEmail | string | Estate agency contact email |
| agencyAddress | string | Estate agency office address |
| agencyUrl | string | Agency profile page on MyHome.ie |
| agentEmail | string | Negotiator email when listed |
| agentJobTitle | string | Negotiator job title when listed |
| photos | array | Up to 50 photo URLs, only when includePhotos is true, otherwise null |
| isNewBuild | boolean | MyHome.ie new listing flag |
| saleAgreed | boolean | True when the listing is marked sale agreed |

Some listings show "Price on Application" instead of a figure. In that case `priceText` holds the text and `price` is null. Many listings leave out the floor area, the agent name or the Eircode, so those fields are filled less often than the address or price.

### How to use

1. Open the Actor on Apify and go to the Input tab.
2. Choose the mode: sale or rent.
3. Type a county slug, for example dublin, cork, galway, limerick or waterford. Alternatively paste MyHome.ie search URLs into Start URLs.
4. Set Max items to the number of listings you want.
5. Click Start. When the run finishes, open the Output tab to view the table or download JSON, CSV or Excel.

The scraper requests about one page per second. Each page holds around 20 listings, so a 100 listing run reads five pages. If a county has fewer listings than you asked for, the run ends with what exists. If the county or URL does not exist on MyHome.ie, the run finishes with zero items and a warning in the log instead of failing or inventing data.

A failed search is logged and skipped so later search URLs can still return listings. If no listings are saved, the final status tells you to check the county and mode, use a search results URL rather than a property brochure, or remove restrictive filters. Persistent blocking can be retried later or with `proxyConfiguration` enabled. Searches that produce no matching item are time-bounded. No placeholder or error rows are saved.

The optional `hasViewings` filter makes a viewing shortlist from the same search feed. With it enabled, only listings with at least one published `openViewings` entry count toward `maxItems`. Each entry keeps MyHome.ie's original keys, including `StartDate`, `EndDate`, and `FormattedString` when provided. An empty array means the source published no entries; null means the source field was missing. Times retain their source timezone. Entries may change or be cancelled, so check the brochure before travelling. The filter tests presence, not whether the time is still in the future.

`refreshedOn` complements `listedOn`: activation and refresh are different timestamps. Compare refresh timestamps between your saved runs to identify listings worth reviewing, but do not treat a refresh as proof of a price change. Compare `price` and `priceText` separately. These fields come from the existing search page and require no additional detail requests.

### Input

| Field | Type | Description |
|---|---|---|
| county | string | County or area slug, for example dublin. Used when Start URLs is empty. Default dublin. |
| mode | string | sale or rent. Default sale. |
| startUrls | array | Optional MyHome.ie search URLs. They replace county and mode. |
| minPrice | integer | Keep only listings priced at or above this euro amount. Listings without a numeric price are dropped when set. |
| maxPrice | integer | Keep only listings priced at or below this euro amount. |
| minBeds | integer | Keep only listings with at least this many bedrooms. |
| propertyType | string | Keep only listings whose property type contains this text, for example apartment. |
| berRatings | array | Keep only these BER first letters, for example \["A", "B"]. A matches A1, A2 and A3; use letters rather than full grades. |
| hasViewings | boolean | Return only listings with published open viewing entries. Default false. |
| includePhotos | boolean | Add a photos array with up to 50 image URLs. Default false. |
| maxItems | integer | Maximum unique matching listings across every URL combined, 1-10000, default 50. Counts listings that pass the filters. |
| proxyConfiguration | object | Apify Proxy settings. Default is no proxy. |

Example input for rentals in Cork using a search URL:

```json
{
  "startUrls": [{ "url": "https://www.myhome.ie/rentals/cork/property-to-rent" }],
  "maxItems": 20
}
```

Filters are applied to the listings the scraper reads, and it keeps paging until maxItems matching listings are found or the search ends, so narrow filters on a large county read more pages. Example with filters:

```json
{
  "mode": "sale",
  "county": "dublin",
  "minBeds": 3,
  "maxPrice": 500000,
  "berRatings": ["A", "B"],
  "maxItems": 40
}
```

Example input for properties for sale in Dublin:

```json
{
  "mode": "sale",
  "county": "dublin",
  "maxItems": 40
}
```

Viewing shortlist example:

```json
{"county":"galway","mode":"sale","hasViewings":true,"maxItems":7}
```

### Output

Each run writes its listings to the default dataset. A sale record looks like this:

```json
{
  "id": "5035957",
  "sourceUrl": "https://www.myhome.ie/residential/galway/property-for-sale?page=1",
  "url": "https://www.myhome.ie/residential/brochure/142-manor-court-western-distributor-road-knocknacarra-galway-city/5035957",
  "listingType": "ResidentialForSale",
  "title": "142 Manor Court, Western Distributor Road, Knocknacarra, Galway City",
  "address": "142 Manor Court, Western Distributor Road",
  "eircode": null,
  "priceText": "€325,000",
  "price": 325000,
  "beds": 2,
  "baths": 2,
  "berRating": "C1",
  "propertyType": "Apartment",
  "status": "ForSale",
  "sizeSqm": 99,
  "agencyName": "O'Donnellan & Joyce Auctioneers Ltd",
  "agentName": "Hugh O'Donnellan",
  "latitude": 53.26630401611328,
  "longitude": -9.127017974853516,
  "mainPhoto": "https://photos-a.propertyimages.ie/media/7/5/9/5035957/2f6198cd-a1f3-4815-ab33-408a1f375891_l.jpg",
  "photoCount": 14,
  "listedOn": "2026-10-14T12:14:27.8970000+01:00",
  "agencyPhone": null,
  "agencyEmail": "info@odj.ie",
  "agencyAddress": "5 Mary Street, Galway, Co. Galway",
  "agencyUrl": "https://www.myhome.ie/estate-agents/odonnellan-joyce-auctioneers-ltd-10532",
  "agentEmail": "hugh@odj.ie",
  "agentJobTitle": null,
  "photos": null,
  "isNewBuild": false,
  "saleAgreed": false,
  "priceChange": null,
  "refreshedOn": "2026-10-14T12:14:27.8970000+01:00",
  "openViewings": [
    {
      "Id": 0,
      "StartDate": "2026-10-17T12:45:00.0000000+01:00",
      "EndDate": "2026-10-17T13:15:00.0000000+01:00",
      "OpenViewingType": "OnViewing",
      "StartDateFormatted": "Sat Oct 17, 12.45pm",
      "EndDateFormatted": "Sat Oct 17, 1.15pm",
      "FeaturedSpotId": 690431,
      "ChannelId": 0,
      "FormattedString": "Sat Oct 17, 12.45pm - 1.15pm"
    }
  ]
}
```

A rental record has the same fields. Its `priceText` reads like "€2,500 / month", `listingType` is LettingsToRent and `status` is ToLet.

Duplicates are removed by property ID, including promoted listings that appear on more than one page. The id field is unique within a run. `maxItems` is one shared budget across all URLs, so earlier searches may fill it before later URLs are visited. Pagination begins at page 1 even if an input URL includes another page number.

### How much does it cost?

The Actor is charged per result, which means per listing saved to the dataset. You pay for the listings you receive and nothing for pages that return no data. See the Pricing tab on the Actor page for the current rate. Because the Actor stops at `maxItems`, you control the maximum cost of every run by choosing that number. Platform usage for compute is small because the Actor needs no browser.

### Use with AI agents (MCP)

You can call this Actor from any MCP compatible AI client through the Apify MCP server. Add this server URL to your client configuration:

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

Example prompts for your agent:

Prompt: "Get 30 three bedroom houses for sale in Cork from MyHome.ie and list the cheapest five."

Prompt: "Scrape rentals in Dublin and tell me the average monthly rent by number of bedrooms."

Prompt: "Collect listings in Galway and group them by estate agency."

The input field descriptions are written so an agent can fill them in without further help: county, mode and maxItems are enough for most tasks.

### Integrations and API

You can run the Actor from your own code with the Apify API. Replace YOUR_TOKEN with your Apify API token.

Python:

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_TOKEN")
run = client.actor("axiomworks/myhome-property-scraper").call(
    run_input={"mode": "rent", "county": "dublin", "maxItems": 50}
)
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["title"], item["priceText"])
```

JavaScript:

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

const client = new ApifyClient({ token: 'YOUR_TOKEN' });
const run = await client.actor('axiomworks/myhome-property-scraper').call({
    mode: 'sale',
    county: 'galway',
    maxItems: 50,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
const titles = items.map((item) => item.title);
```

cURL:

```bash
curl -X POST "https://api.apify.com/v2/acts/axiomworks~myhome-property-scraper/run-sync-get-dataset-items" \
  -H "Authorization: Bearer $APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"mode": "sale", "county": "cork", "maxItems": 20}'
```

You can also schedule runs to monitor prices over time, send results to Google Sheets, Make, Zapier or n8n, or trigger a webhook when a run finishes. Run the same search daily and compare `id` and `price` between runs to spot new listings and price changes.

### FAQ

**How many listings can I get?**
As many as MyHome.ie shows for the search. Large counties such as Dublin have hundreds of listings, smaller rental markets only a few dozen. Set `maxItems` to the number you need.

**Which counties can I use?**
Any county or area that has a MyHome.ie search page. The slug is the part of the URL after /residential/ or /rentals/. If you are unsure, open MyHome.ie, run a search, copy the URL and paste it into Start URLs.

**Can I use filters such as price range or number of bedrooms?**
Yes, through Start URLs. Apply the filters on MyHome.ie, copy the resulting search URL and paste it in. The scraper keeps the filters and only changes the page number.

**Why is price empty for some listings?**
Some advertisers show "Price on Application". The text is kept in `priceText` and `price` is null.

**Why are latitude and longitude sometimes empty?**
Not every listing has an accurate map position. When no usable coordinates exist, both fields are null.

**Do I need a proxy?**
Normally not. The default is no proxy. If your runs are blocked, enable Apify Proxy in the proxy setting; blocked requests are retried with backoff on a fresh session.

**Does the Actor use AI?**
No. It reads structured data from the page and does no AI enrichment.

**What happens when I enter a county that does not exist?**
The run finishes with zero items and a warning in the log.

### Is it legal to scrape MyHome.ie?

This Actor reads only public listing pages that anyone can open without logging in. It does not collect data behind a login and does not bypass any protection. Property listings are mostly facts about homes and advertiser business details, but they can include personal data, such as the name of an agent. Data protection rules such as GDPR can apply to personal data you collect, so use it for a legitimate purpose and keep it only as long as you need it. The website's terms of service may restrict automated access, so check them and your own legal position before commercial use. This is general information, not legal advice.

### Feedback

If a field is missing, a search URL is not recognised or the page layout changes, please open an issue from the Actor page on Apify with the input you used and the run link. Feedback on new fields is welcome.

# Actor input Schema

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

County or area slug, e.g. 'galway' or 'dublin-city'. Default 'dublin' returns Dublin listings for mode. Ignored when startUrls is nonempty. Unknown areas return no results; try a county slug or a search URL.

## `mode` (type: `string`):

Choose 'sale' for sale listings or 'rent' for monthly rentals. Default 'sale'. Used with county only when startUrls is empty; search URLs determine their own listing mode.

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

Optional array of full MyHome.ie search URLs as objects with url, e.g. \[{"url":"https://www.myhome.ie/rentals/cork/property-to-rent"}]. Replaces county and mode. URL filters are kept; pagination starts at page 1. Brochure URLs are not supported. Empty or failed searches are skipped; maxItems is shared across all URLs.

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

Minimum numeric price in EUR, e.g. 200000 for sale or 1000 for monthly rent. Inclusive. Omit for no lower bound. Listings without a numeric price are excluded when set. Applied after URL filters; narrow filters may return no matches.

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

Maximum numeric price in EUR, e.g. 450000 for sale or 2500 for monthly rent. Inclusive. Omit for no upper bound. Listings without a numeric price are excluded when set. Use an amount at least as high as minPrice.

## `minBeds` (type: `integer`):

Minimum bedrooms, e.g. 3. Omit for any bedroom count. Listings with missing bedroom counts are excluded when set. Applied to listings after any search URL filters.

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

Case-insensitive text contained in propertyType, e.g. 'apartment', 'detached' or 'bungalow'. Omit or use an empty string for all types. Substring matching means 'detached' also matches 'Semi-Detached'.

## `berRatings` (type: `array`):

Array of BER first letters, e.g. \["A","B"], matching A1/A2/A3 or B1/B2/B3 as well as A or B. Case-insensitive. Use \[] or omit for any rating. Supply letters rather than full grades such as A3; missing ratings are excluded when set.

## `includePhotos` (type: `boolean`):

Set true to include up to 50 photo URLs in photos, e.g. true. Default false returns photos as null; mainPhoto and photoCount remain available. Images are not downloaded.

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

Maximum unique matching listings across all searches combined, 1-10000, default 50; e.g. 7 returns at most 7. Counts only listings passing filters. Fewer results are returned when searches end, fail, have no matches, or reach the run's spending limit.

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

Proxy object, e.g. {"useApifyProxy":false}. Default disables proxy. To retry blocked requests through Apify Proxy, use {"useApifyProxy":true}. Enabled proxy sessions rotate on retries. Persistent blocks produce a skipped search and guidance in the status message.

## `hasViewings` (type: `boolean`):

Set true to return only listings whose public search data includes at least one open viewing. Default false includes all listings. Viewing times are returned in openViewings as published, without assuming they are still in the future. Narrow filters may return fewer than maxItems.

## Actor input object example

```json
{
  "county": "galway",
  "mode": "sale",
  "includePhotos": false,
  "maxItems": 20,
  "proxyConfiguration": {
    "useApifyProxy": false
  },
  "hasViewings": false
}
```

# Actor output Schema

## `dataset` (type: `string`):

One record per property listing.

# 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 = {
    "county": "galway",
    "mode": "sale",
    "maxItems": 20,
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("axiomworks/myhome-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 = {
    "county": "galway",
    "mode": "sale",
    "maxItems": 20,
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("axiomworks/myhome-property-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 '{
  "county": "galway",
  "mode": "sale",
  "maxItems": 20,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call axiomworks/myhome-property-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,axiomworks/myhome-property-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/4bcMSH0ky9FWLdsCb/builds/0rJVZtmYbCMjG9Bpa/openapi.json