Pricing a used car correctly is a data problem before it is a sales problem. The same three-year-old Golf GTI can be listed at €24,900 on Mobile.de in Germany, €22,400 on AutoScout24 in France, and €21,000 by a private seller on Leboncoin, on the same day. And once the car is on your lot, reconditioning it depends on parts whose prices vary just as much: the same brake kit reference can cost 20% less on autodoc.pl than on auto-doc.fr.
Dealer groups, fleet buyers, and the automotive pricing platforms that serve them all need the same thing: a continuous, structured view of listings and parts prices across marketplaces and countries. Nobody gets that by refreshing search pages manually. It takes an automated collection pipeline built on reliable marketplace data.
This article walks through that pipeline, based on a production pattern from one of our customers (an automotive pricing intelligence platform we will not name), with concrete API calls on AutoScout24, Mobile.de, Leboncoin, and Autodoc.
The use case: a vehicle pricing platform for dealer groups
One of our customers builds pricing intelligence for car dealers and fleet operators. Their product answers three questions that every used-car professional asks daily:
- What is this car worth right now? Model-level market snapshots: live listing prices, mileage bands, days on market, per country.
- Where is it cheapest to source? Cross-border arbitrage alerts when the same model trades significantly below its home-market price in a neighboring country.
- What will it cost to recondition? A parts-cost index per model, fed by live prices from parts marketplaces, to turn a trade-in inspection sheet into a reconditioning budget.
Answering those questions requires collecting tens of thousands of listings per day from sites that are heavily protected, localized, and structurally different from one another. Rather than maintaining an in-house fleet of headless browsers, proxies, and per-site parsers, their platform runs collection through Piloterr's APIs. Three properties of the automotive web make this the right call:
- Every marketplace has a different shape. Mobile.de serves Next.js server components behind aggressive anti-bot rules; Leboncoin mixes dealer and private listings with its own protection; AutoScout24 spans a dozen European domains. One API layer normalizes all of it to JSON.
- Prices only make sense localized. A German search and a French search on the same model are different markets. The APIs preserve the locale, currency, and market context of every listing.
- Volume is daily, not one-shot. Days-on-market and price-drop detection require re-scanning the same searches every day and diffing results: an infrastructure workload, not a scripting one.
Anatomy of an automotive price monitoring pipeline
Discover Normalize Enrich Output
(search APIs) (unify fields) (ad APIs) (indexes + alerts)
│ │ │ │
model sweeps → price, mileage, → full specs, → market snapshot,
per market registration, equipment, arbitrage alerts,
currency seller type parts-cost index
Stage 1: discover listings with search endpoints
Everything starts with model-level sweeps per market. For each model in the catalog, the platform queries the search endpoint of every covered marketplace, in every relevant country.
On AutoScout24, you pass any search URL from any of its European domains: filters included. One call returns the listing cards with vehicle specs, pricing, and seller info:
curl -G "https://api.piloterr.com/v2/autoscout24/search" \
-H "x-api-key: YOUR-API-KEY" \
--data-urlencode "query=https://www.autoscout24.fr/lst/volkswagen/golf?atype=C"
Swap autoscout24.fr for autoscout24.de or autoscout24.it and you are sweeping another national market with the same integration.
On Mobile.de, the Search API accepts a full search URL or a make/model code, with a locale parameter covering 10 locales and a page parameter for pagination:
curl -G "https://api.piloterr.com/v2/mobile/search" \
-H "x-api-key: YOUR-API-KEY" \
--data-urlencode "query=https://www.mobile.de/fr/voiture/recherche.html?ms=20100&s=Car&vc=Car"
Each result card is already rich: price, currency, mileage, first_registration, fuel_type, power, transmission, location, plus price_rating: Mobile.de's own market assessment (GOOD_PRICE, etc.). Feeding that label into your own pricing model gives you a free calibration signal from the largest German marketplace.
On Leboncoin, the Search API takes any search or category URL and returns parsed listings. This is where the private-seller market lives, whose classified-ad prices systematically undercut dealer prices:
curl -G "https://api.piloterr.com/v2/leboncoin/search" \
-H "x-api-key: YOUR-API-KEY" \
--data-urlencode "query=https://www.leboncoin.fr/recherche?category=2&text=golf+gti"
Stage 2: normalize into one listing model
Three marketplaces means three schemas, three currencies, and three ways of writing "first registration 03/2023". The normalization layer maps everything onto a single record:
(marketplace, ad_id, observed_at) → { make, model, price, currency, mileage_km, first_registration, fuel, transmission, seller_type, location, url }
Two rules from production save the most pain:
- Keep the raw marketplace fields alongside the normalized ones. When a pricing anomaly shows up, you want to see exactly what the site displayed.
- A listing that disappears is a signal, not an error. Cars sell. The date a listing vanishes is what turns a price series into a days-on-market metric: the single best demand indicator in the used-car business.
Stage 3: enrich the shortlist with ad endpoints
Search cards are enough for market curves. For cars that a buyer is actually considering, the platform fetches the full listing via the ad endpoints: AutoScout24 Ad (full specs, equipment list, seller details), Mobile Ad (pricing, specs, images, features), and Leboncoin Ad (attributes, seller info, images):
curl -G "https://api.piloterr.com/v2/mobile/ad" \
-H "x-api-key: YOUR-API-KEY" \
--data-urlencode "query=https://www.mobile.de/fr/details.html?id=123456789"
The equipment list matters more than it looks: two Golfs with identical mileage can differ by thousands of euros because one has a trailer hitch and adaptive cruise control. Structured equipment data is what makes cross-listing comparison honest.
Stage 4: price the reconditioning with parts endpoints
A trade-in is only worth its resale price minus reconditioning costs. This is where parts marketplaces enter the pipeline.
The Autodoc Search API covers more than 30 national shops (autodoc.de, auto-doc.fr, autodoc.pl, autodoc.es, …) via the domain parameter. Each result includes price, original_price, discount, the manufacturer part reference, seller, and availability:
# Brake parts on the French shop
curl -G "https://api.piloterr.com/v2/autodoc/search" \
-H "x-api-key: YOUR-API-KEY" \
--data-urlencode "query=search?keyword=frein" \
--data-urlencode "domain=auto-doc.fr"
# Same sweep on the German shop: same references, different prices
curl -G "https://api.piloterr.com/v2/autodoc/search" \
-H "x-api-key: YOUR-API-KEY" \
--data-urlencode "query=search?keyword=bremsen" \
--data-urlencode "domain=autodoc.de"
The manufacturer reference field is the join key: it lets you compare the exact same part across country shops, and against other sources: Oscaro and Norauto for the French market, and Ovoko for used OEM parts, which often cut a reconditioning line item in half. Autodoc Product adds specs, EAN, and vehicle compatibility for the parts you track long-term.
A working Python example: one part, five countries
The script below searches the same part keyword across several Autodoc country shops, joins results on the manufacturer reference, and prints the cheapest shop per reference. It is deliberately minimal: in production you would persist snapshots, track availability, and convert currencies.
import requests
from collections import defaultdict
PILOTERR_API_KEY = "YOUR-API-KEY"
BASE = "https://api.piloterr.com/v2"
HEADERS = {"x-api-key": PILOTERR_API_KEY}
SHOPS = {
"auto-doc.fr": "frein",
"autodoc.de": "bremsen",
"autodoc.es": "freno",
"autodoc.pl": "hamulec",
"auto-doc.it": "freno",
}
def sweep_autodoc(domain: str, keyword: str) -> list[dict]:
r = requests.get(f"{BASE}/autodoc/search", headers=HEADERS,
params={"query": f"search?keyword={keyword}", "domain": domain},
timeout=60)
r.raise_for_status()
return [
{
"shop": domain,
"name": item["name"],
"reference": item.get("reference"),
"price": item.get("price"),
"original_price": item.get("original_price"),
"discount": item.get("discount"),
"availability": item.get("availability"),
"url": item.get("product_url"),
}
for item in r.json().get("results", [])
]
def main():
by_reference = defaultdict(list)
for domain, keyword in SHOPS.items():
for offer in sweep_autodoc(domain, keyword):
if offer["reference"] and offer["price"] is not None:
by_reference[offer["reference"]].append(offer)
multi_shop = {ref: offers for ref, offers in by_reference.items()
if len(offers) >= 2}
print(f"{len(by_reference)} references collected, "
f"{len(multi_shop)} available in 2+ shops\n")
for ref, offers in sorted(multi_shop.items()):
offers.sort(key=lambda offer: offer["price"])
best, worst = offers[0], offers[-1]
spread = (worst["price"] - best["price"]) / worst["price"] * 100
print(f"{ref} {best['name'][:50]}")
print(f" best: {best['price']} @ {best['shop']} "
f"worst: {worst['price']} @ {worst['shop']} "
f"spread: {spread:.0f}%\n")
if __name__ == "__main__":
main()
The same join-on-reference logic powers the car side of the pipeline: replace shops with marketplaces, references with normalized (make, model, year, mileage band) buckets, and the spread becomes a cross-border arbitrage alert.
Beyond listings: auctions, machinery, and the UK market
The same API-first approach extends past the core European marketplaces:
- Salvage and auctions: Copart exposes auction lots, which is how damaged-vehicle buyers and insurers price total-loss inventory.
- Trucks and machinery: Mascus covers used heavy equipment, tractors, and commercial vehicles.
- UK and US markets: Autotrader brings right-hand-drive and North American listings into the same pipeline.
- Rental benchmarks: AutoEurope adds rental price points, useful for mobility operators modeling fleet utilization.
Is scraping car marketplaces legal?
Vehicle listings are publicly displayed commercial offers, and price monitoring on public data is one of the most established scraping use cases: the same practice underpins every price comparison service. The usual principles apply: collect only public data, respect rate limits, and be careful with personal data in private-seller listings (store what the analysis needs, not the seller's phone number). For the broader framework, see our guide on the legality of web scraping.
In summary
Automotive price intelligence is a pipeline: discover with marketplace search APIs, normalize into one listing model, enrich the shortlist with ad endpoints, and price reconditioning with parts APIs joined on manufacturer references. The platforms that win are the ones whose market view is fresher than the dealer's gut feeling. For the cross-country mechanics of price gaps (currencies, asynchronous promotions, assortment), our multiregional price monitoring guide applies to car parts exactly as it does to consumer goods.
Piloterr provides the collection layer as an API: AutoScout24, Mobile.de, Leboncoin, Autodoc, Ovoko, Copart, and the rest of the 500-endpoint library, with anti-bot bypass and browser rendering handled for you. If you are building automotive pricing tools and want to evaluate the data quality on your own models, create a free account (+500 credits, no credit card) or talk to us about volume pricing and endpoints we can add for your use case.
