How to Scrape Bilasolur.is Car Listings (Iceland) to JSON/CSV

#webscraping #python #data #automation

Quick answer: Bilasolur.is publishes no public API, so structured used-car data requires scraping the public listings. The Bilasolur Iceland Car Scraper on Apify handles browser fingerprint rotation, residential proxy session rotation, and retry logic for you, delivering clean typed rows at $2.05 per 1,000 results ($0.05 actor-start + $0.002 per result).

Iceland's used-car market is small by European standards — around 350,000 registered vehicles for a population of 370,000 — but the price spreads are striking. Icelandic króna (ISK) pricing, high import duties, and a relatively isolated market mean that the same 2019 Toyota RAV4 can carry a very different tag on Bilasolur.is than on a mainland European equivalent. If you do automotive market research, run cross-border arbitrage, or build depreciation models, Iceland is a market worth having in your dataset.

Bilasolur.is is the dominant used-car marketplace in Iceland. It ships no developer API and no data export. Getting a structured view of its listings means scraping the public website — which requires the right headers, a residential exit IP, and session management to handle the retries that come with any real-world scraping target.

This guide shows how to pull Bilasolur.is data programmatically using the Bilasolur Iceland Car Scraper, a managed Apify Actor that handles the infrastructure.

Does Bilasolur.is Have an API? 🔎

No. Bilasolur.is operates as a traditional HTML marketplace with no documented public API. The site's search results live at SearchResults.aspx endpoints with query parameters for make, model, price band, and registration year — but all of that is HTML, not JSON, and it's served in a way that requires a browser-like client to retrieve reliably.

The listing data itself — price in ISK, mileage, engine spec, colour, registration date — is split across the search result card and the individual listing detail page. Getting the full spec requires fetching both.

What Data You Can Extract

The Actor returns one row per listing. Fields from the listing card are always present; fields marked "enrichment-only" require enrichDetails: true, which fetches each listing's detail page.

Field	Description
`listing_id`	Bilasolur `sid` query parameter
`listing_url`	Absolute URL to the detail page
`title`	Make + model + variant
`make`	Manufacturer (e.g. Volvo, Toyota)
`model`	Model name (e.g. XC90)
`year`	Manufacture/registration year
`price`	Integer price in ISK
`currency`	Always `ISK`
`mileage_km`	Odometer in kilometres
`fuel_type`	Bensín / Dísel / Rafmagn / ... (Icelandic labels)
`transmission`	Derived from title: Sjálfskiptur (auto) / Beinskiptur (manual)
`engine_power_hp`	Horsepower (hestöfl) — enrichment-only
`engine_size_cc`	Displacement in cc — enrichment-only
`color`	Exterior colour (Litur) — enrichment-only
`first_registration`	First-registration date (M/YYYY)
`region`	Drivetrain: Framhjóladrif / Fjórhjóladrif / Afturhjóladrif
`seller_name`	Seller display name — enrichment-only
`photo_urls`	List of photo URLs
`description`	Seller free-text description — enrichment-only
`posted_date`	Date added to sales register (Skráð á söluskrá)
`scraped_at`	ISO-8601 UTC timestamp of scrape

A note on language: Bilasolur is an Icelandic-language site. Core spec values — fuel type, drivetrain — are in Icelandic. The Actor maps them to standard English column names (fuel_type, mileage_km, engine_power_hp) so your schema stays consistent across markets, but the values themselves are preserved as-is. Bensín stays Bensín; nothing is silently lost in translation.

A Realistic Output Row

Below is a sample row using the exact field names from the Actor's Pydantic ResultRow model:

{
  "listing_id": "1070046",
  "listing_url": "https://bilasolur.is/CarDetails.aspx?bid=94&cid=524786&sid=1070046",
  "title": "Volvo XC90",
  "make": "Volvo",
  "model": "XC90",
  "year": 2021,
  "price": 8690000,
  "currency": "ISK",
  "mileage_km": 82737,
  "fuel_type": "Dísel",
  "transmission": null,
  "engine_power_hp": 235,
  "engine_size_cc": 1969,
  "body_type": null,
  "color": "Dökkblár",
  "first_registration": "2/2021",
  "location": null,
  "region": "Fjórhjóladrif",
  "seller_type": null,
  "seller_name": null,
  "photo_urls": ["https://bilasolur.is/CarImage.aspx?s=94&c=524786&p=1&w=400"],
  "description": null,
  "posted_date": "1.6.2026",
  "scraped_at": "2026-06-02T10:00:00+00:00"
}

That 8,690,000 ISK price is roughly €57,000 at mid-2026 rates — an accurate reflection of Iceland's import-duty-inflated used-car prices. Storing the raw ISK value lets you apply your own FX conversion rather than baking in a rate that goes stale.

How We Handle the Blocks

Bilasolur is not a high-security target by the standards of a DataDome-protected site, but it is a real web server that will block naive clients. Here is what the Actor does to stay reliable:

Browser fingerprint rotation. We use curl-cffi to impersonate real Chrome, Firefox, and Safari TLS handshakes. The server sees a real browser client, not a Python script.
Residential proxy rotation via Apify Proxy. We rotate residential exit IPs and fresh session IDs on every block signal. Datacenter IPs are the fastest way to trigger blocks on smaller marketplace servers.
Exponential backoff with Retry-After. We retry on 408, 429, and 5xx responses — up to five attempts per page, doubling the wait interval each time.
Rate-limit-aware pacing. When the target slows us down, we match its pace rather than pushing until blocked.
Loud failure, never silent. A hard block exits non-zero with a descriptive status message. You never get a green run with an empty dataset.

Running It with Python 🐍

from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")

run = client.actor("DevilScrapes/bilasolur-iceland-cars").call(
    run_input={
        "searchUrl": "https://bilasolur.is/SearchResults.aspx?id=1&makeid=42",
        "maxResults": 100,
        "enrichDetails": True,
        "proxyConfiguration": {
            "useApifyProxy": True,
            "apifyProxyGroups": ["RESIDENTIAL"]
        }
    }
)

items = list(client.dataset(run["defaultDatasetId"]).iterate_items())
print(f"Scraped {len(items)} listings")
for item in items[:3]:
    print(item["make"], item["model"], item["year"], item["price"], "ISK")

The searchUrl parameter is optional. Leave it empty to scrape the default used-cars feed, or visit bilasolur.is, apply your filters (make, model, price band, year range), and paste the resulting SearchResults.aspx URL. The Actor paginates from there until it hits maxResults or the last page.

Use Cases

ISK price tracking. Build a price series for specific makes and models in the Icelandic market. Iceland's small inventory means prices move faster than on large mainland platforms — daily runs surface trends quickly.

Cross-border import arbitrage. Compare ISK asking prices against Norwegian, Danish, or German equivalents. Iceland imposes significant import duties on vehicles, which creates predictable price wedges that importers exploit. The Actor gives you the ISK side of that equation as structured data.

Depreciation modelling. Plot price against mileage_km and year for a given make and model. With enrichDetails on, you also get engine_power_hp for segmenting by powertrain spec.

Dealer inventory monitoring. Filter by seller_name or seller_type to track a specific dealer's stock. Diff successive runs to catch new arrivals and price changes.

Fresh-listing alerts. The posted_date field carries the date the listing was added to the sales register. Feed it into a filter to surface listings posted in the last 24 hours.

FAQ ❓

How much does it cost?

Pay-Per-Event pricing: $0.05 for actor-start (one-off per run) plus $0.002 per result row. 1,000 results costs $2.05 total. Every new Apify account gets $5 of free credit — no credit card required to try.

The values are in Icelandic — can I get English?

The Actor maps all field names to standard English (fuel_type, mileage_km, engine_power_hp, etc.). The values from the Icelandic site — Bensín, Fjórhjóladrif, Dökkblár — are preserved as-is. This is intentional: silent translation introduces errors for uncommon values. You can translate them in post-processing with a lookup table.

Is scraping Bilasolur.is legal?

Bilasolur's terms restrict automated access. You are responsible for ensuring your use complies with applicable law and the site's terms. The Actor scrapes only public listing data visible to any unauthenticated browser. We do not bypass authentication or access any private user data.

What does detail enrichment add, and is it worth it?

With enrichDetails: true, the Actor fetches each listing's detail page for engine power (hestöfl), engine displacement, exterior colour, and the registration date. It roughly doubles the request count and run time. If you only need make, model, year, price, mileage, fuel type, drivetrain, and photos — which all come from the listing card — set enrichDetails: false to halve your costs.