Web Scraping How to scrape a website

7 ways to scrape Mobile.de in 2026

Contributor Jamie Flubbon

The quickest way to scrape mobile.de skips HTML parsing entirely. The site's own front end loads search results from a JSON endpoint, and that endpoint accepts the same search URL you see in your address bar, filters and all. Set the make, price range, or first-registration year in your browser, copy the URL, and you already have a working query.

The JSON route is useful because the official API is closed to most people. mobile.de runs a Search API, a Seller API, and an Ad Stream API through services.mobile.de, but access is limited to registered dealers and software partners managing their own inventory.

If you want listings for market research, price tracking, or a personal car search, you need another way in.

Most pages ranking for this query sell that access as a hosted actor or a paid scraping API. This guide shows you how to build it yourself in about 200 lines of Python, so you decide which fields to keep, how often to run, and where the data ends up.

Two obstacles make mobile.de harder than most car sites:

  • Akamai Bot Manager sits in front of the HTML pages and blocks requests that don't look like a real browser, so plain HTTP clients get challenged or refused.
  • A 50-page cap on search results applies no matter how many cars match. A broad query quietly drops everything past that point, which skews any price or inventory analysis built on it.

Both have workarounds, and the methods below cover each one. If you've already worked through how to scrape AutoScout24, its main German rival, a lot of this will feel familiar.

How do you scrape mobile.de?

To scrape mobile.de, URL-encode the search URL from your browser and send it to the site's consumer search API at /consumer/api/search/srp?url=. The JSON holds price, specs, seller and mobile.de's price rating for each car. Pull descriptions and photos from the VIP endpoint, and split big searches by price to get past the 50-page cap.

Method What you call What you get Use it when
1. Search results /consumer/api/search/srp 20 to 30 listings per page with price, specs, seller, rating Any search you can click together on the site
2. Listing details /consumer/api/search/vip Description, equipment, full gallery, address, GPS You need more than the result card shows
3. Dealer stock Search with sid=<sellerId> Every car one seller has online Competitor or dealer monitoring
4. Market stats aggregations in any search Price and power percentiles, counts by fuel, body, gearbox You want the market, not the rows
5. Price bands priceRating on each card mobile.de's own fair-price range per car Valuation or deal-finding
6. Browser fallback fetch() inside Playwright Same JSON as Method 1 Plain HTTP gets 403 from Akamai
7. New-listing watch Sort sb=doc&od=down New cars and price changes since the last run Daily or hourly monitoring

Prerequisites

  • Python 3.10 or newer
  • pip install curl_cffi for Methods 1 to 5 and 7
  • pip install playwright and playwright install chromium for Method 6
  • A German IP helps, but my test calls from a US address went through (details in the blocking section)

The HTTP client is curl_cffi, which sends Chrome's TLS and HTTP/2 fingerprint instead of Python's. Akamai checks that layer before it reads a single header, and our curl_cffi guide explains the mechanics.

Every method shares one session:

import json
import random
import re
import time
from urllib.parse import urlencode
from curl_cffi import requests

BASE = "https://www.mobile.de"
session = requests.Session(impersonate="chrome")
session.headers.update({
    "Accept": "application/json",
    "Accept-Language": "de-DE,de;q=0.9,en;q=0.8",
    "x-mobile-client": "de.mobile.consumer-webapp",  # the web app's own client header
    "Referer": "https://www.mobile.de/",
})

The x-mobile-client value comes from the site itself. It shows up inside the API's own response, in an ad link that passes client.header.x-mobile-client=de.mobile.consumer-webapp/search.mweb.

My test call worked without it. Sending it costs nothing and keeps you looking like the web app if mobile.de starts enforcing it.

The fetch helper paces requests, tells an Akamai block apart from a rate limit, and refuses to hand you HTML pretending to be JSON:

class Blocked(Exception):
    pass

def get_json(path, **params):
    for attempt in range(4):
        resp = session.get(BASE + path, params=params, timeout=30)
        time.sleep(random.uniform(1.5, 3.0))  # roughly one request every 2 seconds
        if resp.status_code == 200 and "json" in resp.headers.get("content-type", ""):
            return resp.json()
        if resp.status_code == 403 or "Zugriff verweigert" in resp.text:
            raise Blocked(f"Akamai said no ({resp.status_code})")
        time.sleep(2 ** attempt * 5)  # 429 or 5xx: back off, then retry
    raise RuntimeError(f"No JSON from {path} (last status {resp.status_code})")

A 403 raises at once instead of retrying. Hammering Akamai after it has flagged you only extends the block, so Method 6 is the better next move.

Method 1: Pull search results from the consumer JSON API

/consumer/api/search/srp takes one parameter, url, holding the URL-encoded search page path. It returns the same data the results page renders: total matches, page count, and a list of listing cards.

When I called it on 5 November 2026 with a bare car search, it answered 200 with JSON, no cookies, and reported 1,593,238 cars across numPages: 50.

Filters use mobile.de's short query keys. The cleanest way to learn them is to set a filter on the site and read the address bar:

Key Meaning Example
ms Make and model IDs, ;-separated 1900;45 (Audi Q2, seen in the API's own links)
p Price range in euros, min:max 10000:15000, :20000
fr First registration year range 2018:
sb, od Sort field and direction sb=rel&od=up (default), sb=doc&od=down (newest)
sid Seller ID 18862256
pageNumber Result page, 1 to 50 2

urlencode handles the double encoding for you. The ; in ms becomes %3B inside the search path, then curl_cffi encodes that whole path again as the url parameter:

def search_url(**filters):
    """Build the path the website puts in your address bar."""
    query = {"isSearchRequest": "true", "s": "Car", "vc": "Car", **filters}
    return "/fahrzeuge/search.html?" + urlencode(query)

def srp(**filters):
    return get_json("/consumer/api/search/srp", url=search_url(**filters))

data = srp(ms="1900;45", fr="2018:", pageNumber=1)
results = data["searchResults"]
print(results["numResultsTotal"], "matches,", results["numPages"], "pages")
print(data["filters"])  # mobile.de echoes back the filters it understood

That last line is the cheapest bug check you'll get. If filters comes back holding only s, vc, sb and od, mobile.de dropped your filter and you're scraping all 1.5 million cars.

Flatten the item list before you parse it

searchResults.items isn't a clean list of cars. In the response I pulled, it mixed five shapes: topAd, ad and eyecatcherAd cards, plus two that aren't cars at the top level.

Ad slots typed inlineAdvertising carry no id, and a page1Ads group nests three more cars inside its own items.

Loop over it naively and you either crash on a missing id or silently lose the nested group:

def listings(items):
    """Yield real listings: drop ad slots, unpack the page1Ads group."""
    for item in items:
        if item.get("type") == "page1Ads":
            yield from listings(item.get("items", []))
        elif "id" in item:  # inlineAdvertising slots have no id
            yield item

def num(text):
    """'19.610 km' -> 19610, '110 kW (150 PS)' -> 110"""
    match = re.search(r"\d[\d.]*", text or "")
    return int(match.group().replace(".", "")) if match else None

German number formatting uses . for thousands, so float("19.610") gives you 19.6 km. The num() helper strips the dots and takes the first number, which is kW for power strings.

Each card carries its specs in a compact attr object with short keys.

fr is first registration, ml mileage, pw power, ft fuel, tr gearbox, and z the postcode:

def parse(item):
    attr, price = item.get("attr", {}), item.get("price", {})
    contact = item.get("contactInfo") or {}
    return {
        "id": item["id"], "title": item.get("title"),
        "make": item.get("make"), "model": item.get("model"),
        "price_eur": price.get("grossAmount"), "vat": price.get("vat"),
        "first_reg": attr.get("fr"), "mileage_km": num(attr.get("ml")),
        "power_kw": num(attr.get("pw")), "fuel": attr.get("ft"), "gearbox": attr.get("tr"),
        "zip": attr.get("z"), "city": attr.get("loc"), "country": attr.get("cn"),
        "seller_type": contact.get("sellerType"), "seller_id": item.get("sellerId"),
        "seller_name": contact.get("name"),  # None for private (FSBO) sellers
        "price_rating": (item.get("priceRating") or {}).get("rating"),
        "ad_type": item.get("type"),
        "url": BASE + item.get("relativeUrl", "").split("?")[0],
    }

The values in attr are German display strings ("Benzin", "Automatik", "Schaltgetriebe"). Map them to your own codes downstream instead of trusting the labels to stay stable.

price.vat only appears when a dealer shows VAT separately. That makes it a decent proxy for "dealer will issue an invoice with VAT", which matters to business buyers.

Paging is pageNumber=N until hasNextPage goes false. Paid placements repeat on every page, so dedupe on id as you go:

def crawl_search(max_pages=50, **filters):
    seen = set()
    for page in range(1, max_pages + 1):
        res = srp(pageNumber=page, **filters)["searchResults"]
        for item in listings(res.get("items", [])):
            if item["id"] not in seen:  # top ads come back on every page
                seen.add(item["id"])
                yield parse(item)
        if not res.get("hasNextPage"):
            break

rows = list(crawl_search(ms="1900;45", fr="2018:"))
print(len(rows), "unique listings")

IDs come in two lengths. Older listings carry nine-digit IDs like 426594111, newer ones fourteen digits like 54222711160800. Store them as 64-bit integers or strings, never as 32-bit ints.

Method 2: Fetch full listing details from the VIP endpoint

/consumer/api/search/vip takes the listing's details path in the same url wrapper and returns an ad object. It holds the seller's description, the equipment list, every gallery image, and labelled specs.

I called it for listing 54222711160800 on 5 November 2026. The top-level keys were ad, advertisingConfig, cookies, ratings and experimentVariations.

from html import unescape

def vip(listing_id):
    path = f"/fahrzeuge/details.html?id={listing_id}"
    return get_json("/consumer/api/search/vip", url=path)

def parse_vip(data):
    ad = data["ad"]
    contact = ad.get("contactInfo", {})
    text = re.sub(r"<[^>]+>", " ", ad.get("htmlDescription") or "")
    return {
        "description": " ".join(unescape(text).split()),
        "features": ad.get("features", []),
        "specs": {a.get("label"): a.get("value") for a in ad.get("attributes", [])},
        "images": [img["src"] for img in ad.get("galleryImages", []) if img.get("src")],
        "address": [contact.get("address1"), contact.get("address2")],
        "lat_lon": contact.get("latLong"),  # {"lat": ..., "lon": ...} for dealers
        "dealer_reviews": data.get("ratings", []),
    }

attributes is the full spec sheet with German labels such as "Kilometerstand". Keying the dict by label gives you every spec the seller filled in, including the odd ones the card skips.

The ratings block holds the dealer's reviews with a creationTime per review. I didn't find a created or modified date for the listing itself in this payload, so don't count on one.

Get bigger images by changing one parameter

mobile.de serves images from img.classistatic.de, and the size lives in a rule query parameter. The search cards I pulled listed mo-160w through mo-1024w in their srcSet:

def resize(url, rule="mo-1024w"):
    """Swap the size rule on a classistatic image URL."""
    if "rule=" in url:
        return re.sub(r"rule=[^&]+", f"rule={rule}", url)
    return url + ("&" if "?" in url else "?") + f"rule={rule}"

print(resize("https://img.classistatic.de/api/v1/mo-prod/images/fd/fd93941a?rule=mo-160w"))

That turns a 160-pixel thumbnail from Method 1 into a usable photo without calling the VIP endpoint at all.

Download images at the same pace as everything else; the CDN is still mobile.de's.

Method 3: Scrape a dealer's whole inventory with sid

Every listing card carries a sellerId, and the search accepts it back as sid. One search with sid=<sellerId> returns everything that seller has online.

I didn't guess this parameter. The first card in my test response had sellerId: 18862256 and a similarAdsLink ending in sid=18862256, so mobile.de's own front end builds dealer filters this way.

from collections import Counter

def dealer_inventory(seller_id, vehicle_class="Car"):
    return list(crawl_search(sid=seller_id, s=vehicle_class, vc=vehicle_class))

# Find the biggest dealers in a search, then pull each one's full stock
top_sellers = Counter(r["seller_id"] for r in rows if r["seller_type"] == "DEALER")
for seller_id, n in top_sellers.most_common(3):
    stock = dealer_inventory(seller_id)
    print(seller_id, n, "in this search,", len(stock), "in total")

s and vc override the defaults in search_url, so pass Motorbike or another class for dealers that don't sell cars. Mixed dealers need one call per class.

Dealer storefronts live at home.mobile.de/<SLUG>, but I didn't confirm where that page exposes the seller ID.

Finding one of the dealer's cars in a search and reading its sellerId is the dependable route.

Method 4: Read market statistics from aggregations without paging

Every search response includes an aggregations object with counts and percentiles computed over the whole result set, past page 50 too.

One request per segment gives you a market snapshot that would otherwise take 50 pages.

On the unfiltered car search I pulled, con split the 1,593,238 cars into 1,492,860 used and 100,410 new. The median price in p was 18,998 euros.

def percentiles(agg, key):
    return {float(k): round(float(v)) for d in agg.get(key, []) for k, v in d.items()}

def market_snapshot(**filters):
    data = srp(**filters)
    agg = data.get("aggregations", {})
    counts = lambda key: {d["key"]: d["count"] for d in agg.get(key, [])}
    return {
        "total": data["searchResults"]["numResultsTotal"],
        "price_eur": percentiles(agg, "p"),   # 1st, 5th, 25th, 50th, 75th, 95th, 99th
        "power_kw": percentiles(agg, "pw"),
        "condition": counts("con"), "gearbox": counts("tr"),
        "body": counts("c"), "colour": counts("ecol"),
    }

The percentile keys arrive as strings like "50.0" and in no fixed order, hence the conversion to floats. pw is in kW: the median of 109 converts to roughly 148 PS.

There's also a cnc series with values from 1.7 to 14.7. They look like fuel consumption in litres per 100 km, but I couldn't confirm that, so I leave it out.

Comparing segments is then a loop, one request each:

snapshots = {}
for fuel in ("PETROL", "DIESEL", "ELECTRICITY"):
    snapshots[fuel] = snap = market_snapshot(ms="1900;45", ft=fuel)
    print(fuel, snap["total"], "cars, median", snap["price_eur"].get(50.0), "EUR")

with open("audi_q2_by_fuel.json", "w", encoding="utf-8") as fh:
    json.dump(snapshots, fh, indent=2)

The fuel codes come from the filter values other scrapers pass, not from my own testing. Confirm them against the filters echo before you trust the totals.

Method 5: Extract mobile.de's own price bands for every car

Every card's priceRating holds six thresholdLabels, the boundaries of mobile.de's five price bands for that specific car. The rating codes are VERY_GOOD_PRICE, GOOD_PRICE, REASONABLE_PRICE, INCREASED_PRICE and HIGH_PRICE, plus NO_RATING.

That's mobile.de's valuation model, published per listing. The fair band is the third interval, between the third and fourth labels.

I checked that reading against five cards by hand. An Audi Q2 at 22,450 euros was rated VERY_GOOD_PRICE, and its first two bounds were 18.300 € and 23.800 €.

vehiclePriceOffset matched too. It's the car's position inside its band in percent: (22,450 − 18,300) / (23,800 − 18,300) is 75.5, and the field said 75.

BANDS = ["VERY_GOOD_PRICE", "GOOD_PRICE", "REASONABLE_PRICE", "INCREASED_PRICE", "HIGH_PRICE"]

def valuation(item):
    pr = item.get("priceRating") or {}
    bounds = [num(label) for label in pr.get("thresholdLabels", [])]
    if len(bounds) != 6 or None in bounds:
        return None
    return {
        "id": item["id"], "price_eur": (item.get("price") or {}).get("grossAmount"),
        "rating": pr.get("rating"),
        "fair_low": bounds[2], "fair_high": bounds[3],
        "fair_mid": (bounds[2] + bounds[3]) // 2,  # mobile.de's implied market value
        "bands": dict(zip(BANDS, zip(bounds, bounds[1:]))),
        "position_in_band_pct": pr.get("vehiclePriceOffset"),
        "kba": item.get("kba"),  # {"hsn": ..., "tsn": ...} type-approval codes
    }

valuation() works on raw items from listings(), not on parsed rows. Run it alongside parse() in the Method 1 loop.

Cars rated NO_RATING sometimes still carry the six labels. A Caddy in my sample did, so you get a valuation where the site shows none.

And kba holds the HSN and TSN codes from German vehicle registration papers. They identify the exact type variant, which beats fuzzy-matching titles like "Golf VII Lim. GTI Performance 2.HD|LEDER|ACC".

Method 6: Call the API from inside a real browser when Akamai blocks you

When plain HTTP gets a 403, open mobile.de in a real Chromium with Playwright, let Akamai's script run, then call the same JSON endpoint with fetch() from inside the page.

The request then carries the browser's own cookies, TLS fingerprint and headers, because the browser sends it.

from playwright.sync_api import sync_playwright
FETCH_JS = """async (u) => {
    const r = await fetch('/consumer/api/search/srp?url=' + encodeURIComponent(u),
        {headers: {'x-mobile-client': 'de.mobile.consumer-webapp'}});
    return r.ok ? await r.json() : {error: r.status};
}"""

def srp_in_browser(search_paths):
    with sync_playwright() as p:
        browser = p.chromium.launch(headless=False)  # headless is easier to spot
        ctx = browser.new_context(locale="de-DE", timezone_id="Europe/Berlin")
        page = ctx.new_page()
        page.goto("https://www.mobile.de/", wait_until="domcontentloaded")
        page.wait_for_timeout(5000)  # give Akamai's sensor script time to set cookies
        results = []
        for path in search_paths:
            results.append(page.evaluate(FETCH_JS, path))
            page.wait_for_timeout(random.randint(1500, 3000))
        browser.close()
        return results

Pass it the output of search_url(), as in srp_in_browser([search_url(ms="1900;45", pageNumber=n) for n in range(1, 4)]). Each result is the same dict Method 1 parses, so listings() and parse() work unchanged.

The fetch is same-origin, so it needs no CORS tricks. If a consent banner covers the page, the fetch still runs; you don't have to click it.

The other browser route is to click through the real search page and capture the JSON as it loads. Our guide to intercepting network traffic in Playwright covers page.on("response") for that.

Hand the browser's cookies back to curl_cffi

A browser per request is slow. Once a browser session has passed, you can copy its cookies into the curl_cffi session and continue over plain HTTP:

def cookies_to_session(ctx, user_agent):
    """Call inside srp_in_browser() before browser.close()."""
    for c in ctx.cookies():
        session.cookies.set(c["name"], c["value"], domain=c["domain"], path=c["path"])
    session.headers["User-Agent"] = user_agent  # must match the browser that earned the cookies

# inside srp_in_browser(): cookies_to_session(ctx, page.evaluate("navigator.userAgent"))

This works only while the rest of the fingerprint lines up. Use the same IP for both, and copy the browser's User-Agent along with the cookies, as the function does.

Akamai ties its cookie to more than the cookie value. Expect the handoff to last minutes, not days, and plan to refresh it.

Method 7: Watch for new listings and price changes

Sort the search by newest first with sb=doc&od=down, read pages until one brings nothing new, and compare prices against your last run.

A daily run on one model is then a handful of requests instead of 50 pages.

Store what you've seen in SQLite:

import sqlite3

db = sqlite3.connect("mobile_de.sqlite")
db.execute("""CREATE TABLE IF NOT EXISTS seen (
    id INTEGER PRIMARY KEY, price INTEGER, first_seen TEXT, last_seen TEXT)""")

Then the watcher yields an event per new car or price change:

def new_and_changed(max_pages=5, **filters):
    for page in range(1, max_pages + 1):
        res = srp(sb="doc", od="down", pageNumber=page, **filters)["searchResults"]
        organic_new = 0
        for item in listings(res.get("items", [])):
            row = parse(item)
            old = db.execute("SELECT price FROM seen WHERE id = ?", (row["id"],)).fetchone()
            if old is None:
                organic_new += item.get("type") == "ad"  # paid slots ignore the sort
                db.execute("INSERT INTO seen VALUES (?, ?, datetime('now'), datetime('now'))",
                           (row["id"], row["price_eur"]))
                yield "new", row
            else:
                db.execute("UPDATE seen SET last_seen = datetime('now'), price = ? WHERE id = ?",
                           (row["price_eur"], row["id"]))
                if old[0] != row["price_eur"]:
                    yield "price_change", {**row, "old_price": old[0]}
        db.commit()
        if not organic_new or not res.get("hasNextPage"):
            break

The stop rule counts only type == "ad" cards. Top ads and page-one ads stay pinned regardless of sort order, so they'd keep the loop alive forever if they counted.

last_seen gives you removals for free: anything unseen for two or three runs has most likely sold or expired.

Our guide to storing scraped data covers moving this from one SQLite file to something shared.

A price change only shows up if the car is still on the pages you read. Run Method 1 across the whole search once a week to catch the rest.

Get past the 50-page cap when you scrape mobile.de

A mobile.de search stops serving results at page 50, no matter what numResultsTotal reports. If you scrape mobile.de with one broad query, you get the first few thousand listings and nothing after them. My unfiltered test search reported 1,593,238 cars alongside numPages: 50. Everything past page 50 was unreachable from that query.

The workaround is to split one large search into many smaller ones, each small enough to fit under the cap, then merge the results.

Pick a safe slice size

Check numPages in the search response before you trust numResultsTotal. When numPages reads 50 and the total is far higher, the query is truncated.

The exact ceiling is fuzzy. Hosted scrapers quote anywhere from about 1,300 to 2,000 reachable results, and the page size moves too: a page holds 20 to 30 cards depending on the ad mix. At 20 cards, 50 pages is 1,000 listings, so I split until each slice holds 1,000 or fewer. That number stays under the cap even on a month when pages run small.

Split the search by price

Price is the best field to split on. It's continuous, so any range can be cut in half, and nearly every listing has one, so few cars fall outside the slices. The function below asks mobile.de how many cars sit in a price range, and if the count is over the limit, halves the range and tries again:

CAP = 1000  # stay well under 50 pages, whatever the page size is this month

def total(**filters):
    return srp(**filters)["searchResults"]["numResultsTotal"]

def price_slices(lo=0, hi=500_000, **filters):
    """Bisect [lo, hi] until each price range fits under CAP."""
    n = total(p=f"{lo}:{hi}", **filters)
    if n <= CAP or hi - lo < 100:
        if n > CAP:
            print(f"warning: {n} cars at {lo}-{hi} EUR, split this range on fr or ft too")
        yield lo, hi, n
        return
    mid = (lo + hi) // 2
    yield from price_slices(lo, mid, **filters)
    yield from price_slices(mid + 1, hi, **filters)

A few details matter here:

  • Using mid + 1 for the upper half keeps slices from overlapping, since prices are whole euros.
  • Bisection stops once a range is narrower than 100 euros. Popular price points can still hold more than 1,000 cars, and in that case the function prints a warning instead of looping forever. Split that range again on a second filter, such as fr or ft.
  • The default range ends at 500,000 euros. Cars priced above that need one extra slice with p="500001:".

Spend fewer requests on probing

Every probe through total() is one request, and blind halving wastes some on ranges that are obviously too wide. Method 4 shortens this. Read the price percentiles from the aggregations first, then cut at those points so most slices land near the target size on the first try.

Crawl every slice and dedupe

Once you have the slices, the full crawl walks each one and drops IDs it has already seen:

def crawl_everything(**filters):
    seen = set()
    for lo, hi, n in price_slices(**filters):
        for row in crawl_search(p=f"{lo}:{hi}", **filters):
            if row["id"] not in seen:
                seen.add(row["id"])
                yield row

golfs = list(crawl_everything(ms="25200;14"))  # ms for VW Golf: confirm in your address bar
print(len(golfs), "listings")

Keep the seen set across all slices, not one per slice. Top ads are paid placements and don't have to match your price filter, so the same promoted car can show up in every slice you crawl.

The ms value in the example is the make and model code for the VW Golf. Codes can change, so run the search in a browser and copy the value from the address bar before you rely on it.

Narrow the search before you crawl everything

Slicing makes the whole site reachable, but that doesn't make it a good target. All of mobile.de is about 1.6 million listings, and at a polite rate of one request every two seconds, fetching them is weeks of traffic. Start from the narrowest search that answers your question, such as one make and model or one region, and slice only that.

Which method gives you which field

Field Search JSON (1) VIP (2) Aggregations (4) Price bands (5)
Listing ID and URL Yes Yes No Yes
Price, gross and net Yes Yes Percentiles only Yes
Mileage, power, fuel, first registration Yes (attr) Yes (attributes) Power percentiles No
Description and equipment No Yes No No
All photos Preview only Yes No No
Seller name, phone, postcode Yes Yes, plus address and GPS No No
mobile.de price rating Code only Not checked No Code, bands, position
HSN/TSN type codes Yes, when present Not checked No Yes
Requests for 1,000 cars About 40 1,000 1 0 extra

The last row explains the order of this guide. Search JSON returns about 25 cars per request, while the VIP endpoint costs one request per car. Collect everything you can from search JSON first, and call the VIP endpoint only for the cars you need to read in full.

What blocks you when you scrape mobile.de?

Akamai Bot Manager blocks most mobile.de scrapers, judging your IP reputation, TLS fingerprint and request pattern before your headers.

Other scrapers report a 403 with a German "Zugriff verweigert" (access denied) page when they hit the HTML from datacenter IPs.

My own calls went through from a US address on 5 November 2026. That was a handful of requests, though, and Akamai's thresholds move, so build for the 403 instead of hoping.

What keeps you under the threshold, in order of payoff:

  • A browser TLS fingerprint. curl_cffi's impersonate="chrome" does this; plain requests gets flagged on the handshake.
  • A German residential or mobile IP, if a datacenter address starts drawing 403s.
  • Pacing: one request every two seconds per IP, with jitter, and no parallel bursts.
  • One session per IP, so the cookies Akamai sets stay with the address they were issued to.

Our Akamai bypass guide goes deeper on the sensor data and cookie checks if you need to scale beyond this.

The API also tells you where it thinks you are. advertisingConfig.gpt.page.targeting.geo came back as us|||37.751|-97.822 on my test call, a quick check that a proxy is exiting where you paid for:

def where_does_mobile_de_think_i_am():
    data = srp(pageNumber=1)
    targeting = data.get("advertisingConfig", {}).get("gpt", {}).get("page", {}).get("targeting", {})
    return targeting.get("geo", "").split("|")[0]  # "de", "us", ...

print(where_does_mobile_de_think_i_am())

Read the robots rules before you schedule anything. suchen.mobile.de/robots.txt disallows /consumer/api/, /fahrzeuge/search.html, /auto-inserat/ and any URL with pageNumber= for all crawlers.

On www.mobile.de, where the endpoint in this guide lives, robots.txt disallows /api/ and /consumer/next/api/search/count but not /consumer/api/search/srp. That's a crawler signal, not a licence, so keep volumes modest.

What you can't get from mobile.de

Sold prices aren't published anywhere. A listing disappears when the car sells, so Method 7's last_seen tells you when it went, not what it fetched.

There's no price history either. If you want one, Method 7 builds it from your own snapshots.

Private sellers are the other limit, and it's a legal one. Search cards for FSBO (private) sellers include a contact phone number.

Storing that number is processing personal data under GDPR. Drop it unless you have a lawful basis.

Saved searches, parked cars and messages sit behind a login, and none of the methods here touch them.

Troubleshooting

Blocked: Akamai said no (403)

Why: Akamai flagged the IP, the TLS fingerprint, or the request rate. The body is usually an HTML page with "Zugriff verweigert".

Fix: Stop for a few minutes, slow down, and move to a German residential IP. If it persists, switch to Method 6.

RuntimeError: No JSON from /consumer/api/search/srp (last status 200)

Why: The server answered with HTML: a challenge page, a consent interstitial, or a maintenance page.

Fix: Print resp.text[:500] in get_json() to see which one. A challenge means the same fix as the 403.

KeyError: 'id'

Why: You looped over searchResults.items directly and hit an inlineAdvertising slot, which has no id.

Fix: Always go through listings(), which also unpacks the page1Ads group you'd otherwise miss.

The filters echo shows only s, vc, sb and od

Why: mobile.de didn't recognise a filter key or value, usually from encoding ; or : by hand on top of urlencode.

Fix: Pass raw values like ms="1900;45" and let search_url() encode once. Compare with the URL your browser shows for the same filter.

hasNextPage is false at page 50, but numResultsTotal says 30,000

Why: That's the 50-page cap, not the end of the data.

Fix: Split the search with price_slices() from the section above.

FAQ

Does mobile.de have an API?

Yes, but not a public one for searching other people's listings. mobile.de runs a Seller-API, a Search-API, Ad-Stream and others for API accounts and dealer accounts, set up through its customer support.

The mobile.de API overview lists them. The consumer endpoint in this guide is the undocumented one the website uses.

Reading public listing data is lower-risk than scraping behind a login, but mobile.de's terms and robots.txt still apply, and robots.txt on suchen.mobile.de disallows its search and API paths.

Private sellers' phone numbers are personal data under GDPR. This isn't legal advice; check with a lawyer before commercial use.

Do you need proxies to scrape mobile.de?

Not always. My test calls from a US address returned JSON, but other scrapers report 403s from datacenter IPs, and volume makes a block more likely.

For daily crawls, a German residential or mobile IP with one request every two seconds is the safe setup. Roundproxies sells those, but pacing comes first.

How many listings does mobile.de have?

On 5 November 2026 the unfiltered car search returned 1,593,238 cars: 1,492,860 used and 100,410 new.

That count comes from numResultsTotal and the con aggregation in one search response. Motorbikes, vans and motorhomes are counted separately.

Can you scrape motorbikes, vans and motorhomes from mobile.de?

Yes. Change the vehicle class in s and vc, for example Motorbike or Motorhome, and every method here works the same way.

Set the category on the website first and copy the exact values from the address bar, since class names differ between categories.

Why do the same cars show up on every page?

Paid placements repeat across pages. Top ads, eyecatcher ads and the page1Ads group are pinned regardless of page number or sort order.

Dedupe on the listing id, as crawl_search() does, and dedupe again across price slices.

Wrapping up

The whole mobile.de scraper rests on one endpoint: /consumer/api/search/srp with your browser's search URL in url=.

Methods 2 to 5 read more out of the same data. Method 6 keeps it reachable when Akamai pushes back, and Method 7 keeps it current.

Start with one model and the filters echo, add price slicing only when a search hits 50 pages, and store id as a 64-bit value from day one.

The fragile parts are the item types, the attr keys and the Akamai thresholds. When a run comes back thin, print one raw response before you touch the parser.