DEV Community: Devil Scrapes

How to Scrape Mobile.bg Car Listings (Bulgaria) to JSON/CSV

Devil Scrapes — Sat, 13 Jun 2026 10:33:11 +0000

Quick answer: Use the Mobile.bg Bulgaria Car Scraper on Apify. Paste a filtered Mobile.bg search URL (or leave it empty for the default cars-and-jeeps feed), set maxResults, and the Actor returns structured rows — price in EUR and BGN, make, model, year, mileage, fuel, gearbox, engine power, body type, colour, and seller — as a JSON or CSV dataset. No API key needed.

Why scrape Mobile.bg?

Mobile.bg is Bulgaria's largest used-car marketplace and the primary venue for Bulgarian used-car transactions. It carries tens of thousands of listings from private sellers and dealers, priced in both EUR and BGN (Bulgarian lev). Bulgaria is adopting the euro, so the site exposes dual-currency pricing natively — the price field is in EUR and price_bgn carries the lev equivalent.

Mobile.bg publishes no public API. The site is served in Windows-1251 encoding — the Cyrillic character set that predates UTF-8 adoption in Eastern Europe. Getting clean, correctly decoded data out of it requires handling that encoding correctly, matching the browser's TLS fingerprint so the site does not block automated requests, and mapping Bulgarian-language spec labels to standard field names. The Actor handles all of that.

What fields does the scraper return? 🔥

Every row maps to the ResultRow Pydantic model in the Actor source. Here is a realistic sample:

{
  "listing_id": "11772628462288076",
  "listing_url": "https://www.mobile.bg/obiava-11772628462288076-audi-a3-s-line-s3",
  "title": "Audi A3 S-line S3",
  "make": "Audi",
  "model": "A3",
  "year": 2010,
  "price": 7600,
  "currency": "EUR",
  "price_bgn": 14864,
  "mileage_km": 255000,
  "fuel_type": "Дизелов",
  "transmission": "Ръчна",
  "engine_power_hp": 140,
  "engine_size_cc": 2000,
  "body_type": "Хечбек",
  "color": "Бял",
  "first_registration": "октомври 2010",
  "location": "гр. Варна",
  "region": null,
  "seller_type": "private",
  "seller_name": null,
  "photo_urls": [
    "//mobistatic1.focus.bg/mobile/photosorg/076/1/11772628462288076_t4.webp"
  ],
  "description": "Audi A3 2.0 TDI ...",
  "posted_date": "НОВА ОБЯВА",
  "scraped_at": "2026-06-02T10:00:00+00:00"
}

The complete field set is: listing_id, listing_url, title, make, model, year, price, currency (always EUR), price_bgn, mileage_km, fuel_type, transmission, engine_power_hp, engine_size_cc, body_type, color, first_registration, location, region, seller_type, seller_name, photo_urls, description, posted_date, and scraped_at. Fields tagged enrichment-only (location, region, seller_type, seller_name) are populated when enrichDetails is true.

A note on Cyrillic values: fuel type, gearbox, body type, and colour are returned in their original Bulgarian text (e.g. Дизелов, Автоматична, Хечбек). The column names are standard English, so your pipeline can process them without knowing Bulgarian — just map the Cyrillic values if you need English labels in your output.

What does it cost to scrape Mobile.bg listings? 💰

Pricing is Pay-Per-Event.

Event	Price
`actor-start` (one-off per run)	$0.05
`result-row` (per car listing)	$0.002

1,000 results in a single run costs $2.05 ($0.05 start + 1,000 × $0.002). Every new Apify account gets $5 of free credit — enough for two full runs of 1,000 listings before you spend anything. No credit card required to start.

How does the anti-blocking work?

Mobile.bg is a Windows-1251 encoded site with anti-bot protections on its listing pages. We handle the blocks:

We rotate Chrome, Firefox, and Safari TLS fingerprints using curl-cffi browser impersonation — the site sees a real-browser handshake, not a Python HTTP client.
We decode the Windows-1251 Cyrillic encoding correctly on every response before parsing, so you never get garbled text in fuel_type, body_type, or description.
We rotate residential proxy sessions through Apify Proxy on every block — a fresh session ID and a fresh Bulgarian exit IP, automatically.
We retry on 408, 429, and 5xx responses with exponential backoff (starting at two seconds, capping at thirty, up to five attempts per page), honouring Retry-After headers.
Partial runs surface with a clear status message; we never return empty data with a green status.

How to run the scraper from Python

Install apify-client and call the Actor:

from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_API_TOKEN")

run_input = {
    "searchUrl": "https://www.mobile.bg/obiavi/avtomobili-dzhipove/bmw",
    "maxResults": 150,
    "enrichDetails": True,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

run = client.actor("DevilScrapes/mobile-bg-bulgaria-cars").call(run_input=run_input)

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(
        item["make"], item["model"], item["year"],
        item["price"], "EUR", "/", item["price_bgn"], "BGN",
        item["mileage_km"], "km"
    )

To target a specific make or model, apply filters on mobile.bg and paste the resulting URL into searchUrl. Leave searchUrl empty to scrape the default cars-and-jeeps feed. Turn enrichDetails off to halve the request count — you still get make, model, year, price (both EUR and BGN), mileage, fuel, gearbox, engine power and size, body type, colour, and photos from the listing cards.

What are the main use cases?

Cross-border arbitrage: Bulgaria vs Western Europe 💡

Bulgaria's used-car prices are among the lowest in the EU. A dataset of Mobile.bg listings filtered by make, year, and mileage_km, compared against equivalent data from coches.net, leboncoin, or Marktplaats, reveals the price delta for specific models. Importers use this to source vehicles for resale in higher-price markets.

EUR/BGN dual-currency price tracking

Bulgaria is in the process of euro adoption. Mobile.bg already shows both prices. The price (EUR) and price_bgn (BGN) fields let you track market pricing through the currency transition — useful for financial modelling and policy research.

Depreciation modelling: price vs mileage vs age

Pull a broad dataset for a specific model (e.g. all Volkswagen Passat listings), export to CSV, and fit a regression. The year, mileage_km, engine_power_hp, and transmission fields give you the standard independent variables. Bulgarian private-seller pricing tends to be less filtered by dealer margin, which produces more signal for depreciation studies.

Dealer intelligence

Filter seller_type to dealer (requires enrichDetails: true), segment by location, and you have a directory of active Bulgarian car dealers with their listed inventory. Track price changes across successive runs.

Fresh listings monitoring

The posted_date field carries Mobile.bg's own relative posting marker (e.g. НОВА ОБЯВА — "new listing"). Run the Actor daily and filter to new listings to catch fresh private-seller posts before they attract attention.

FAQ

Is it legal to scrape Mobile.bg?

The Actor accesses publicly visible listing data — the same data any browser user sees without logging in. Mobile.bg's terms of service govern automated access; review them for your jurisdiction and use case before running at scale. We recommend responsible pacing and legitimate analytical use.

The fuel type and body type values are in Bulgarian — can I translate them?

The column names (fuel_type, body_type, transmission, color) are standard English. The values are preserved in the original Bulgarian so nothing is lost. Common mappings: Дизелов → Diesel, Бензинов → Petrol, Електрически → Electric, Ръчна → Manual, Автоматична → Automatic, Хечбек → Hatchback, Седан → Sedan, Комби → Estate/Wagon.

What currency are prices in?

price is always in EUR and currency is always EUR. price_bgn carries the Bulgarian-lev equivalent shown on the site. If price_bgn is null, the listing did not show a lev amount.

What does enrichDetails add?

Setting enrichDetails: true fetches each listing's detail page for the full technical table, exact engine displacement, the seller's city (location), and seller_type. Without enrichment you still get make, model, year, price (EUR + BGN), mileage, fuel, gearbox, engine power and size, body type, colour, and photos from the listing card.

How much does a run of 2,000 listings cost?

$0.05 (start) + 2,000 × $0.002 = $4.05.

Start collecting Bulgarian car listing data

The Mobile.bg Bulgaria Car Scraper is live on the Apify Store. Click Try for free — $5 of credit included, no card required.

Your first dataset exports to JSON or CSV in minutes. If you hit an edge case or need a field added, open an issue on the Actor's Issues tab and we'll address it in the next weekly release.

Resources:

How to Scrape Marktplaats Car Listings (Netherlands) to JSON/CSV

Devil Scrapes — Sat, 13 Jun 2026 10:27:55 +0000

Quick answer: Use the Marktplaats Netherlands Car Scraper on Apify. Paste a filtered Marktplaats auto's search URL, set maxResults, and the Actor walks the result pages and delivers structured rows — price in EUR, make, model, year, mileage, fuel, transmission, body type, drivetrain, energy label, seller, and photos — into a JSON or CSV dataset. No API key, no local scraping stack.

Why scrape Marktplaats for car listings?

Marktplaats.nl is the Netherlands' dominant classifieds marketplace — the Dutch equivalent of Craigslist and eBay Classifieds rolled into one. The auto's category carries listings from both private sellers and professional dealers (handelaren), making it the primary source for Dutch used-car pricing data. Marktplaats publishes no public API for its listings.

The site has a few characteristics that make extraction non-trivial: listing data is served through Marktplaats' own internal search service (not a straightforward HTML scrape), the platform uses Dutch-language spec labels (bouwjaar, kilometerstand, Handgeschakeld, Voorwielaandrijving), and it employs residential proxy detection on its search endpoints. The Actor handles all of that, including Dutch-specific quirks like bid-based listings (Bieden) and the Dutch energy label system (A through G).

What fields does the scraper return? 💡

Every row maps directly to the ResultRow Pydantic model in the Actor's source. Here is a realistic sample row:

{
  "listing_id": "m2406042278",
  "listing_url": "https://www.marktplaats.nl/v/auto-s/skoda/m2406042278-skoda-octavia-1-6-comfort",
  "title": "Skoda Octavia 1.6 Comfort",
  "make": "Skoda",
  "model": "Octavia",
  "year": 2001,
  "price": 1150,
  "currency": "EUR",
  "price_type": "Te koop",
  "mileage_km": 315844,
  "fuel_type": "Benzine",
  "transmission": "Handgeschakeld",
  "body_type": "Hatchback",
  "drive_train": "Voorwielaandrijving",
  "energy_label": "B",
  "color": "Grijs",
  "location": "Lienden",
  "region": "Nederland",
  "seller_type": "dealer",
  "seller_name": "MBSmart",
  "seller_id": "56392587",
  "photo_urls": [
    "https://images.marktplaats.com/api/v1/hz-mp-pro-listing/images/4933080c-8de2-40e5-95e9-e9cc46631ef3?rule=ecg_mp_eps$_85.jpg"
  ],
  "description": "Algemene informatie Aantal deuren: 5 Kleur: Grijs ...",
  "posted_date": "Vandaag",
  "scraped_at": "2026-06-02T00:00:00+00:00"
}

The complete field set is: listing_id, listing_url, title, make, model, year, price, currency (always EUR), price_type, mileage_km, fuel_type, transmission, body_type, drive_train, energy_label, color, location, region, seller_type, seller_name, seller_id, photo_urls, description, posted_date, and scraped_at. The color and description fields are populated via detail-page enrichment.

Note drive_train — this is the exact field name in the ResultRow model (not drivetrain). Use it as-is when processing the dataset.

What does it cost to scrape Marktplaats listings?

Pricing is Pay-Per-Event.

Event	Price
`actor-start` (one-off per run)	$0.05
`result-row` (per car listing)	$0.002

1,000 results in a single run costs $2.05 ($0.05 start + 1,000 × $0.002). Every new Apify account gets $5 of free credit — enough to pull your first two thousand listings before spending anything. No credit card required to start.

How does the anti-blocking work? 🔥

Marktplaats.nl protects its search endpoints from automated scraping. Here is how we handle it:

We rotate Chrome, Firefox, and Safari TLS fingerprints on every request using curl-cffi browser impersonation. The platform sees a real-browser TLS handshake, not a Python HTTP client.
We rotate residential proxy sessions through Apify Proxy on any block — a new session ID and a new Dutch exit IP, automatically.
We retry on 408, 429, and 5xx responses with exponential backoff (starting at two seconds, capping at thirty, up to five attempts per page), honouring Retry-After headers.
Sponsored Admarkt ads (item IDs beginning with a) are detected and skipped — they contaminate price analysis datasets.
Partial successes surface with a clear status message. We never quietly return an empty dataset.

The default proxy configuration already requests Dutch RESIDENTIAL exits. Nothing to configure.

How to run the scraper from Python

Install apify-client and call the Actor:

from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_API_TOKEN")

run_input = {
    "searchUrl": "https://www.marktplaats.nl/l/auto-s/volkswagen/golf/#Language:all-languages",
    "maxResults": 200,
    "enrichDetails": True,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

run = client.actor("DevilScrapes/marktplaats-netherlands-cars").call(run_input=run_input)

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(
        item["make"], item["model"], item["year"],
        item["price"], item["mileage_km"], item["energy_label"]
    )

To target a specific search, apply your filters on marktplaats.nl, copy the URL, and paste it into searchUrl. The Actor translates it to the internal search query. Set enrichDetails to False if you only need the search-payload fields — price, make, model, year, mileage, fuel, transmission, body type, drivetrain, energy label, seller, and photos — without fetching each detail page.

What are the main use cases?

Used-car price analytics for the Dutch market

Marktplaats combines private sellers and dealers in a single feed, giving a complete picture of Dutch retail and C2C pricing. Pull listings for a model range, export to CSV, and build price-vs-age and price-vs-mileage charts. The energy_label column adds a sustainability dimension you will not find on most car data APIs.

Energy label composition research

The Netherlands has aggressive emission regulations and a strong push toward electrification. The energy_label field (A through G) lets you aggregate the label distribution across any search filter — useful for fleet compliance reporting, real-estate proximity analysis, or EV market research.

Dealer inventory monitoring

Filter seller_type to dealer, run on a cron schedule, and diff by listing_id to track new stock and price changes. The seller_id field lets you group all listings from the same dealership even when the seller_name display name changes.

Bid-based listing research

Listings with price_type: "Bieden" are minimum-bid auctions. Filter to Bieden listings and you have a view of the distressed-sale segment of the Dutch market — a common source of under-market deals.

Cross-border sourcing

Dutch used-car prices are competitive against some neighbouring markets, especially on specific segments. A Marktplaats dataset filtered by fuel_type, mileage_km, and year gives European importers a current Dutch benchmark.

FAQ

Is it legal to scrape Marktplaats.nl?

The Actor accesses publicly visible listing data — the same data any browser user sees without logging in. Marktplaats's terms of service govern automated access; review them for your use case before running at scale. We recommend responsible pacing and legitimate analytical use.

What is price_type and why is it sometimes Bieden?

Marktplaats supports fixed-price listings (Te koop), bid-based listings (Bieden), and reserved listings (Gereserveerd). The price field is still populated for Bieden listings (it shows the minimum bid), and price_type tells you which mode applies.

Why are color and description sometimes null?

Both come from the listing detail page, not the search payload. Set enrichDetails: true (the default) to fill them in. Turn it off to halve the request count — price, specs, seller, and photos all come from the search results.

How much does a run of 5,000 listings cost?

$0.05 (start) + 5,000 × $0.002 = $10.05.

Are sponsored Admarkt ads included?

No. Admarkt ads (item IDs starting with a) are detected and skipped automatically. They distort price comparisons and typically point to dealer landing pages rather than individual listings.

Start collecting Dutch car listing data

The Marktplaats Netherlands Car Scraper is live on the Apify Store. Click Try for free — $5 of credit included, no card required.

Your first dataset exports to JSON or CSV in minutes. Questions or edge cases? Open an issue on the Actor's Issues tab and we'll address it in the next weekly release.

Resources:

How to Scrape leboncoin Car Listings (France) to JSON/CSV

Devil Scrapes — Sat, 13 Jun 2026 10:22:38 +0000

Quick answer: Use the leboncoin France Car Scraper on Apify. Paste a filtered leboncoin.fr Voitures search URL, set maxResults, and the Actor walks the result pages and returns structured rows — price in EUR, brand, model, year, mileage, fuel, gearbox, Crit'Air sticker, seller, location, and photos — as a JSON or CSV dataset. No API key, no local scraping stack to configure.

Why scrape leboncoin for car listings?

leboncoin.fr is France's largest classifieds marketplace and the default venue for millions of French used-car transactions each year. The Voitures section carries hundreds of thousands of live listings from private sellers and professional dealers alike. There is no public API — structured data access means extracting it from the search pages.

That extraction is not straightforward. leboncoin is fronted by bot protection. Datacenter IP ranges get challenged or blocked. The listing data is embedded in JSON inside server-rendered HTML, paginated at 35 results per page. The French automotive classification has its own vocabulary: Crit'Air air-quality stickers (a regulatory requirement for driving in low-emission zones), horsepower measured in chevaux, fuel types like Essence and Hybride. The Actor handles all of it and delivers clean, typed rows.

What fields does the scraper return?

Every row maps exactly to the ResultRow Pydantic class in the Actor source. Here is a realistic sample row:

{
  "listing_id": "3117822207",
  "listing_url": "https://www.leboncoin.fr/ad/voitures/3117822207",
  "title": "Morris Mini COOPER 1275 S",
  "make": "MORRIS",
  "model": "Autre",
  "year": 1968,
  "price": 34900,
  "currency": "EUR",
  "mileage_km": 101890,
  "fuel_type": "Essence",
  "transmission": "Manuelle",
  "engine_power_hp": null,
  "engine_size_cc": null,
  "body_type": "Citadine",
  "color": "Vert",
  "first_registration": "07/1968",
  "location": "Saint-Jean-du-Cardonnay",
  "region": "Seine-Maritime",
  "postcode": "76150",
  "seller_type": "dealer",
  "seller_name": "MECA SPORT",
  "critair": "Non classé",
  "photo_urls": [
    "https://img.leboncoin.fr/api/v1/lbcpb1/images/12/99/eb/1299eb9f07aa41b5f0430ce684d22b4e689dc47c.jpg?rule=ad-image"
  ],
  "description": "Magnifique Morris Mini Cooper 1275 S restaurée.",
  "posted_date": "2025-12-26 14:04:00",
  "scraped_at": "2026-06-02T00:00:00+00:00"
}

The full field set is: listing_id, listing_url, title, make, model, year, price, currency (always EUR), mileage_km, fuel_type, transmission, engine_power_hp, engine_size_cc, body_type, color, first_registration, location, region, postcode, seller_type, seller_name, critair, photo_urls, description, posted_date, and scraped_at. The description field comes from the search payload; when enrichDetails is on, it is re-fetched from the detail page for the freshest copy.

What does it cost to scrape leboncoin listings? 💰

Pricing is Pay-Per-Event — you pay only when rows land in the dataset.

Event	Price
`actor-start` (one-off per run)	$0.05
`result-row` (per car listing)	$0.002

1,000 results in a single run costs $2.05 ($0.05 start + 1,000 × $0.002). Every new Apify account receives $5 of free credit — enough to pull your first couple of thousand listings before you spend anything. No credit card required to begin.

How does the anti-blocking work?

leboncoin.fr is fronted by bot protection. Residential proxy sessions are not optional — they are required for reliable access. Here is what we do so you do not have to:

We rotate Chrome, Firefox, and Safari TLS fingerprints on every request using curl-cffi browser impersonation. The site's protection stack sees a real browser handshake, not a Python HTTP client.
We rotate residential proxy sessions through Apify Proxy on every block — a fresh session ID and a fresh French exit IP, automatically.
We retry on 408, 429, and 5xx responses with exponential backoff (starting at two seconds, capped at thirty, up to five attempts per page), honouring Retry-After headers.
When the site pushes back, we slow down rather than triggering a harder block. Partial runs surface with a clear status message; we never return empty data with a green status.

The default proxy config already requests RESIDENTIAL exits. You do not need to configure anything.

How to run the scraper from Python 🔥

Install the apify-client library and call the Actor:

from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_API_TOKEN")

run_input = {
    "searchUrl": "https://www.leboncoin.fr/recherche?category=2&brand=Peugeot&vehicle_type=4",
    "maxResults": 300,
    "enrichDetails": True,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

run = client.actor("DevilScrapes/leboncoin-france-cars").call(run_input=run_input)

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["make"], item["model"], item["price"], item["mileage_km"], item["critair"])

To target a specific search, apply your filters on leboncoin.fr, copy the URL, and paste it into searchUrl. The Actor walks result pages from there. Set enrichDetails to False if you only need the search-payload fields — price, brand, model, year, mileage, fuel, gearbox, colour, seller, location, and photos — and want to halve the request count.

What are the main use cases?

Used-car price analytics for the French market

Pull listings for a specific make and model, export to CSV, and load into your analysis tool of choice. leboncoin's depth in the private-seller segment gives a view of French retail pricing that dealer-only datasets miss.

Crit'Air label composition research

France's Crit'Air system classifies vehicles from label 0 (fully electric) through to Non classé for the oldest polluters. Low-emission zones in Paris, Lyon, and other major cities restrict entry by Crit'Air label. The critair field lets you aggregate the sticker distribution across any filtered search — useful for policy research, fleet management planning, or market forecasting.

Dealer inventory monitoring

Filter seller_type to dealer, set a daily schedule, and diff successive datasets by listing_id to catch new arrivals and price cuts. seller_name, location, and postcode let you segment by dealer and geography.

Cross-border arbitrage from France

French private-seller prices, especially on diesel estates and older luxury cars, can diverge meaningfully from equivalent listings in neighbouring markets. A dataset filtered by fuel_type, year, and mileage_km gives importers a current benchmark.

Lead generation: French car dealers

Dealer listings carry seller_name and the dealer's location and postcode. Run a broad sweep across the Voitures section and you have a structured directory of active French car dealers, filterable by region.

FAQ

Is it legal to scrape leboncoin.fr?

The Actor accesses publicly visible listing data — the same data any browser user sees without logging in. leboncoin's terms of service govern automated access; review them for your jurisdiction and use case before running at scale. We recommend responsible pacing and legitimate analytical use.

Why does this Actor require a residential proxy?

leboncoin.fr's bot protection challenges or blocks datacenter IP ranges. Residential exit IPs from Apify Proxy ride past this reliably. The default proxy configuration already requests RESIDENTIAL — you do not need to change anything.

What is the Crit'Air field?

The Crit'Air (Certificat Qualité de l'Air) is a French government air-quality sticker required for driving in designated low-emission zones (Zones à Faibles Émissions). It is published on listings where the seller has declared it. Values include 0, 1, 2, 3, 4, 5, and Non classé. Not all listings include it.

How much does 5,000 listings cost?

$0.05 (start) + 5,000 × $0.002 = $10.05 for one run of 5,000 results.

How often can I run it?

As often as you need. Schedule in the Apify Console with a cron expression. The Apify API lets you access and diff successive datasets programmatically.

Start collecting French car listing data

The leboncoin France Car Scraper is live on the Apify Store. Click Try for free — $5 of credit included, no card required.

Your first dataset is minutes away. If you hit an edge case or need an additional field, open an issue on the Actor's Issues tab and we'll address it in the next weekly release.

Resources:

How to Scrape FINN.no Car Listings (Norway) to JSON/CSV

Devil Scrapes — Sat, 13 Jun 2026 10:17:22 +0000

Quick answer: Use the FINN.no Car Scraper on Apify. Paste a filtered FINN.no car search URL (or just set a make or query), choose maxResults, and the Actor walks every page and returns structured rows — NOK price, make, model, year, mileage, fuel, gearbox, body type, colour, and seller type — in a JSON or CSV dataset. No API key, no scraping infrastructure to maintain.

Why scrape FINN.no?

FINN.no is Norway's dominant classifieds marketplace and hosts tens of thousands of used-car listings. If you want a dataset of Norwegian car prices, want to monitor a dealer's stock, or are tracking the country's famously active used-EV market, the FINN.no car search is the primary source of truth. FINN publishes no public API for its car listings. Structured data means you have to extract it from the search pages.

Norway's used-car market has its own quirks: prices in Norwegian kroner (NOK), Norwegian-language spec labels (Modellår, Drivstoff, Girkasse, Karosseri, Farge), and a used-EV penetration rate that leads Europe. The Actor maps all of those to standard English column names and outputs clean, typed rows.

What fields does the scraper return? 🔥

Every row maps directly to the ResultRow Pydantic class in the Actor's source. Here is a realistic sample:

{
  "listing_id": "463169662",
  "listing_url": "https://www.finn.no/mobility/item/463169662",
  "title": "Renault Kangoo",
  "make": "Renault",
  "model": "Kangoo",
  "year": 2014,
  "price": 33796,
  "currency": "NOK",
  "mileage_km": 214713,
  "fuel_type": "Diesel",
  "transmission": "Manuell",
  "engine_power_hp": 90,
  "engine_size_cc": null,
  "body_type": "Kasse",
  "color": "Hvit",
  "first_registration": "09.10.2013",
  "location": "Norge",
  "region": null,
  "seller_type": "private",
  "seller_name": null,
  "photo_urls": [
    "https://images.finncdn.no/dynamic/default/item/463169662/78cfeabc-d8b8-4c8c-99eb-ce53725c1209"
  ],
  "description": null,
  "posted_date": null,
  "scraped_at": "2026-06-02T00:00:00+00:00"
}

The complete field set is: listing_id, listing_url, title, make, model, year, price, currency (always NOK), mileage_km, fuel_type, transmission, engine_power_hp, engine_size_cc, body_type, color, first_registration, location, region, seller_type, seller_name, photo_urls, description, posted_date, and scraped_at. Fields tagged enrichment-only are populated only when enrichDetails is true (the default).

What does it cost to scrape FINN.no listings?

Pricing is Pay-Per-Event.

Event	Price
`actor-start` (one-off per run)	$0.05
`result-row` (per car listing)	$0.002

1,000 results in one run costs $2.05 ($0.05 start + 1,000 × $0.002). Apify gives every new account $5 of free credit — enough to pull your first two thousand listings before you spend anything. No card required to start.

How does the anti-blocking work?

FINN.no does not hand out listing data to every HTTP client that asks nicely. We handle that:

We rotate Chrome, Firefox, and Safari TLS fingerprints using curl-cffi browser impersonation — FINN sees a real browser's handshake, not a Python request library.
We rotate residential proxy sessions through Apify Proxy on every block, cycling to a fresh session ID and exit IP automatically.
We retry on 408, 429, and 5xx responses with exponential backoff (starting at 2 seconds, up to five attempts per page), honouring any Retry-After headers the server sends back.
When FINN pushes back and rate-limits the run, we pace down rather than triggering a harder block. Partial successes are surfaced with a clear status message — we never return an empty dataset with a green status.

The devil's in the details. We handle them.

How to run the scraper from Python

Install the apify-client library and call the Actor:

from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_API_TOKEN")

run_input = {
    "query": "tesla model 3",
    "maxResults": 100,
    "enrichDetails": True,
    "proxyConfiguration": {
        "useApifyProxy": True,
    },
}

run = client.actor("DevilScrapes/finn-norway-cars").call(run_input=run_input)

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["make"], item["model"], item["price"], item["currency"], item["mileage_km"])

You have three ways to target listings. Set query for a free-text search (e.g. "audi a4 quattro"), set make for a single brand filter (e.g. "Tesla"), or paste a full FINN search URL into searchUrl with all your filters already applied — the URL wins if all three are set. Turn enrichDetails off to halve the request count if mileage, gearbox, and power are not required.

What are the main use cases? 💡

Used-EV market tracking

Norway leads Europe in EV adoption and its used-EV market moves fast. Query make: "Tesla" or query: "elbil", run the Actor weekly, and you have a time series of Norwegian used-EV asking prices in NOK. Chart price against mileage and model year to see depreciation curves no paid automotive data service covers for this market.

Dealer inventory monitoring

Filter seller_type by dealer, run on a schedule, and diff successive datasets to catch new arrivals and price drops at specific dealerships. seller_name and location give you everything needed to segment by dealer.

Price benchmarking for importers

Norwegian consumers pay import taxes and VAT on new cars but the used market prices can be competitive for European buyers shopping cross-border. A dataset of FINN prices in NOK, normalised to EUR, gives importers a baseline.

Private-seller arbitrage

Private sellers on FINN sometimes list cars well below dealer retail. Filter seller_type: private and set a tight price band to surface those listings the moment they appear.

Regression modelling: price vs mileage vs age

Pull a broad dataset (e.g. all Volkswagen Golf listings), export to CSV, and fit a simple regression. The year, mileage_km, engine_power_hp, and transmission fields give you the standard independent variables.

FAQ

Is it legal to scrape FINN.no?

The Actor scrapes publicly visible listing data — the same data any browser user sees without logging in. FINN.no's terms of service govern automated access; review them for your specific use case. We recommend reasonable scraping cadence and using the data for legitimate analytical purposes.

Why are mileage, gearbox, and power sometimes null?

Those fields live on each car's individual detail page, not in the search payload. Keep enrichDetails on (the default) to fill them in. Turn it off to halve the request count and get only make, model, year, price, photos, and seller type from the search results.

What currency are prices in?

Norwegian kroner (NOK). The currency field is always NOK; price is an integer amount. Convert to EUR or GBP client-side with a live exchange rate if needed.

How do I search a specific model?

Set query to something like "volvo xc60 diesel", or apply your filters directly on finn.no and paste the resulting URL into searchUrl.

Can I schedule it to run daily?

Yes. Set up a scheduled task in the Apify Console with a cron expression. Successive datasets are stored and accessible via the Apify API for diffing and downstream processing.

Start collecting Norwegian car data

The FINN.no Car Scraper is live on the Apify Store. Hit Try for free — $5 of credit included, no card required.

Export to JSON or CSV in minutes. Questions or edge cases? Open an issue on the Actor's Issues tab and we'll look at it in the next weekly release.

Resources:

How to Scrape coches.net Car Listings (Spain) to JSON/CSV

Devil Scrapes — Sat, 13 Jun 2026 10:12:07 +0000

Quick answer: Use the coches.net Spain Car Scraper on Apify. Paste your filtered coches.net search URL, set maxResults, and the Actor walks every page of results and returns structured rows — price, make, model, year, mileage, fuel type, environmental label, seller, and photos — directly to a JSON or CSV dataset. No API key needed, no Python environment to configure.

Why scrape coches.net at all?

coches.net is Spain's largest used-car marketplace. Millions of segunda-mano listings sit behind its search interface, and there is no public API. If you want to track Spanish asking prices by make and model, monitor a dealer's inventory, or build a cross-border arbitrage dataset, you have to scrape the public search pages.

Scraping a high-traffic Spanish marketplace is not a casual afternoon project. The site serves its listing data through a mix of rendered HTML and embedded JSON payloads, paginates at 30 listings per page, and pushes back hard against automated traffic with fingerprinting and rate-limiting. We built the Actor to absorb all of that so you get clean rows in a dataset rather than 403 errors in a terminal.

What fields does the scraper return?

Every row returned by the Actor maps exactly to the ResultRow Pydantic model in the Actor's source. Here is a realistic example output row:

{
  "listing_id": "54595133",
  "listing_url": "https://www.coches.net/land-rover-range-rover-velar-30-d300-se-4wd-auto-diesel-2019-en-madrid-54595133-covo.aspx",
  "title": "LAND-ROVER Range Rover Velar 3.0 D300 SE 4WD Auto",
  "make": "LAND-ROVER",
  "model": "Range Rover Velar",
  "version": "3.0 D300 SE 4WD Auto",
  "year": 2018,
  "price": 34900,
  "currency": "EUR",
  "mileage_km": 101643,
  "fuel_type": "Diésel",
  "transmission": "Automatic",
  "engine_power_hp": 300,
  "drivetrain": "All",
  "body_type": "6",
  "color": "Gray",
  "environmental_label": "C",
  "first_registration": "2018",
  "location": "Majadahonda",
  "region": "Madrid",
  "seller_type": "dealer",
  "seller_name": "Movilcar",
  "seller_rating": 4.7,
  "photo_urls": [
    "https://a.ccdn.es/cnet/vehicles/13042849/d0305526-6eeb-4e4c-8535-4463a6c1367e.jpg"
  ],
  "has_warranty": true,
  "warranty_months": 12,
  "description": "Libro de revisiones en concesionario oficial. 12 meses de garantia oficial.",
  "posted_date": "2026-04-24T09:05:37Z",
  "scraped_at": "2026-06-02T00:00:00+00:00"
}

The full field set includes listing_id, listing_url, title, make, model, version, year, price, currency, mileage_km, fuel_type, transmission, engine_power_hp, drivetrain, body_type, color, environmental_label, first_registration, location, region, seller_type, seller_name, seller_rating, photo_urls, has_warranty, warranty_months, description, posted_date, and scraped_at. Fields marked enrichment-only (version, transmission, drivetrain, color, description) are populated when enrichDetails is true.

What does it cost to scrape coches.net listings? 💰

Pricing is Pay-Per-Event — you pay for results that land, not for compute time.

Event	Price
`actor-start` (one-off per run)	$0.05
`result-row` (per car listing)	$0.002

How does the anti-blocking work?

coches.net does not welcome automated traffic. We handle the blocks so you do not have to think about them:

We rotate through Chrome, Firefox, and Safari TLS fingerprints on every request using curl-cffi browser impersonation, so the site's anti-bot stack sees real-browser handshakes, not a Python HTTP client.
We rotate residential proxy sessions through Apify Proxy on every block — a new session ID and a new exit IP, automatically.
We retry with exponential backoff on 408, 429, and 5xx responses, honouring Retry-After headers, up to five attempts per page.
When the target rate-limits us, we slow down rather than getting banned. Partial successes surface with a clear status message — we never silently return an empty dataset.

You get clean, typed rows. We run the gauntlet.

How to run the scraper from Python

The Actor lives on the Apify platform. The fastest way to call it from your own code is the apify-client Python library:

from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_API_TOKEN")

run_input = {
    "searchUrl": "https://www.coches.net/segunda-mano/?ma=BMW&mo=3+Series",
    "maxResults": 200,
    "enrichDetails": True,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

run = client.actor("DevilScrapes/coches-spain-cars").call(run_input=run_input)

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["make"], item["model"], item["price"], item["currency"])

Swap in your own search URL — apply your filters on coches.net, copy the URL, paste it into searchUrl. The Actor walks result pages from that filtered starting point. Set enrichDetails to False to halve the request count if you only need price, mileage, power, and seller from the search payload.

What are the main use cases?

Used-car price analytics

Pull 500 listings for a specific make and model, export to CSV, and load into a spreadsheet or pandas DataFrame. You can plot asking prices against mileage and year in under ten minutes once the data is in your hands.

Dealer inventory monitoring

Filter by a dealer's name or location, run the Actor on a schedule, and diff successive datasets to catch new arrivals and price drops. Spain's dealer market moves fast; a daily diff keeps you current.

Market research: DGT environmental labels

Spain's Dirección General de Tráfico assigns environmental labels (0, ECO, C, B) to vehicles for low-emission zone access. The environmental_label field lets you aggregate the mix of labels across any filtered search — useful for tracking how quickly the segunda-mano market is shifting toward ECO and 0-label vehicles.

Cross-border arbitrage

Spanish used-car prices diverge from northern European markets, especially for diesel estates and certain German brands. Filter by fuel_type, mileage_km, and year, then compare against a dataset from another EU marketplace to spot import opportunities.

Lead generation

The seller_name and location fields on dealer listings give you a ready-made directory of car dealers in any Spanish province. Combine with seller_rating to rank them.

FAQ

Is it legal to scrape coches.net?

This Actor scrapes publicly visible listing data — the same information any browser user sees without logging in. coches.net's terms of service govern automated access; review them for your jurisdiction and use case. We recommend scraping responsibly: use the default rate-limiting settings, do not request data at a pace that would stress the server, and use the data for legitimate analytical and research purposes.

How much does 10,000 listings cost?

One run of 10,000 results costs $0.05 (start) + 10,000 × $0.002 = $20.05. You pay only when rows actually land in the dataset.

How often can I run it?

As often as you need. Schedule it daily in the Apify Console with a cron expression and it runs unattended. Successive datasets can be diffed programmatically via the Apify API.

What if coches.net blocks the Actor?

We handle blocks automatically through residential proxy rotation and session cycling. If a run encounters a hard ban across all available exits, the Actor exits non-zero with a clear status message rather than returning empty data quietly.

Start scraping Spanish car listings

The coches.net Spain Car Scraper is live on the Apify Store. Click Try for free — your first $5 of credit is on Apify, no card required.

Export your first dataset to JSON or CSV in minutes. If you run into an edge case or need an extra field, open an issue on the Actor's Issues tab — we ship fixes weekly.

Resources:

How to Scrape Carzone.ie Car Listings (Ireland) to JSON/CSV

Devil Scrapes — Sat, 13 Jun 2026 10:06:52 +0000

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

Ireland's used-car market has a few distinctive quirks. The market is denominated in euros, left-hand traffic means most Irish cars are right-hand drive, and engine power is reported in BHP (brake horsepower) rather than the metric PS/CV used across most of continental Europe. The county-level location field matters too — Dublin listings trade at a premium over identical cars in Connacht, and that geographic signal is worth capturing.

Carzone.ie is Ireland's leading used-car marketplace, listing tens of thousands of cars at any given moment. It publishes no developer API. The site's search pages surface roughly 10 listings per page, with detail pages holding the richer spec data (transmission, BHP, cc, body type, colour, county). Getting a complete structured view of the market means working through both layers — which requires session management, residential proxies, and robust retry logic.

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

Does Carzone.ie Have an API? 🔎

No. Carzone.ie publishes no public car API and no structured data export. Its search is backed by an internal endpoint that the Next.js frontend calls — not a stable surface for external code. The site also de-duplicates sponsored and featured placements that appear mixed into search results; the Actor handles that de-duplication for you by advert ID.

What Data You Can Extract

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

Field	Description
`listing_id`	Carzone advert ID
`listing_url`	Absolute URL to the listing
`title`	Make + model + derivative
`make`	Manufacturer (e.g. Toyota)
`model`	Model (e.g. Corolla)
`year`	Registration / model year
`price`	Integer price in EUR
`currency`	Always `EUR`
`mileage_km`	Odometer in kilometres
`fuel_type`	Petrol / Diesel / Electric / Petrol Hybrid
`transmission`	Manual or Automatic — enrichment-only
`engine_power_hp`	Engine power in BHP — enrichment-only
`engine_size_cc`	Displacement in cc — enrichment-only
`body_type`	Hatchback / Saloon / SUV, etc. — enrichment-only
`color`	Exterior colour — enrichment-only
`first_registration`	First registration date YYYY-MM-DD — enrichment-only
`location`	Seller town/city — enrichment-only
`region`	Irish county — enrichment-only
`seller_type`	`dealer` (Trade) or `private`
`seller_name`	Dealer trading name — enrichment-only
`photo_urls`	List of photo URLs
`description`	Advert description / equipment list
`posted_date`	Listing last-updated date
`scraped_at`	ISO-8601 UTC timestamp of scrape

The region field carries the Irish county — Dublin, Cork, Galway, Meath, and so on. This is the geographic granularity that matters in the Irish market: county-level pricing differences are significant and not captured by city names alone.

Engine power in engine_power_hp is BHP as Carzone reports it — consistent with how Irish buyers compare cars, and directly comparable to other UK/Ireland automotive data sources.

A Realistic Output Row

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

{
  "listing_id": "4444769",
  "listing_url": "https://www.carzone.ie/used-cars/mitsubishi/mirage/fpa/4444769",
  "title": "Mitsubishi Mirage 1.2 DBA-A03A CVT 5DR AU AUTO",
  "make": "Mitsubishi",
  "model": "Mirage",
  "year": 2017,
  "price": 6990,
  "currency": "EUR",
  "mileage_km": 111000,
  "fuel_type": "Petrol",
  "transmission": "Automatic",
  "engine_power_hp": 78,
  "engine_size_cc": 1200,
  "body_type": "Hatchback",
  "color": "White",
  "first_registration": "2017-02-28",
  "location": null,
  "region": "Meath",
  "seller_type": "dealer",
  "seller_name": "CarBar",
  "photo_urls": [
    "https://c0.carsie.ie/d43864c90df075c94489ddbe4ca5ffe9742493abfef315899189d722e9fae6e5.jpg"
  ],
  "description": null,
  "posted_date": null,
  "scraped_at": "2026-06-02T00:00:00+00:00"
}

Note that mileage is already in kilometres — Carzone reports km natively, so there is no unit conversion required (unlike Swedish Blocket, which uses the Swedish mil).

How We Handle the Blocks

Carzone.ie is a modern JavaScript marketplace. Its search pages serve approximately 10 listings per page and surface sponsored placements mixed in with organic results. Here is what the Actor does to stay reliable across both the search and detail layers:

Browser fingerprint rotation. We use curl-cffi to impersonate real Chrome, Firefox, and Safari TLS handshakes. The server sees a real browser, not Python.
Residential proxy rotation via Apify Proxy. We rotate residential exit IPs and fresh session IDs on every block signal. Irish residential exits are preferred for this target.
Exponential backoff with Retry-After. We retry on 408, 429, and 5xx — up to five attempts per page, honouring Retry-After headers.
Rate-limit-aware pacing. When the site pushes back, we slow down rather than burning through retries.
Advert ID deduplication. Sponsored and featured placements appear multiple times in Carzone search results. The Actor de-duplicates by listing_id so you never get duplicate rows in your dataset.
Loud failure, never silent. A hard block produces a non-zero exit with a descriptive status message — never a green run with zero results.

Running It with Python 🐍

from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")

run = client.actor("DevilScrapes/carzone-ireland-cars").call(
    run_input={
        "make": "Toyota",
        "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"], "EUR", "—", item["region"])

Three ways to target your search:

make — convenience filter, e.g. "Toyota". Builds the /used-cars/toyota path automatically.
query — free-text keywords, e.g. "hybrid suv". Maps to Carzone's keywords parameter.
searchUrl — paste a full Carzone search URL with filters applied. The URL wins if all three are set.

Use Cases

Irish EUR price analytics. Build time series of asking prices for specific makes and models in the Irish market. Run daily and push to a database; plot price vs. mileage and price vs. year to understand depreciation curves in EUR.

EV and hybrid market tracking. Query fuel_type = Electric or Petrol Hybrid to chart Ireland's used-EV pricing. Ireland introduced strong SEAI EV grants that suppressed new-EV prices and are now flowing through to the used market — tracking Carzone gives you the data to see that in real time.

County-level pricing analysis. Use the region field to compare asking prices for identical cars across Irish counties. Dublin vs. rural Connacht pricing gaps are well known in the trade; quantifying them from listing data is straightforward with region in your dataset.

Dealer inventory monitoring. Filter by seller_type = dealer and seller_name to watch a competitor's stock. Diff successive runs to catch new arrivals and price movements.

Arbitrage from the UK. Ireland and the UK share a right-hand-drive convention, making cross-channel vehicle sourcing common. Compare Carzone EUR prices against UK equivalents (in GBP) to spot import opportunities, particularly on popular Japanese imports like the Corolla and Yaris.

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.

Is mileage in miles or kilometres?

Kilometres. Carzone.ie reports mileage in km natively and the Actor stores the km value in mileage_km — no conversion required. This makes it directly comparable with other EU markets in the fleet.

Why are transmission, body type, and county sometimes null?

Those fields live on each car's detail page, not the search result card. Keep enrichDetails: true (the default) to fill them in; set it to false to halve the request count and return only what the search page provides: make, model, year, price, mileage, fuel type, and photos.

Is scraping Carzone.ie legal?

Carzone'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, access private messages, or scrape seller phone numbers.

Does this cover new cars too?

The default search targets the used-car channel. Paste a searchUrl that includes new-car filters if you want those — the parser reads whatever the search page returns.

Get Started

The Actor is live on the Apify Store. Every new Apify account starts with $5 of free credit — enough for roughly 2,400 enriched listings.

Carzone Car Scraper on Apify Store

Questions or edge cases? Use the Actor's Issues tab on Apify Console. We ship fixes weekly and read every report.

Built by Devil Scrapes — a fleet of opinionated public-data Actors. Honest pricing, real engineering, zero fine print.

How to Scrape Cars.bg Car Listings (Bulgaria) to JSON/CSV

Devil Scrapes — Sat, 13 Jun 2026 10:01:36 +0000

Quick answer: Cars.bg publishes no public API, so structured used-car data requires scraping the public listings. The Cars.bg Bulgaria Car Scraper on Apify handles browser fingerprint rotation, residential proxy rotation, and retries for you — returning clean typed rows with dual EUR and BGN pricing at $2.05 per 1,000 results ($0.05 actor-start + $0.002 per result).

Bulgaria's used-car market has a quirk that sets it apart from most of Western Europe: prices appear in both euros and Bulgarian lev (BGN) on every single listing. Bulgaria is an EU member but retains the lev — pegged at a fixed rate of 1.9558 BGN per EUR — and the marketplace convention is to show both. If you are building a pricing model or running arbitrage across EU markets, you need both currency fields in your dataset.

Cars.bg is Bulgaria's largest automotive marketplace with no public API and no structured data export. Scraping it is not trivial: the site uses a modern JavaScript frontend with an internal API, and its detail pages are guarded more aggressively than the listing cards — requiring residential proxy rotation and careful session management to retrieve reliably.

This guide covers how to pull Cars.bg data programmatically using the Cars.bg Bulgaria Car Scraper, a managed Apify Actor that handles the infrastructure.

Does Cars.bg Have an API? 🔎

No. Cars.bg offers no developer API, no data export, and no documented structured feed. The site's listing data is rendered via an internal API that the frontend calls with session-scoped parameters — not something you can call stably from external code.

One important distinction from other scrapers in this fleet: Cars.bg's detail pages are guarded more aggressively than its listing cards. With the default enrichment-off setting, you can pull make, model, year, price (EUR + BGN), mileage, fuel type, location, seller type, and photos from listing cards alone — which is the fastest and most reliable path. Detail-page enrichment (gearbox, body type, engine spec, colour, full description) is available but requires a larger proxy pool to avoid rate-limiting.

What Data You Can Extract

The Actor returns one row per listing. Fields from the listing card are always present (enrichment off is the default). Fields marked "enrichment-only" require enrichDetails: true.

Field	Description
`listing_id`	Cars.bg listing reference ID
`listing_url`	Absolute URL to the listing detail page
`title`	Make + model from listing title
`make`	Manufacturer (e.g. Mazda)
`model`	Model (e.g. 6)
`year`	Manufacture year
`price`	Integer price in EUR
`currency`	Always `EUR`
`price_bgn`	Price in Bulgarian lev (BGN) as shown on the listing
`mileage_km`	Odometer in kilometres
`fuel_type`	Дизел / Бензин / Електрически (Bulgarian Cyrillic)
`transmission`	Автоматични / Ръчни скорости — enrichment-only
`engine_power_hp`	Horsepower (к.с.) — enrichment-only
`engine_size_cc`	Displacement in cc — enrichment-only
`body_type`	Комби / Седан / Джип, etc. — enrichment-only
`color`	Exterior colour — enrichment-only
`first_registration`	First-registration month/year, e.g. "Март 2009" — enrichment-only
`location`	Seller city
`seller_type`	`dealer` or `private`
`seller_name`	Seller display name — enrichment-only
`photo_urls`	List of photo URLs
`description`	Free-text seller description — enrichment-only
`posted_date`	Relative posting time from listing card (e.g. "днес, 01:44")
`scraped_at`	ISO-8601 UTC timestamp of scrape

A note on language: Cars.bg is a Bulgarian-language site. Fuel type, gearbox, and body type values are in Bulgarian Cyrillic. The Actor maps all field names to English column names — your schema is consistent — but the values are preserved as-is. Дизел stays Дизел. This is correct behaviour: silent translation introduces errors for uncommon values.

A Realistic Output Row

Here is a sample result using the exact field names from the Actor's Pydantic ResultRow model, with enrichment enabled:

{
  "listing_id": "68eb6bba3c8c0e169c027093",
  "listing_url": "https://www.cars.bg/offer/68eb6bba3c8c0e169c027093",
  "title": "Mazda 6 2,2MZR-CD",
  "make": "Mazda",
  "model": "6 2,2MZR-CD",
  "year": 2009,
  "price": 2850,
  "currency": "EUR",
  "price_bgn": 5574,
  "mileage_km": 308000,
  "fuel_type": "Дизел",
  "transmission": "Ръчни скорости",
  "engine_power_hp": 185,
  "engine_size_cc": 2200,
  "body_type": "Комби",
  "color": "Светло сив металик",
  "first_registration": "Март 2009",
  "location": "Монтана",
  "region": null,
  "seller_type": "private",
  "seller_name": "Aleksandr",
  "photo_urls": ["https://g1-bg.cars.bg/2025-10-12_1/68eb68ec14f9749b22054f64b.jpg"],
  "description": "Продавам Mazda 6 комби (GH), 2009 г. ...",
  "posted_date": "днес, 01:44",
  "scraped_at": "2026-06-02T10:00:00+00:00"
}

Notice both price (2,850 EUR) and price_bgn (5,574 BGN) — both come directly from the listing card, so they are available even without detail enrichment.

How We Handle the Blocks

Cars.bg is a modern JavaScript marketplace. Its listing cards and detail pages behave differently under automated traffic — the site's defences are more aggressive on detail pages than on search results. Here is what the Actor does:

Browser fingerprint rotation. We use curl-cffi to impersonate real Chrome, Firefox, and Safari TLS handshakes. The server sees a browser, not Python.
Residential proxy rotation via Apify Proxy. We rotate residential exit IPs and fresh session IDs on every block signal. Datacenter IPs are a reliable path to a 403 on Cars.bg detail pages.
Exponential backoff with Retry-After. We retry on 408, 429, and 5xx — up to five attempts per page, honouring the server's own Retry-After header.
Rate-limit-aware pacing. When the target slows us, we match its pace rather than pushing through.
Loud failure, never silent. A hard block produces a non-zero exit with a descriptive status message. Empty datasets with green statuses are not acceptable.

The default configuration has enrichDetails: false — not because the detail pages are off-limits, but because detail enrichment requires a larger proxy pool to run reliably, and we want the default run to succeed predictably.

Running It with Python 🐍

from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")

run = client.actor("DevilScrapes/carsbg-bulgaria-cars").call(
    run_input={
        "searchUrl": "https://www.cars.bg/carslist.php?subtype=1&brand=16",
        "maxResults": 200,
        "enrichDetails": False,
        "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"], "EUR /", item["price_bgn"], "BGN")

The searchUrl is optional. Leave it empty to scrape the default used-cars feed, or visit cars.bg, apply your filters (brand, body type, price band, year range), and paste the resulting URL. The Actor follows pagination from there.

Use Cases

EUR and BGN price analytics. Track asking prices in both currencies across the Bulgarian market. Since the lev is pegged to the euro, the BGN field is a sanity check for data quality rather than a currency risk surface — but having both is useful when joining against Bulgarian financial data sources that use one or the other.

Cross-border EU arbitrage. Bulgaria is one of the more affordable used-car markets in the EU. Compare Cars.bg EUR prices against German, French, or Romanian equivalents to identify import opportunities. The mileage_km field is already normalised to kilometres across the fleet.

Dealer intelligence. Filter by seller_type = dealer and location to track inventory in specific Bulgarian cities. Sofia, Plovdiv, and Varna account for most of the dealer volume.

Market research. Aggregate fuel_type across the full dataset to measure diesel vs. petrol vs. electric adoption in the Bulgarian market — one of the later EU adopters of EV technology.

Lead generation. Build a directory of Bulgarian dealers from seller_name and location. Diff successive runs to score dealers by listing volume and price-cut frequency.

FAQ ❓

How much does it cost?

Should I enable detail enrichment?

With enrichDetails: false (the default), you get make, model, year, price (EUR + BGN), mileage, fuel type, location, seller type, and photos from the listing card alone. That is enough for most pricing and market research use cases. Enable enrichDetails: true to add gearbox, engine displacement, engine power, body type, colour, first-registration month, full description, and seller name — but note that Cars.bg guards detail pages more aggressively, so enrichment performs best on larger proxy tiers.

Is scraping Cars.bg legal?

Cars.bg'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 private user data.

What currency does Cars.bg use?

Cars.bg shows each price in both EUR and BGN. The price field is the integer EUR amount and currency is always EUR. The price_bgn field carries the BGN amount shown alongside it on the listing card.

Get Started

The Actor is live on the Apify Store. Every new Apify account starts with $5 of free credit — enough for roughly 2,400 enriched listings or around 2,400 listing-card-only rows per dollar.

Cars.bg Bulgaria Car Scraper on Apify Store

Questions or edge cases? Use the Actor's Issues tab on Apify Console. We ship fixes weekly and read every report.

Built by Devil Scrapes — a fleet of opinionated public-data Actors. Honest pricing, real engineering, zero fine print.

How to Scrape Blocket.se Car Listings (Sweden) to JSON/CSV

Devil Scrapes — Sat, 13 Jun 2026 08:39:34 +0000

Quick answer: Blocket.se publishes no public car API, so the only way to get structured listings data is to scrape the public site. The Blocket Car Scraper on Apify handles browser fingerprint rotation, residential proxy rotation, Swedish-mil-to-km conversion, and retries for you — delivering clean typed rows at $2.05 per 1,000 results ($0.05 actor-start + $0.002 per result).

Sweden's used-car market is one of the most active in the Nordics. Blocket.se is the dominant classifieds platform in Sweden — tens of thousands of car listings at any moment, spanning everything from a 1999 Volvo V70 at 12,000 SEK to a freshly imported Tesla Model Y at market rate. If you want to track SEK prices by make and model, watch Sweden's fast-moving used-EV segment, or monitor a competitor's dealer inventory, Blocket is the data source you need.

The complication: Blocket.se publishes no public API, and its car search is rendered by a Next.js frontend backed by internal endpoints that resist naive HTTP clients. The site also reports odometer readings in the Swedish mile — mil — where 1 mil equals 10 kilometres, a unit convention that catches most data pipelines off guard the first time.

This guide covers how to pull Blocket.se car data programmatically, using the Blocket Car Scraper — a managed Apify Actor that handles both the anti-blocking layer and the mil-to-km normalisation.

Does Blocket.se Have an API? 🔎

No. Blocket.se is a consumer marketplace — it exposes no documented developer API and no data export for car listings. The site's internal search endpoint feeds the React frontend, but it uses session-based authentication and rate-limits aggressively. Any client you build against it will break without warning when Blocket rotates its internal API version or adds a new challenge layer.

The durable approach is a managed scraper that stays current with site changes, so your pipeline continues working when Blocket updates its frontend.

What Data You Can Extract

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

Field	Description
`listing_id`	Blocket ad ID
`listing_url`	Absolute URL to the listing
`title`	Make + model heading
`make`	Manufacturer, e.g. Volvo
`model`	Model, e.g. V70
`year`	Model year (Modellår)
`price`	Integer price in SEK
`currency`	Always `SEK`
`mileage_km`	Odometer in km (converted from Swedish mil)
`fuel_type`	Bensin / Diesel / El, etc. — enrichment-only
`transmission`	Manuell or Automat — enrichment-only
`engine_power_hp`	Metric horsepower (Effekt, Hk) — enrichment-only
`engine_size_cc`	Displacement in cc — enrichment-only
`body_type`	Kombi / Sedan / SUV, etc. — enrichment-only
`color`	Exterior colour (Färg) — enrichment-only
`first_registration`	Registration date YYYY-MM-DD — enrichment-only
`location`	Seller location (Bilens plats) — enrichment-only
`drivetrain`	Framhjulsdrift / Fyrhjulsdrift, etc. — enrichment-only
`num_owners`	Number of previous owners (Antal ägare) — enrichment-only
`seller_type`	`dealer` (Handlare) or `private` (Privatperson)
`seller_name`	Dealer trading name — enrichment-only
`photo_urls`	List of photo URLs
`description`	Short trim/equipment line
`posted_date`	Listing publication date
`scraped_at`	ISO-8601 UTC timestamp of scrape

Note the num_owners field — Blocket surfaces previous-owner count on detail pages, which is genuinely useful for pricing models that discount high-ownership cars.

A Realistic Output Row

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

{
  "listing_id": "23740311",
  "listing_url": "https://www.blocket.se/mobility/item/23740311",
  "title": "Volvo V70",
  "make": "Volvo",
  "model": "V70",
  "year": 2000,
  "price": 12000,
  "currency": "SEK",
  "mileage_km": 238000,
  "fuel_type": "Bensin",
  "transmission": "Manuell",
  "engine_power_hp": 140,
  "engine_size_cc": 2400,
  "body_type": "Kombi",
  "color": "Grå",
  "first_registration": "1999-11-04",
  "location": "Sverige",
  "drivetrain": "Framhjulsdrift",
  "num_owners": 4,
  "seller_type": "private",
  "seller_name": null,
  "photo_urls": [
    "https://images.blocketcdn.se/dynamic/default/item/23740311/0c453750-654c-488c-878e-7d50af9966be"
  ],
  "description": "2.4 Manuell",
  "posted_date": null,
  "scraped_at": "2026-06-02T00:00:00+00:00"
}

The mileage_km value of 238,000 came from a listing that showed "23 800 mil" — the Actor converted it. Without that conversion, a pipeline that compares Swedish listings against German or Irish equivalents would see odometer values that are an order of magnitude off.

How We Handle the Blocks

Blocket.se's car search is served by a Next.js frontend that calls internal authenticated endpoints. A plain HTTP client hitting those endpoints gets refused. Here is what the Actor does instead:

Browser fingerprint rotation. We use curl-cffi to impersonate real Chrome, Firefox, and Safari TLS handshakes — the complete ClientHello, ALPN extension order, and HTTP/2 SETTINGS frame. The target sees browser traffic, not Python.
Residential proxy rotation via Apify Proxy. We rotate residential exit IPs on every block. Swedish residential exits are preferred for this target.
Exponential backoff with Retry-After. We retry on 408, 429, and 5xx — up to five attempts per page, doubling the wait each time and honouring Retry-After headers.
Rate-limit-aware pacing. When Blocket pushes back, we slow down instead of accelerating into a ban.
Loud failure, never silent. A hard block produces a non-zero exit and a descriptive status message — never 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/blocket-sweden-cars").call(
    run_input={
        "query": "volvo v70",
        "maxResults": 200,
        "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"], "SEK",
          item["mileage_km"], "km")

Three ways to target your search:

query — free-text, maps to Blocket's q parameter (e.g. "volvo v70 kombi").
make — convenience filter for a single brand (e.g. "Volvo").
searchUrl — paste a full Blocket search URL with filters already applied. The URL wins if all three are set.

Use Cases

SEK price analytics. Track how asking prices for a make/model/year combo move over time in the Swedish market. Sweden's used-car market is liquid enough that weekly runs produce meaningful price series.

EV market tracking. Filter by fuel_type = El to chart used-EV pricing in Sweden, which is one of Europe's most mature EV markets. The engine_power_hp and year fields let you segment by generation.

Dealer inventory monitoring. Filter by seller_type = dealer and watch stock turnover at specific dealers by seller_name. Diff successive runs to catch new arrivals and price cuts before competitors.

Ownership-based pricing models. The num_owners field is rare in European marketplace scrapers. Build models that discount price by ownership count for a given make/model/mileage bucket.

Cross-Nordic arbitrage. Compare Blocket (SEK) prices against Norwegian Finn.no (NOK) or Danish DBA (DKK) equivalents. The km-normalised mileage_km field makes cross-market comparison straightforward.

FAQ ❓

How much does it cost?

Why does Blocket show "mil" but the Actor returns "km"?

The Swedish mile (mil) is 10 kilometres — different from the international mile (1.6 km). The Actor converts for you: a listing showing "23 800 mil" becomes 238000 in mileage_km, consistent with every other market in the Devil Scrapes automotive fleet.

Is scraping Blocket.se legal?

Blocket's terms restrict automated data collection. 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, access private messages, or scrape seller phone numbers.

How do I get mileage, gearbox, and engine power?

Those fields live on each car's detail page. Keep enrichDetails: true (the default) to fill them in; set it to false to halve the request count and get just make, model, year, price, and photos from the search payload.

Get Started

The Actor is live on the Apify Store. Every new Apify account starts with $5 of free credit — enough for roughly 2,400 enriched listings.

Blocket Car Scraper on Apify Store

Questions or edge cases? Use the Actor's Issues tab on Apify Console. We ship fixes weekly.

Built by Devil Scrapes — a fleet of opinionated public-data Actors. Honest pricing, real engineering, zero fine print.

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

Devil Scrapes — Sat, 13 Jun 2026 08:34:18 +0000

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?

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.

Get Started

The Actor is live on the Apify Store. Every new Apify account starts with $5 of free credit — enough for roughly 2,400 enriched listings.

Bilasolur Iceland Car Scraper on Apify Store

Questions or edge cases? Open an issue on the Actor's Issues tab on Apify Console.

Built by Devil Scrapes — a fleet of opinionated public-data Actors. Honest pricing, real engineering, zero fine print.

How to Scrape Autovit.ro Car Listings (Romania) to JSON/CSV

Devil Scrapes — Sat, 13 Jun 2026 08:29:03 +0000

Quick answer: Autovit.ro publishes no public API, so the only way to get structured used-car data is to scrape the public listings. The Autovit Romania Car Scraper on Apify handles browser fingerprint rotation, residential proxy session rotation, and retry logic for you, returning clean typed rows at $2.05 per 1,000 results ($0.05 actor-start + $0.002 per result).

Romania's used-car market runs on autovit.ro. The site is part of the Adevinta/OLX group — the same engine that powers OTOMOTO in Poland and Standvirtual in Portugal — and it moves serious volume: tens of thousands of listings at any moment, priced in both EUR and RON. If you want to track asking prices, monitor dealer inventory, or build an arbitrage pipeline across the Romanian market, you need that data in a format your code can actually work with.

The problem is that autovit.ro guards its listings behind DataDome, a commercial anti-bot stack that blocks naive HTTP clients almost immediately. Getting past it requires rotating real browser TLS fingerprints, using residential exit IPs, and backing off gracefully when the target pushes back. That's before you even think about pagination.

This guide walks you through exactly how to pull autovit.ro data programmatically, using the Autovit Romania Car Scraper — a managed Apify Actor that does the infrastructure work so you can focus on the data.

Does Autovit.ro Have an API? 🔎

No. Autovit.ro offers no developer API, no data export, and no structured feed. The listing data lives in HTML pages and in embedded JSON-LD payloads — both behind DataDome protection. There is also an internal API the site's Next.js frontend calls, but it requires authenticated sessions and rotates its challenge parameters regularly, which means any direct client you build against it breaks without warning.

The practical path is a managed scraper that stays current with the site's anti-bot countermeasures, so your pipeline keeps running when the site updates its defences.

What Data You Can Extract

Each listing on autovit.ro carries a rich spec sheet. The Actor surfaces every field that appears consistently across listings:

Field	Description
`listing_id`	Autovit advert ID
`listing_url`	Absolute URL to the listing
`title`	Make + model + version headline
`make`	Manufacturer (e.g. BMW, Dacia, Volkswagen)
`model`	Model name (e.g. Logan, Range Rover Sport)
`version`	Trim / engine spec line
`year`	Production year (Anul producției)
`price`	Integer price in listing currency
`currency`	EUR or RON
`mileage_km`	Odometer in kilometres
`fuel_type`	Benzina / Diesel / Hibrid / Electric
`gearbox`	Manuala / Automata (detail page)
`transmission`	Drivetrain, e.g. 4x4 (automat) (detail page)
`engine_power_hp`	Power in horsepower (CP)
`engine_size_cc`	Displacement in cc
`body_type`	SUV / Berlina / Break, etc. (detail page)
`color`	Exterior colour in Romanian (detail page)
`location`	City
`region`	Romanian county / judet
`seller_type`	`private` or `dealer`
`seller_name`	Dealer name when present
`photo_urls`	List of photo URLs
`description`	Full Romanian listing text (detail page)
`posted_date`	ISO timestamp of listing creation
`scraped_at`	ISO timestamp of scrape

Fields marked "detail page" are populated only when enrichDetails is enabled. Price, make/model, year, mileage, fuel, power, and seller all come from the search payload — you can skip enrichment to halve requests if those are enough.

A Realistic Output Row

Here is what a single result looks like as JSON, using the exact field names from the Actor's Pydantic ResultRow model:

{
  "listing_id": "7058024533",
  "listing_url": "https://www.autovit.ro/autoturisme/anunt/land-rover-range-rover-sport-ID7HEKBn.html",
  "title": "Land Rover Range Rover Sport 4.4 V8 P635 MHEV SV Black",
  "make": "Land Rover",
  "model": "Range Rover Sport",
  "version": "4.4 V8 P635 MHEV SV Black",
  "year": 2026,
  "price": 187737,
  "currency": "EUR",
  "mileage_km": 1,
  "fuel_type": "Benzina",
  "gearbox": "Automata",
  "transmission": "4x4 (automat)",
  "engine_power_hp": 635,
  "engine_size_cc": 4395,
  "body_type": "SUV",
  "color": "Negru",
  "location": "Pitesti",
  "region": "Arges",
  "seller_type": "dealer",
  "seller_name": "BRIT Motor AG - RANGE ROVER | DEFENDER | DISCOVERY",
  "photo_urls": ["https://ireland.apollo.olxcdn.com/v1/files/.../image"],
  "description": "Range Rover Sport 4.4 V8 635 CP AWD Auto MHEV SV Black ...",
  "posted_date": "2026-06-01T17:30:53Z",
  "scraped_at": "2026-06-02T00:00:00+00:00"
}

Notice currency can be either EUR or RON — autovit.ro allows sellers to list in both, and the Actor reads each listing's own currency code rather than assuming one.

How We Handle the Blocks

Autovit.ro is fronted by DataDome. A plain requests.get() call gets a challenge page almost immediately. Here is what the Actor does so you don't have to:

Browser fingerprint rotation. We use curl-cffi to impersonate real Chrome, Firefox, and Safari TLS handshakes — the full ClientHello, ALPN extension order, and HTTP/2 SETTINGS frame. The target sees a real browser, not Python.
Residential proxy rotation via Apify Proxy. On every block signal we request a fresh session_id and a new residential exit IP. Datacenter IPs are a fast path to a ban on DataDome targets.
Exponential backoff with Retry-After. We retry on 408, 429, and 5xx — up to five attempts per page, doubling the wait each time and honouring the server's own Retry-After header.
Rate-limit-aware pacing. When the target pushes back, we slow down rather than hammering until banned.
Loud failure, never silent. If we hit a hard ban, the Actor exits non-zero with a clear status message. You never get an empty dataset with a green status.

Running It with Python 🐍

Install the Apify client and run the Actor programmatically:

from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")

run = client.actor("DevilScrapes/autovit-romania-cars").call(
    run_input={
        "searchUrl": "https://www.autovit.ro/autoturisme/bmw",
        "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"], item["currency"])

The searchUrl is just the autovit.ro results URL with your filters already applied. Open autovit.ro in a browser, set your filters (make, model, price band, mileage range), and copy the URL from the address bar — the Actor walks pagination from there.

Use Cases

Used-car price analytics. Build a time series of asking prices for a specific make/model/year combination. Run the Actor daily, push results to a database, and chart the market. Romanian sellers list in both EUR and RON; the currency + price fields let you normalise to whichever you prefer.

Dealer inventory monitoring. Filter by seller_type = dealer and a specific seller_name. Diff successive runs to catch new arrivals and price cuts before competitors do.

Market research. Aggregate fuel_type and gearbox across the full Romanian market to measure EV, hybrid, and automatic transmission adoption over time.

Lead generation. Build a directory of Romanian car dealers from seller_name + location + region. Cross-reference with runs over time to score dealers by listing volume.

Arbitrage and sourcing. Apply tight filters — low mileage, specific power band, narrow year range — and run daily. Surface underpriced listings the moment they appear.

FAQ ❓

How much does it cost?

Is scraping autovit.ro legal?

Autovit.ro's ToS restricts automated access to the site. You are responsible for ensuring your use complies with applicable law and the site's terms. The Actor scrapes only public listing data that is visible to any unauthenticated browser. We do not bypass authentication, access private user data, or circumvent any paywall.

How often should I run it?

Autovit.ro listing data changes daily. For price-tracking use cases, a daily run is sufficient. For "new listing" alerts you can run every few hours. Apify lets you schedule runs via the Console or the API.

What if listings stop appearing?

DataDome updates its challenge logic periodically. If a run returns fewer results than expected, check the run log — the Actor will have logged the HTTP status codes and retry attempts. We ship updates to keep pace with site changes; subscribe to Actor release notes on Apify to get notified.

Get Started

The Actor is live on the Apify Store. Every new Apify account starts with $5 of free credit — enough for roughly 2,400 enriched listings at the PPE rates above.

Autovit Romania Car Scraper on Apify Store

Questions or edge cases? Use the Actor's Issues tab on Apify Console. The devil's in the data — we read every report.

Built by Devil Scrapes — a fleet of opinionated public-data Actors. Honest pricing, real engineering, zero fine print.

How to Scrape AutoScout24.de Car Listings (Germany) to JSON/CSV

Devil Scrapes — Sat, 13 Jun 2026 08:23:47 +0000

Quick answer: AutoScout24.de publishes no public API. Use the AutoScout24 Germany Car Scraper on Apify to extract make, model, version, price in EUR, mileage, first registration, fuel type, transmission, power, body type, colour, dealer name and phone, geo-coordinates, and photos from any AutoScout24 search — no account needed. Results land in a clean JSON or CSV dataset within minutes.

Germany is the largest used-car market in the European Union by volume, and AutoScout24.de is where the bulk of that inventory lives. The platform carries hundreds of thousands of active listings from dealers and private sellers across every German postcode. If you need structured pricing data for the German market — for competitive intelligence, depreciation modelling, dealer lead generation, or cross-border arbitrage with Austria or Poland — AutoScout24 is the source. And it offers no public API.

Does AutoScout24.de have an API? 🔎

No. AutoScout24 does not offer a public data API. The platform serves its listing data through a Next.js frontend that embeds structured JSON in __NEXT_DATA__ script tags — a richer extraction target than raw HTML, but still behind active bot defences. AutoScout24 fingerprints TLS handshakes, monitors request rates, and returns degraded or blocked responses to traffic it identifies as non-browser.

We handle this. The Actor uses curl-cffi to impersonate real Chrome, Firefox, and Safari TLS handshakes — the site sees a browser, not Python. Every request routes through Apify's residential proxy pool, with a fresh session_id and exit IP on every block. Retries use exponential backoff with a 30-second cap and honour Retry-After headers. The __NEXT_DATA__ payload is parsed directly, giving structured data without fragile CSS selectors.

What data does the scraper return? 📤

One row per listing, validated by the ResultRow Pydantic model before it touches your dataset. AutoScout24's data model is notably rich — it includes model version/trim, postal code, geo-coordinates, and dealer phone number:

{
  "listing_id": "a15406b4-db66-4cb0-8e5d-1b74d162144a",
  "listing_url": "https://www.autoscout24.de/angebote/opel-corsa-d-1-4-color-edition-einparkhilfe-export-benzin-weiss-cat_ma54mo1918-a15406b4-db66-4cb0-8e5d-1b74d162144a",
  "title": "Opel Corsa D 1.4 Color Edition Einparkhilfe EXPORT",
  "make": "Opel",
  "model": "Corsa",
  "version": "D 1.4 Color Edition Einparkhilfe EXPORT",
  "year": 2013,
  "price": 3490,
  "currency": "EUR",
  "mileage_km": 101125,
  "fuel_type": "Benzin",
  "transmission": "Schaltgetriebe",
  "engine_power_hp": 101,
  "engine_power_kw": 74,
  "engine_size_cc": 1398,
  "body_type": "Limousine",
  "color": "Weiß",
  "first_registration": "07/2013",
  "location": "Bad Dürkheim",
  "postcode": "67098",
  "latitude": 49.46323,
  "longitude": 8.18632,
  "seller_type": "dealer",
  "seller_name": "Autohaus Schläfer GmbH",
  "seller_phone": "+49 (0)6322 - 943344",
  "photo_urls": [
    "https://prod.pictures.autoscout24.net/listing-images/a15406b4-..._...jpg/1280x960.webp"
  ],
  "description": null,
  "posted_date": "2026-06-01T12:21:47.636Z",
  "scraped_at": "2026-06-02T10:00:00+00:00"
}

Full field list: listing_id, listing_url, title, make, model, version, year, price, currency, mileage_km, fuel_type, transmission, engine_power_hp, engine_power_kw, engine_size_cc, body_type, color, first_registration, location, postcode, latitude, longitude, seller_type, seller_name, seller_phone, photo_urls, description, posted_date, scraped_at.

Notable extras compared to other EU marketplaces: version captures the trim line (e.g. "D 1.4 Color Edition"), postcode gives German PLZ for postcode-level geographic analysis, and latitude/longitude (enrichment-only) enable map-based dealer clustering. seller_phone is available when the dealer publishes it — useful for building a German dealer directory.

Enable enrichDetails for full description, body type, colour, engine displacement, geo-coordinates, and full-resolution photos. Disable it to halve requests when the search-page fields are sufficient.

How to run it with Python 🐍

Install the Apify client:

pip install apify-client

Pass a make/model filter, or paste any AutoScout24 search URL with your filters pre-applied:

from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")

run = client.actor("DevilScrapes/autoscout24-germany-cars").call(
    run_input={
        "make": "volkswagen",
        "model": "golf",
        "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.get("version"),
        item["year"], item["price"], "EUR",
        item.get("mileage_km"), "km",
        item.get("seller_name")
    )

For complex filters — price range, year band, fuel type, body type, radius from a city — build the search on autoscout24.de and paste the resulting URL into searchUrl instead of using the make/model shortcuts.

What can you build with German used-car data? 💡

Price analytics for the EU's largest market. Germany sets pricing benchmarks for the broader EU secondhand market. Tracking asking prices by make, model, year, and trim on AutoScout24.de gives you the most liquid price signal in continental Europe.

Dealer lead generation. seller_type == "dealer" combined with seller_name, seller_phone, location, and postcode gives you a structured directory of German car dealers, partitioned by geography. The latitude/longitude fields enable radius-based filtering in post-processing.

Depreciation modelling. Pair price, mileage_km, first_registration, and year for a model series (e.g. all Volkswagen Golf VII variants) to fit depreciation curves. AutoScout24's depth of inventory — particularly for German mainstream brands — makes curve-fitting statistically robust.

Cross-border arbitrage. Germany's large dealer network means well-specified cars are often priced lower there than in adjacent markets (Austria, Netherlands, Poland). Comparing AutoScout24.de prices against local equivalents — accounting for re-registration costs — is a standard workflow for professional car importers.

Inventory monitoring. Run the Actor daily filtered to a specific dealer (by seller_name or a dealer's profile URL as searchUrl). Diff listing_id sets between runs to catch new stock arrivals and price reductions.

How much does it cost? 💰

Pay-Per-Event pricing — charges fire only when results land in your dataset:

Event	Price
`actor-start` (once per run)	$0.05
`result-row` (per listing)	$0.002

1,000 listings costs $2.05 ($0.05 start + 1,000 × $0.002). No results, no result-row charges. New Apify accounts receive $5 of free credit; no credit card required to start.

FAQ ❓

Is scraping AutoScout24.de legal?

The Actor accesses only data visible to any anonymous visitor without logging in. AutoScout24 has no public API, so web access is the only route. The legality of web scraping varies by jurisdiction; consult legal counsel before commercial use. See the Terms of Service notice on the Store listing.

AutoScout24 caps search results at ~400 pages — how do I get more data?

AutoScout24's own search UI caps any query at approximately 400 pages (roughly 8,000 results). To collect larger datasets, split your target into narrower filter slices — by year range, price band, body type, or German state (Bundesland) — and run the Actor once per slice.

What does detail enrichment add?

With enrichDetails: true, the Actor fetches each listing's detail page to add: description, body_type, color, engine_size_cc, latitude, longitude, and full-resolution photo_urls. Without enrichment you still get make, model, version, year, price, mileage, fuel, transmission, power, location, postcode, seller name, phone, and a photo from the search payload.

What if AutoScout24 blocks a request?

We rotate TLS fingerprints across Chrome, Firefox, and Safari profiles, rotate residential proxy exits, and retry with exponential backoff. If a page fails after 5 attempts, the run fails loudly with a clear status message — you see exactly what happened, not a silent empty dataset.

Are prices inclusive of VAT?

AutoScout24 displays the asking price as listed by the dealer or private seller. For dealer listings this is typically the gross (VAT-inclusive) price; for exports it may be marked as net. The version field often carries clues (e.g. "EXPORT" in the title). We return the price exactly as shown — no VAT adjustment.

Get started

The AutoScout24 Germany Car Scraper is live on the Apify Store. Try it free — $5 of Apify starter credit, no credit card, and results in minutes.

Store link: https://apify.com/DevilScrapes/autoscout24-germany-cars

Built by Devil Scrapes — a fleet of opinionated public-data Actors. Honest pricing, real engineering, zero fine print.

Further reading:

How to Scrape AUTO.RIA Ukraine Car Listings to JSON/CSV

Devil Scrapes — Sat, 13 Jun 2026 08:18:32 +0000

Quick answer: AUTO.RIA (auto.ria.com) carries around 300,000 live used-car ads and is Ukraine's largest car marketplace. Use the AUTO.RIA Ukraine Car Scraper on Apify to extract price in USD or UAH, make, model, year, mileage, fuel type, transmission, engine, body type, colour, VIN, doors, location, seller type, and photos — no API key required. Output arrives as clean JSON or CSV.

When analysts, researchers, and developers need structured data on Ukraine's used-car market, AUTO.RIA is the authoritative source. With roughly 300,000 live ads at any given time, the platform captures a representative cross-section of vehicle supply, pricing, and regional distribution across every oblast. AUTO.RIA does offer a separate keyed developer API, but it carries access restrictions and a separate approval process. The public website is where the data actually lives — and where this Actor works.

Does AUTO.RIA have an API? 🔎

AUTO.RIA offers a separately keyed developer API that requires registration and approval. However, most of the rich listing data — seller descriptions, photo galleries, VIN, door count, exact engine specs — is only fully available through the public website. This Actor scrapes the public site, which means it accesses the same information any visitor sees: no developer key needed, no approval process, no per-endpoint quota tied to an API plan.

The site is not a pushover technically. It monitors request fingerprints and access patterns. We rotate Chrome, Firefox, and Safari TLS handshakes via curl-cffi impersonation, route through Apify Proxy with a fresh session_id on every block event, and back off with exponential delay before retrying. Up to 5 attempts per request before we fail loud rather than silently swallow the error.

What data does the scraper return? 📤

AUTO.RIA's data model is richer than most EU marketplace scrapers because listings include VIN numbers and dual-currency pricing. Every row is validated by the ResultRow Pydantic model before it lands in your dataset:

{
  "listing_id": "39954693",
  "listing_url": "https://auto.ria.com/uk/auto_volkswagen_tiguan_39954693.html",
  "title": "Volkswagen Tiguan 2011",
  "make": "Volkswagen",
  "model": "Tiguan",
  "year": 2011,
  "price": 12800,
  "currency": "USD",
  "price_uah": 565760,
  "mileage_km": 270000,
  "fuel_type": "Дизель",
  "transmission": "Автомат",
  "engine_size_cc": 1970,
  "engine_power_hp": null,
  "body_type": "Позашляховик / Кросовер",
  "color": "Білий",
  "vin": "WVGZZZ5NZBW559888",
  "doors": 5,
  "location": "Івано-Франківськ",
  "region": null,
  "seller_type": "private",
  "seller_name": "Надюша",
  "photo_urls": [
    "https://cdn0.riastatic.com/photosnew/auto/photo/volkswagen_tiguan__644750158s.webp"
  ],
  "description": null,
  "first_registration": null,
  "posted_date": null,
  "scraped_at": "2026-06-02T00:30:00+00:00"
}

The complete field list: listing_id, listing_url, title, make, model, year, price, currency, price_uah, mileage_km, fuel_type, transmission, engine_size_cc, engine_power_hp, body_type, color, vin, doors, location, region, seller_type, seller_name, photo_urls, description, first_registration, posted_date, scraped_at.

A few things worth noting about the data. AUTO.RIA quotes most cars in US dollars — currency reflects whatever the seller chose (USD, EUR, or UAH), and when the page also shows a hryvnia figure we surface it in the dedicated price_uah field. Ukrainian category values like Дизель (diesel), Автомат (automatic), and Позашляховик / Кросовер (SUV/crossover) are preserved as-is. VIN numbers appear on a meaningful subset of listings and are a direct data point for cross-referencing vehicle history.

How to run it with Python 🐍

Install the Apify client:

pip install apify-client

Run against AUTO.RIA's default used-car catalogue, or paste a filtered search URL:

from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")

run = client.actor("DevilScrapes/autoria-ukraine-cars").call(
    run_input={
        "categoryId": "1",
        "maxResults": 100,
        "enrichDetails": True,
        "proxyConfiguration": {
            "useApifyProxy": True
        }
    }
)

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"], item.get("currency"),
        item.get("mileage_km"), "km",
        item.get("vin")
    )

To target a specific make, model, region, or price range, build the search on auto.ria.com, copy the resulting URL, and pass it as searchUrl. The Actor forwards the URL's query parameters to AUTO.RIA's search backend so you get exactly the matching slice of the catalogue.

What can you build with Ukrainian used-car data? 💡

Price intelligence for USD-denominated markets. Most Ukrainian sellers quote in US dollars, making AUTO.RIA one of the few large EU-adjacent marketplaces where USD is the primary price unit. This is directly useful for analysts tracking USD/UAH exchange effects on vehicle affordability, or for comparing to other USD-denominated markets.

VIN-backed vehicle sourcing. AUTO.RIA listings frequently include VINs — a rarity on many European platforms. A VIN lets you query history databases (Carfax, AutoCheck, or Ukrainian equivalents) before committing to a cross-border purchase. Pull vin + price + mileage_km for a filtered model and you have a sourcing shortlist.

Dealer vs. private-seller segmentation. The seller_type field distinguishes dealer from private. Ukrainian dealer networks operate differently from Western European chains; this split enables separate analysis of professional inventory vs. private-sale dynamics.

Regional market analysis. The location and region fields map to Ukrainian cities and oblasts. Run the Actor filtered by city — Kyiv, Lviv, Odesa, Kharkiv — and compare price distributions to identify regional price differentials within the domestic market.

Import/export research. With ~300,000 live ads, AUTO.RIA is large enough for statistically meaningful segment analysis. Pair make, model, year, mileage_km, and price to identify models where the Ukrainian asking price (adjusted for import duties) creates an arbitrage window relative to Polish or German prices.

How much does it cost? 💰

Pay-Per-Event pricing — charges only fire when results land in your dataset:

Event	Price
`actor-start` (once per run)	$0.05
`result-row` (per listing)	$0.002

1,000 listings costs $2.05 ($0.05 start + 1,000 × $0.002). If a run returns nothing, only the $0.05 start fee applies. New Apify accounts get $5 of free credit; no credit card is needed to begin.

FAQ ❓

What currency is price in?

AUTO.RIA allows sellers to list in USD, EUR, or UAH. The currency field records whichever currency the seller chose. Where the page also shows a hryvnia equivalent, we surface it in price_uah. There is no automatic conversion to a fixed currency — the raw seller price is preserved exactly.

Can I scrape a filtered search?

Yes. Paste any AUTO.RIA results URL into searchUrl — its filter parameters (brand, model, price range, region, year, mileage) are forwarded to AUTO.RIA's search backend. The Actor then paginates that filtered result set up to your maxResults cap.

What is categoryId?

AUTO.RIA organises listings by vehicle category. Category 1 is passenger cars (the default). You can change it to target motorcycles, trucks, or other vehicle types that AUTO.RIA hosts.

Is scraping AUTO.RIA legal?

The Actor accesses only data visible to any anonymous visitor — no login, no gated content. AUTO.RIA has a separate developer API for programmatic access. Web scraping legality varies by jurisdiction; consult legal counsel before commercial use.

How far can I paginate?

AUTO.RIA lists around 300,000 used cars. The Actor's maxResults cap tops out at 1,000 per run. For larger pulls, run multiple times with different searchUrl filters (by region, make, or price band) to partition the catalogue into manageable slices.

Get started

The AUTO.RIA Ukraine Car Scraper is available on the Apify Store now. Start free — Apify's $5 credit covers your first few hundred enriched listings with no credit card required.

Store link: https://apify.com/DevilScrapes/autoria-ukraine-cars

Built by Devil Scrapes — a fleet of opinionated public-data Actors. Honest pricing, real engineering, zero fine print.

Further reading: