# Ireland Residential Property Price Register - Per Sale (`nexgensignal/ie-property-price-register-records`) Actor

Ireland Residential Property Price Register (PSRA), all sales 2010 to date, as clean per-record data - date, address, county, Eircode, price and not-full-market/VAT-exclusive flags. No personal data. PSRA re-use. $0.05 per record.

- **URL**: https://apify.com/nexgensignal/ie-property-price-register-records.md
- **Developed by:** [NexGen Signal](https://apify.com/nexgensignal) (community)
- **Categories:** Business, Developer tools, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $33.50 / 1,000 property sale records

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?

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

## How to integrate an Actor?

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

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

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

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

# README

## Ireland Residential Property Price Register - Per Sale

Every residential property sale on Ireland's **Residential Property Price Register** (2010 to date) as one
clean, flat record - date, address, county, Eircode, price, and the not-full-market and VAT-exclusive flags,
plus the property description and size band. **No buyer or seller name is in the source.**

### What one record represents

The source is the **Property Services Regulatory Authority (PSRA)** Residential Property Price Register, the
official Irish register of residential sales, downloaded as the authority's own all-years ZIP. Each record is
**one sale**: date of sale, property address, county, Eircode (where present), the price in euro, a flag for
not-full-market price, a flag for VAT-exclusive, the property description (new or second-hand dwelling) and the
property-size band.

### Coverage and volume

The register holds **803,904** sales from 2010 to date - measured at build time from the downloaded file.

**Sol's Wave-4 index put this door at 803,904 EXACT; measured live at build time the all-years file holds
exactly 803,904 sales - matching the index.**

The Actor downloads the ZIP, reads the single CSV inside it (correctly handling quoted, comma-containing
addresses), and delivers each sale, stopping as soon as your **Maximum records** cap is met.

### Licence and attribution

The register is re-usable under the PSRA's terms. The full notice travels on every record:

> Property Services Regulatory Authority (PSRA), Ireland. The data may be freely reproduced and re-used in any format, including for commercial purposes, provided the PSRA is acknowledged as the source.

### Person-data policy

The Residential Property Price Register **carries no buyer or seller name** - it records the property, not the
parties. The address is a property address, not a person. A per-record assertion rejects any buyer/seller/person
field (verified with a planted-field test). No natural-person data is processed.

### Interpretation caveat

One record per residential property sale on the Irish Residential Property Price Register (2010 to date): date of sale, address, county, Eircode, price (EUR), and flags for not-full-market price and VAT-exclusive, plus the property description and size band. No buyer or seller name is in the source.

Values are reproduced verbatim from the register; the Actor never rewrites a field. `price_eur` is delivered as
a real number and the two flags as real booleans. The register serves **no robots.txt (HTTP 404)**; a 404
means there are no crawl rules, and the PSRA licence expressly grants free re-use - the runtime gate records
the 404 in the receipt and proceeds on the licence.

### Provenance and compliance

Every run reads the door host's `robots.txt` at runtime; the gate result (URL, status, byte length, SHA-256
of the policy) is written to the run's `RUN_RECEIPT`, and the data path is confirmed permitted before any
fetch. The endpoint is keyless. The Actor never bypasses a block or fetches through a mirror.

### Data quality and freshness

Boolean columns are delivered as real booleans and numeric columns as real numbers. Delivery is keyed on a
stable composite id, so the dataset is safe to diff, deduplicate or upsert. Every run re-reads the live door,
so the data is as fresh as the source publishes, and each record's `observed_at` stamp dates the snapshot. The
run's `RUN_RECEIPT` records the source URL and how many records were delivered and charged, and confirms
`charge_equals_delivered`.

### Billing and delivery

Pricing is per record: you are billed only for records the Actor actually delivers, at a flat rate, with the
charge raised after each record is pushed (push-then-charge), so a failed or empty run costs nothing. There is
no subscription and no minimum. The **Maximum records** cap bounds every run, so you control the spend
precisely - set it low to sample the shape of the data cheaply, then raise it once you have confirmed the cell
fits your use. Because delivery is incremental and keyed on a stable id, re-running against the same door and
upserting on that id keeps a downstream table current without re-paying for rows you already hold; only the new
and changed records add cost. Every run's receipt reconciles delivered against charged, so the billing is
auditable against the data you received.

### Inputs

- **Maximum records** (`maxRecords`) - hard cap on sale records delivered and billed.

### Output

Records land in the Actor's default dataset and export as JSON, CSV, Excel or via the Apify API. A tabular
overview surfaces date of sale, address, county, price, and the not-full-market and VAT-exclusive flags.

### Fields in detail

The record leads with `date_of_sale`, `address`, `county`, `eircode`, `price_eur`, the booleans
`not_full_market_price` and `vat_exclusive`, `property_description` and `property_size`. The provenance block
closes every record. Because the composite key combines date, address and price, the dataset is safe to diff,
deduplicate or upsert.

### Typical uses

Property-analytics and valuation teams use this cell as the authoritative Irish residential-sales series -
803,000 sales keyed and typed, ready to chart price trends by county, filter by property type, or feed a
valuation model. Because the price is a real number and the county and description are clean fields, a single
group-by gives median price by county and year without cleaning. A scheduled run keeps a downstream table
current as the PSRA republishes.

### Scaling and limits

Set **Maximum records** low to sample or high to pull the whole 2010-to-date register. The Actor streams the
CSV inside the ZIP and delivers incrementally, so memory stays flat and you are billed only for what is
delivered. The register is republished continuously, so a scheduled run keeps a downstream table current; each
record's `observed_at` stamp dates the snapshot.

### How the all-years file is delivered

The PSRA publishes the register both as per-year CSVs and as a single all-years ZIP; this cell downloads the
all-years ZIP and reads the one CSV inside it, so a single run captures the entire 2010-to-date history rather
than one year at a time. Irish addresses contain commas, so the file is a properly quoted CSV; the Actor parses
it with a real CSV reader rather than a naive split, which keeps a comma inside an address from spilling into
the next column. The file is Windows-encoded (the price header carries a euro sign), and the Actor decodes it
accordingly so that field names and values come through intact.

### Reading the flags and the price

`price_eur` is the sale price in euro as a real number - the euro sign and thousands separators are stripped so
the value is ready to sum or average. `not_full_market_price` flags sales the register marks as not at full
market value (for example a transfer between related parties), and `vat_exclusive` flags prices recorded net of
VAT, typically on new dwellings; both are real booleans so you can include or exclude them from a market
analysis with a simple filter. `property_description` separates new from second-hand dwellings, and
`property_size` gives the size band where the register records one.

### Building analyses

Because the county, price and property type are clean fields, common analyses need no preparation: a group-by
on county and year gives median or mean price over time, a filter on `not_full_market_price` isolates
arms-length sales, and the property description splits new-build from resale. The composite key (date, address,
price) makes the dataset safe to diff run-to-run, so a scheduled run surfaces exactly the new sales the PSRA
added since the last pull.

### Sibling Actors

It sits beside the fleet's HK land-registry transactions cell (0% overlap - different jurisdiction and register). It shares its zip/CSV engineering with the fleet's other records Actors.

# Actor input Schema

## `maxRecords` (type: `integer`):

Maximum records delivered and billed. You are billed only for records actually delivered. Raise it to pull the full set.

## Actor input object example

```json
{
  "maxRecords": 500
}
```

# Actor output Schema

## `results` (type: `string`):

The delivered Ireland residential property sale record.

# 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 = {
    "maxRecords": 500
};

// Run the Actor and wait for it to finish
const run = await client.actor("nexgensignal/ie-property-price-register-records").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 = { "maxRecords": 500 }

# Run the Actor and wait for it to finish
run = client.actor("nexgensignal/ie-property-price-register-records").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 '{
  "maxRecords": 500
}' |
apify call nexgensignal/ie-property-price-register-records --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,nexgensignal/ie-property-price-register-records"
        }
    }
}

```

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/ndXPBwKxZALCLpRv0/builds/xURVdpXjeoogenv9h/openapi.json