How to Bulk Export UK Property Data: Python & Node.js Guide

{
  "postcode_prefix": "SW1",
  "min_price": 400000,
  "max_price": 1000000,
  "bedrooms": 3,
  "property_type": "flat",
  "limit": 500,
  "format": "csv",
  "fields": [
    "address",
    "postcode",
    "uprn",
    "price",
    "bedrooms",
    "property_type",
    "status",
    "dom",
    "listed_date",
    "lat",
    "lng"
  ]
}

import requests
import csv
import io
import time

API_KEY = "hd_live_your_key_here"
BASE_URL = "https://homedata.co.uk/api/v1"

def bulk_export(filters: dict, output_file: str) -> int:
    """
    Export UK property listings matching filters to a CSV file.
    Handles pagination automatically by batching into 500-row chunks.

    Returns total rows written.
    """
    headers = {
        "X-API-Key": API_KEY,
        "Content-Type": "application/json",
        "Accept": "text/csv",
    }

    offset = 0
    batch_size = 500
    total_rows = 0
    first_batch = True

    with open(output_file, "w", newline="", encoding="utf-8") as f:
        writer = None

        while True:
            payload = {
                **filters,
                "limit": batch_size,
                "offset": offset,
                "format": "json",  # use JSON for easy pagination
            }

            resp = requests.post(
                f"{BASE_URL}/listings/export",
                json=payload,
                headers={**headers, "Accept": "application/json"},
                timeout=30,
            )
            resp.raise_for_status()
            data = resp.json()

            rows = data.get("listings", [])
            if not rows:
                break  # no more results

            if first_batch:
                # Write CSV header from first row's keys
                writer = csv.DictWriter(f, fieldnames=rows[0].keys())
                writer.writeheader()
                first_batch = False

            writer.writerows(rows)
            total_rows += len(rows)
            offset += len(rows)

            print(f"  Fetched {total_rows} rows so far...")

            # Respect rate limits — 0.5s between batches on Growth tier
            if len(rows) == batch_size:
                time.sleep(0.5)
            else:
                break  # last batch (fewer than batch_size = no more pages)

    return total_rows


if __name__ == "__main__":
    filters = {
        "postcode_prefix": "SW1",
        "min_price": 400_000,
        "max_price": 1_000_000,
        "bedrooms": 3,
        "property_type": "flat",
        "fields": [
            "address", "postcode", "uprn", "price",
            "bedrooms", "property_type", "status",
            "dom", "listed_date", "lat", "lng",
            "agent", "has_address_match",
        ],
    }

    print("Starting bulk export...")
    n = bulk_export(filters, "sw1_3bed_flats.csv")
    print(f"Done. {n} properties exported to sw1_3bed_flats.csv")

import fs from 'fs';
import { stringify } from 'csv-stringify/sync';

const API_KEY = 'hd_live_your_key_here';
const BASE_URL = 'https://homedata.co.uk/api/v1';

interface ExportFilters {
  postcodePrefix?: string;
  minPrice?: number;
  maxPrice?: number;
  bedrooms?: number;
  propertyType?: string;
  fields?: string[];
}

interface Listing {
  address: string;
  postcode: string;
  uprn?: string;
  price?: number;
  bedrooms?: number;
  status?: string;
  dom?: number;
  listed_date?: string;
  lat?: number;
  lng?: number;
}

async function bulkExport(
  filters: ExportFilters,
  outputPath: string
): Promise {
  const batchSize = 500;
  let offset = 0;
  let totalRows = 0;
  let allListings: Listing[] = [];

  while (true) {
    const response = await fetch(`${BASE_URL}/listings/export`, {
      method: 'POST',
      headers: {
        'X-API-Key': API_KEY,
        'Content-Type': 'application/json',
        'Accept': 'application/json',
      },
      body: JSON.stringify({
        postcode_prefix: filters.postcodePrefix,
        min_price: filters.minPrice,
        max_price: filters.maxPrice,
        bedrooms: filters.bedrooms,
        property_type: filters.propertyType,
        fields: filters.fields,
        limit: batchSize,
        offset,
        format: 'json',
      }),
    });

    if (!response.ok) {
      throw new Error(`API error ${response.status}: ${await response.text()}`);
    }

    const data = await response.json();
    const listings: Listing[] = data.listings ?? [];

    if (listings.length === 0) break;

    allListings = allListings.concat(listings);
    offset += listings.length;
    totalRows += listings.length;

    console.log(`  Fetched ${totalRows} rows...`);

    if (listings.length < batchSize) break; // last page
    await new Promise(r => setTimeout(r, 500)); // rate limit
  }

  // Write to CSV
  const csv = stringify(allListings, { header: true });
  fs.writeFileSync(outputPath, csv, 'utf-8');

  return totalRows;
}

// Run
bulkExport(
  {
    postcodePrefix: 'M1',
    minPrice: 100_000,
    maxPrice: 500_000,
    bedrooms: 2,
    fields: ['address', 'postcode', 'uprn', 'price', 'bedrooms', 'dom', 'lat', 'lng'],
  },
  'manchester_2bed.csv'
).then(n => console.log(`Exported ${n} properties.`));

import requests

API_KEY = "hd_live_your_key_here"

def find_long_dom_properties(postcode_prefix: str, min_dom: int = 90):
    """
    Find properties that have been on the market for 90+ days.
    High DOM = motivated seller, more likely to accept below asking.
    """
    resp = requests.post(
        "https://homedata.co.uk/api/v1/listings/export",
        headers={"X-API-Key": API_KEY},
        json={
            "postcode_prefix": postcode_prefix,
            "limit": 1000,
            "format": "json",
            "fields": ["address", "postcode", "price", "bedrooms",
                       "property_type", "dom", "listed_date",
                       "lat", "lng", "agent"],
        },
        timeout=30,
    )
    resp.raise_for_status()

    listings = resp.json()["listings"]
    long_dom = [p for p in listings if (p.get("dom") or 0) >= min_dom]
    long_dom.sort(key=lambda x: x.get("dom", 0), reverse=True)

    print(f"Found {len(long_dom)} properties in {postcode_prefix} on market {min_dom}+ days:")
    for p in long_dom[:10]:
        print(f"  {p['address']} — £{p['price']:,} — {p['dom']} days on market")

    return long_dom

# Example: find motivated sellers in Manchester M1
results = find_long_dom_properties("M1", min_dom=90)

import requests
from statistics import median

API_KEY = "hd_live_your_key_here"
BASE = "https://homedata.co.uk/api/v1"

def estimate_yield(postcode_prefix: str, bedrooms: int = 2) -> dict:
    """Estimate gross rental yield for a postcode by comparing sale vs let prices."""

    common_filters = {
        "postcode_prefix": postcode_prefix,
        "bedrooms": bedrooms,
        "limit": 500,
        "format": "json",
        "fields": ["price", "transaction_type"],
    }

    # Sale prices
    sales = requests.post(f"{BASE}/listings/export",
        headers={"X-API-Key": API_KEY},
        json={**common_filters, "transaction_type": "sale"},
        timeout=30).json().get("listings", [])

    # Rental prices
    lets = requests.post(f"{BASE}/listings/export",
        headers={"X-API-Key": API_KEY},
        json={**common_filters, "transaction_type": "let"},
        timeout=30).json().get("listings", [])

    if not sales or not lets:
        return {"error": "insufficient data"}

    median_sale = median(p["price"] for p in sales if p.get("price"))
    median_rent = median(p["price"] for p in lets if p.get("price"))

    # Convert monthly rent to annual; calculate gross yield
    annual_rent = median_rent * 12
    gross_yield = (annual_rent / median_sale) * 100

    return {
        "postcode": postcode_prefix,
        "bedrooms": bedrooms,
        "median_sale_price": round(median_sale),
        "median_monthly_rent": round(median_rent),
        "gross_yield_pct": round(gross_yield, 2),
        "sample_sales": len(sales),
        "sample_lets": len(lets),
    }

# Screen multiple postcodes
for pc in ["LS1", "LS2", "LS6", "LS7", "LS8"]:
    result = estimate_yield(pc, bedrooms=2)
    print(f"{pc}: {result.get('gross_yield_pct', 'N/A')}% gross yield "
          f"(median sale £{result.get('median_sale_price', 0):,})")

import requests
import csv
import json
import time
from pathlib import Path

API_KEY = "hd_live_your_key_here"

def resumable_export(filters: dict, output_csv: str, checkpoint_file: str):
    """
    Large export with checkpoint/resume.
    Saves offset after each batch — safe to kill and restart.
    """
    # Load checkpoint if exists
    offset = 0
    if Path(checkpoint_file).exists():
        with open(checkpoint_file) as f:
            offset = json.load(f).get("offset", 0)
        print(f"Resuming from offset {offset}...")

    mode = "a" if offset > 0 else "w"
    total = offset

    with open(output_csv, mode, newline="", encoding="utf-8") as f:
        writer = None
        write_header = (offset == 0)

        while True:
            resp = requests.post(
                "https://homedata.co.uk/api/v1/listings/export",
                headers={"X-API-Key": API_KEY, "Accept": "application/json"},
                json={**filters, "limit": 5000, "offset": offset, "format": "json"},
                timeout=60,
            )
            resp.raise_for_status()
            data = resp.json()
            rows = data.get("listings", [])

            if not rows:
                break

            if write_header:
                writer = csv.DictWriter(f, fieldnames=rows[0].keys())
                writer.writeheader()
                write_header = False
            elif writer is None:
                writer = csv.DictWriter(f, fieldnames=rows[0].keys())

            writer.writerows(rows)
            total += len(rows)
            offset += len(rows)

            # Save checkpoint
            with open(checkpoint_file, "w") as cp:
                json.dump({"offset": offset, "total": total}, cp)

            print(f"  {total} rows exported...")

            if len(rows) < 5000:
                break
            time.sleep(0.2)

    # Clean up checkpoint on successful completion
    Path(checkpoint_file).unlink(missing_ok=True)
    print(f"Complete: {total} rows → {output_csv}")
    return total


# Export all 2-bed properties in London (E, EC, N, NW, SE, SW, W, WC postcodes)
LONDON_OUTCODES = ["E1", "E2", "N1", "N4", "SE1", "SW1", "W1", "EC1", "WC1"]

for outcode in LONDON_OUTCODES:
    print(f"\nExporting {outcode}...")
    resumable_export(
        filters={
            "postcode_prefix": outcode,
            "bedrooms": 2,
            "transaction_type": "sale",
            "fields": ["address", "postcode", "uprn", "price", "dom",
                       "listed_date", "lat", "lng", "has_address_match"],
        },
        output_csv=f"london_{outcode.lower()}_2bed.csv",
        checkpoint_file=f".checkpoint_{outcode.lower()}.json",
    )

{
  "count": 1,
  "total_calls_used": 1,
  "listings": [
    {
      "listing_id": "rm_123456789",
      "address": "14 Acacia Avenue",
      "postcode": "SW1A 1AA",
      "uprn": "100023336956",
      "price": 650000,
      "original_price": 695000,
      "bedrooms": 3,
      "bathrooms": 2,
      "property_type": "semi-detached",
      "transaction_type": "sale",
      "status": "For Sale",
      "dom": 47,
      "listed_date": "2026-02-16",
      "agent": "Knight Frank",
      "agent_branch": "Chelsea",
      "reductions": 1,
      "lat": 51.5012,
      "lng": -0.1419,
      "construction_age": "1950s",
      "has_address_match": true
    }
  ]
}