Developer guide

How to scrape public property listing pages with UnblockingAPI

Public property pages often rely on JavaScript, location-specific content and dynamically loaded listing details. This guide shows how to fetch the rendered page through UnblockingAPI and parse the returned HTML in your own application.

Practical guide 8 min read

What you can build

UnblockingAPI handles the fetching layer — your application decides what to do with the data. For more context, see the real estate use case overview. Common workflows include:

  • — New listing alerts. Poll a search-results page and notify your application when new inventory appears.
  • — Price change monitoring. Track asking prices over time and flag changes.
  • — Availability tracking. Detect when listings are marked as sold, pending or withdrawn.
  • — Market research. Aggregate publicly available data points for pricing signals and supply trends.
  • — Property comparison. Fetch multiple listing pages and compare features side by side.
  • — Agency page monitoring. Track inventory counts and new additions on broker or agency listing pages.

What UnblockingAPI returns

UnblockingAPI fetches the public page and returns:

  • • Rendered HTML (with optional JavaScript rendering)
  • • Target HTTP status code
  • • Request status (succeeded / failed)
  • • Response time in milliseconds
  • • Selected location
  • • Rendering settings
  • • Response metadata
UnblockingAPI handles the fetching layer. Your application handles parsing and storage.

It does not automatically extract structured fields such as price, bedrooms or address. The returned HTML is the raw page content — your parser decides which fields to extract. See the full response format reference for all available fields.

Send your first property-page request

Pass a public property listing URL with rendering and location controls:

curl \
  -H "X-Api-Key: YOUR_API_KEY" \
  "https://api.unblockingapi.com/unblock?url=https://example.com/property/listing&render=true&location=es"
urlstringrequired

The public URL you want to fetch. URL-encode if needed.

renderbooleandefault: false

Set to true to execute JavaScript and return the fully rendered HTML. Recommended for property listing pages that load content dynamically.

locationstring

Two-letter country code. Routes the request through the specified country for region-specific content and pricing.

Example response

A successful response contains the rendered HTML, timing data and request metadata:

{
  "job_id": "a1b2c3",
  "url": "https://example.com/property/listing",
  "status": "succeeded",
  "http_response_code": 200,
  "response_time_ms": 812,
  "render": true,
  "location": "es",
  "response_format": "html",
  "response": "<!doctype html><html>..."
}

The response field contains the full HTML string. Your application loads and parses it to extract listing details.

Parse listing fields from the HTML

The returned HTML is a standard web page. Common fields you can parse include:

• Listing title
• Price and currency
• Location text
• Property type
• Bedrooms and bathrooms
• Size
• Features and amenities
• Description
• Image URLs
• Agency or broker details
• Availability or listing status

Here is a minimal example using Node.js and Cheerio. CSS selectors vary by target page — adjust them for your specific source.

import * as cheerio from "cheerio";

const res = await fetch(
  "https://api.unblockingapi.com/unblock?" +
    new URLSearchParams({
      url: "https://example.com/property/listing",
      render: "true",
      location: "es",
    }),
  { headers: { "X-Api-Key": "YOUR_API_KEY" } }
);

const data = await res.json();
const $ = cheerio.load(data.response);

const title = $("h1.listing-title").text().trim();
const price = $(".price").first().text().trim();
const beds  = $('[data-testid="bedrooms"]').text().trim();

console.log({ title, price, beds });

Selectors like h1.listing-title are examples only. Inspect the target page to find the correct selectors for your source.

JavaScript-rendered property pages

Many property portals load listing details through client-side JavaScript. Without rendering, the initial HTML may contain an empty shell or loading placeholders. Set render=true when:

  • • The initial HTML is an empty shell or loading skeleton
  • • Listing details are fetched by client-side API calls
  • • Content is lazy-loaded as the page scrolls
  • • Search results are rendered dynamically
  • • The page is a hydrated single-page application

If a non-rendered request returns meaningful HTML, you can skip rendering to save response time. See how it works for a deeper look at the rendering pipeline.

Country-level routing

Property portals often serve different content based on the visitor's location. Use the location parameter to route requests through a specific country when you need:

  • • Regional pricing in the local currency
  • • Market-specific listing availability
  • • Localised content and language
  • • Region-restricted search results

Results may still vary by target page — not all portals differentiate content by location.

Monitoring listings over time

To track changes, build a simple pipeline that fetches, parses, compares and alerts:

Scheduler
↓
UnblockingAPI → rendered property page
↓
Parser → extract fields
↓
Database → store with stable identifier
↓
Compare → detect changes
↓
Alert → price change, new listing, sold
  1. Fetch the listing or search-results page through UnblockingAPI.
  2. Parse the fields you care about (price, status, inventory count).
  3. Store a stable identifier and the current values.
  4. On the next run, compare with the previous snapshot.
  5. Emit an alert when a meaningful change occurs.

Handling failures and difficult targets

Not every request will succeed on the first attempt. A few practical steps:

  • • Inspect status and http_response_code to distinguish fetch failures from target errors.
  • • Enable rendering when the non-rendered HTML is empty or incomplete.
  • • Choose the appropriate location for region-specific pages.
  • • Avoid excessive request bursts — space requests and use reasonable intervals.
  • • Use stable identifiers (listing IDs, canonical URLs) so your pipeline is resilient to page layout changes.
  • • Log parsing failures separately from fetch failures — a successful fetch with unexpected HTML is a parser issue, not an API issue.

Site-specific success depends on the target page, region, rendering mode and anti-bot behavior. If you need hands-on help tuning requests for a specific target, our developers can help.

Responsible use

Use UnblockingAPI for public web pages and legitimate data workflows. Customers are responsible for complying with applicable laws, third-party terms and the Acceptable Use Policy.

Frequently asked questions

Yes. Set render=true and UnblockingAPI will execute JavaScript in a real browser and return the fully rendered HTML.

No. UnblockingAPI returns the rendered HTML, HTTP status, timing and metadata. Your application parses the HTML to extract fields like price, bedrooms or location.

Yes. Use the location parameter with a two-letter country code to route the request through a specific country for region-specific content and pricing.

Yes. Fetch the same listing URL on a schedule, parse the fields you care about, and compare with the previous snapshot to detect changes.

UnblockingAPI still returns the page HTML. If the page structure changes, your CSS selectors may need updating. Log parsing failures separately from fetch failures to catch this quickly.

UnblockingAPI is designed for public web pages. It does not handle login flows or authenticated sessions.

Start with a public property URL.

Test the fetching layer before building the parser. Start with 1,000 successful requests and no credit card. See pricing for plan details.

Start free View API docs

One successful request is one request. No credit multipliers.

Rasmus Kjellberg

Rasmus Kjellberg

Founder & Developer at UnblockingAPI

Technically reviewed 18 July 2026