How to Scrape Halooglasi Serbia Real Estate Listings in 2026

Halooglasi.com is Serbia’s number-one classifieds and property portal, and its real-estate section is the single best window into the Serbian housing market — apartments and houses in Belgrade, Novi Sad and Niš, land plots, commercial space, garages, and rooms, both for sale and rent. The data is all there on the listing cards, but the site doesn’t hand it to you in a clean API, sits behind Cloudflare, and buries the structured payload inside the HTML. This guide walks through how Halooglasi’s pages are actually built and how to extract clean, EUR-priced listing data at scale in 2026.

What’s worth extracting

For each ad on a Halooglasi results page, a consistent set of fields is available once you parse the card correctly:

• Pricing — EUR price and a computed price-per-square-meter (the metric that actually drives Serbian market analysis).
• Size — usable area in m², and plot area for houses and land.
• Rooms — room count with Serbian labels and the half-step increments the local market uses (e.g. “1.5”, “2.5” rooms).
• Location — a four-level parsed address: city → municipality → district → micro-location → street. This hierarchy is what makes neighborhood-level analysis possible.
• Advertiser — display name, profile URL, advertiser ID, and owner type (private vs agency).
• Listing tier — Premium / Top / VIP and other promotion labels.
• Media — the image gallery, with agency logos automatically filtered out so you keep only real property photos.
• Dates — posting date and other card-level attributes.

How the page is actually built

Halooglasi runs on a Sitecore / ASP.NET backend, and this is the key detail: the results page embeds an inline JSON payload in the HTML rather than serving listings purely as rendered DOM. Inside that payload is an Ads array, and each entry carries HTML-encoded card markup.

So the extraction is a two-stage parse:

1. Regex-extract the inline JSON envelope from the page source.
2. Iterate the Ads array, HTML-decode each card’s markup, and parse it with a DOM library (cheerio) to pull price, area, rooms, floor, the location chain, images and advertiser info.

When the JSON envelope is missing — older pages, edge cases — the robust approach is to fall back to parsing the rendered HTML cards directly. Having both paths is what keeps coverage near 100% instead of silently dropping pages.

Crucially, this works as direct HTTP fetches — no headless browser and no GraphQL. The inline payload means you don’t need to render JavaScript to get the data, which keeps runs fast and cheap. What you do need is residential proxy sessions and automatic retries, because Halooglasi sits behind Cloudflare and will challenge datacenter IPs.

▶ Run the Halooglasi Property Scraper — apartments, houses, land, commercial, garages and rooms by city, EUR price, m² and owner type. Returns full address chain, advertiser and image gallery per ad. Residential proxy and Cloudflare retries included.

The Cloudflare reality

Halooglasi doesn’t run a Booking-grade in-house bot stack, but it does front the site with Cloudflare. In practice that means:

• Datacenter IPs get challenged. A raw requests call from a cloud VM hits an interstitial, not a listing page.
• Residential or sticky sessions pass. Real-looking IPs with consistent session behavior sail through.
• Retries matter. Cloudflare occasionally serves a transient challenge even to good IPs; automatic retry with backoff turns a 503 into a clean fetch on the second try.

Because there’s no browser in the loop, the cost profile is much lighter than a Playwright-based scraper — you’re paying for HTTP fetches and proxy bandwidth, not for spinning up a Chromium per page.

A clean per-listing schema

{
  "listing_id": "5425398347",
  "url": "https://www.halooglasi.com/nekretnine/prodaja-stanova/...",
  "transaction": "sale",
  "property_type": "apartment",
  "price_eur": 142000,
  "area_m2": 58,
  "price_per_m2_eur": 2448,
  "rooms": "2.5",
  "floor": "4/6",
  "location": {
    "city": "Beograd",
    "municipality": "Vračar",
    "district": "Crveni Krst",
    "micro_location": "Južni bulevar",
    "street": "Maksima Gorkog"
  },
  "advertiser": {
    "name": "CityExpert",
    "profile_url": "https://www.halooglasi.com/...",
    "advertiser_id": "ag-118842",
    "owner_type": "agency"
  },
  "tier": "Premium",
  "images": ["https://img.halooglasi.com/.../1.jpg"],
  "posted_at": "2026-05-18",
  "scraped_at": "2026-05-24T11:00:00Z"
}

Schema choices worth making early:

• Always store price_per_m2_eur. It’s the comparison currency of Serbian real estate; raw price alone is hard to compare across sizes.
• Keep the full location chain, not a flattened string. Neighborhood-level analytics live or die on the municipality and micro-location split.
• Store owner_type. Filtering private sellers vs agencies is the difference between a lead list and market noise.
• Persist listing_id. Titles and prices change as ads get edited and re-promoted; the ID is the stable join key.

Typical use cases

• Serbia-wide inventory harvesting — pull every listing by city, municipality, district or micro-location, for sale or rent.
• Price analytics — neighborhood-level price-per-m² comparisons and trend tracking over time.
• Advertiser and agency profiling — monitor which agencies dominate which districts and how active each owner type is.
• Image-gallery collection — grab cover photos and full galleries (with agency logos already filtered) for portals or CV/ML use.
• Inventory slicing for research — cut by transaction type, property type, EUR range, area, and room count.
• Deep historical sweeps — slice queries by price and area bands to traverse result sets larger than the portal’s own pagination will surface in one pass.

Cost math

Pricing is pay-per-event with a tiny per-run start fee and no per-result charge, so the marginal cost of an extra listing is essentially zero — you pay for compute and proxy bandwidth. Because extraction is HTTP-only (no Chromium), a full Belgrade apartments-for-sale sweep of several thousand ads completes fast and cheap. A daily refresh of a city slice is pennies.

Against a DIY build you avoid: reverse-engineering the Sitecore inline-JSON envelope, maintaining the HTML-card fallback when the envelope is absent, the pagination loop-detection logic, and the residential-proxy + Cloudflare-retry plumbing.

Common pitfalls

• Don’t render JavaScript. The data is in the inline JSON; spinning up a browser is wasted money and slower.
• Pagination can loop. Halooglasi’s paging will sometimes re-serve the same page near the end of a result set — dedup by listing_id and detect repeated pages or you’ll inflate counts.
• Agency logos pollute galleries. Raw image lists include the advertiser’s logo; filter it or your “property photos” will be branding.
• Room counts use half-steps and Serbian labels. A “dvoiposoban” (2.5-room) flat won’t parse as an integer — handle the local labeling.
• Cloudflare from datacenter IPs. Without residential sessions you’ll scrape challenge pages, not listings, and won’t always get an error to tell you.
• EUR is the listing currency, but verify. Serbian portals quote in EUR by convention; still store the currency explicitly rather than assuming.

Wrapping up

Halooglasi is friendlier than a hotel OTA — no JavaScript rendering needed thanks to the inline JSON payload — but it still demands real proxy handling and a careful two-stage parse with a fallback path. For a one-off neighborhood snapshot you could hand-roll it. For a refreshed, EUR-normalized feed across all of Serbia with clean address hierarchies and filtered galleries, use a scraper that already solved the envelope parsing and Cloudflare retries.

▶ Open the Halooglasi Serbia Real Estate Scraper on Apify — structured EUR-priced listings with four-level address and advertiser data. Pay-per-event, start on Apify’s free credit.