How to Scrape AutoScout24: API, Anti-Bot Bypass, and Python Guide

AutoScout24 is Europe's largest car marketplace with over 700,000 active listings across 18+ countries. Whether you need pricing data for market research, inventory tracking, or vehicle specs for analysis, AutoScout24 is one of the richest sources of automotive data. But the site runs behind Akamai Bot Manager, and the official API doesn't support data extraction.

In this guide, you'll learn how to scrape AutoScout24 with Python using __NEXT_DATA__ JSON extraction. We'll cover the official API situation, anti-bot bypass, search and detail page scraping, pagination, and Scrapfly as a managed alternative. Let's get started.

Why Scrape AutoScout24?

Car dealers watch prices and inventory across markets. Makers and resellers track competitors. Researchers follow availability by body type and trim. AutoScout24 exposes a lot of the info you need: title, price, mileage, year, specs, and seller details.

Understanding AutoScout24's Structure

AutoScout24 is a modern JS site, so a lot of content loads after the first HTML. It also has strong bot protection. Expect some 403s and changing selectors, and plan for that.

Project Setup

We'll use a few Python libraries:

• requests - HTTP library for making web requests
• BeautifulSoup - HTML parsing library
• json - For parsing JSON data embedded in pages

Install the required dependencies:

Why Scrape AutoScout24?

AutoScout24 covers 18+ countries from Germany and Italy to Switzerland and Spain. Car dealers use AutoScout24 data to watch prices and inventory across markets. Manufacturers and resellers track competitor pricing. Researchers follow availability by body type, fuel type, and region.

Each listing has rich data: title, price, mileage, registration year, technical specs, seller details, and high-resolution images. You can compare a Volkswagen Golf's price in Germany versus Italy versus Spain from one source.

Does AutoScout24 Have a Public API?

AutoScout24 does have an official API, the Listing Creation API. But this API lets dealers create and manage vehicle listings, not extract car data.

What the Official Listing Creation API Does

The official API serves registered dealers and listing management platforms. The API handles the listing lifecycle: creating a new listing, uploading images, publishing, updating, and removing listings. AutoScout24 documents the API through an OpenAPI/Swagger spec.

The Listing Creation API is write-only. There's no search endpoint, no browse endpoint, and no way to query vehicle data. You can push listings into AutoScout24, but you can't pull data out.

Why the Official API Doesn't Help for Data Extraction

If you need car prices, specs, or seller details from AutoScout24, the official API won't help. The API has no read endpoints for vehicle listings. There's no way to search for cars, filter by make or model, or retrieve pricing data through official channels.

This gap between what the API offers and what data users need is why scraping and third-party tools exist.

Third-Party AutoScout24 APIs and Scraping Tools

Several categories of tools fill the official API gap:

• No-code scraping tools: pre-built scrapers you configure through a web interface. You set up the search URL, choose parameters, and export results as CSV or JSON
• Dedicated automotive data APIs: REST APIs that maintain their own AutoScout24 parsers and offer search, filters, and daily data exports
• Managed scraping APIs: services that handle anti-bot bypass, proxy rotation, and JS rendering, returning raw page data for you to parse

The tradeoff is clear. Managed tools are faster to start but charge per result. Custom scraping gives full control but needs anti-bot handling and proxy setup.

How Does AutoScout24 Block Scrapers?

AutoScout24 uses Akamai Bot Manager, one of the most aggressive anti-bot systems. A single request with proper headers may return 200. But Akamai blocks once patterns emerge: repeated requests from one IP, datacenter IPs, or missing browser fingerprints.

Akamai Bot Manager Protection

Akamai Bot Manager combines multiple detection methods:

• TLS fingerprinting (JA3/JA4): Akamai checks the TLS handshake to tell real browsers from HTTP libraries like requests
• HTTP/2 fingerprinting: the order and values of HTTP/2 settings frames reveal the client type
• JavaScript challenges: Akamai injects JavaScript that collects browser data and generates validation cookies (_abck, ak_bmsc)
• Behavior tracking: request timing, navigation patterns, and mouse movement data feed into Akamai's bot scoring model

When blocked, you'll see a 403 Forbidden status, an "Access Denied" message, or an empty response body. Here's what a basic request looks like:

import requests

response = requests.get(
    "https://www.autoscout24.com/lst?atype=C&cy=D&sort=standard&ustate=N%2CU",
    headers={"User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) Chrome/125.0.0.0"}
)
print(f"Status: {response.status_code}")
# First request often returns 200, but try 50 pages and you'll hit 403

A single request often succeeds because Akamai's heavier checks (JS challenges, behavior tracking) kick in after repeated requests. Don't mistake that first 200 for reliable access at scale.

For the full technical deep-dive on Akamai's detection, see our Akamai bypass guide.

Geo-Restrictions and Country-Specific Domains

AutoScout24 runs country-specific domains: .de, .it, .nl, .at, .be, .fr, .es, .ch, and .com. Some listings only show from specific countries, and IP geolocation affects search results. Scraping .de needs a German IP. Scraping .it needs an Italian proxy.

How to Scrape AutoScout24 Car Listings with Python

To scrape AutoScout24 listings, extract the __NEXT_DATA__ JSON from each page. Don't parse HTML selectors. AutoScout24 runs on Next.js, so every page has a __NEXT_DATA__ script tag with all page data as JSON. Next.js rehashes class names on each deploy, but the JSON stays stable.

Project Setup and Dependencies

You need Python 3.7+, requests for HTTP calls, and beautifulsoup4 to find the script tag. Install them:

$ pip install requests beautifulsoup4

Then set up the session with realistic headers and retry logic:

import requests
import json
import random
import time
from bs4 import BeautifulSoup
from requests.adapters import HTTPAdapter
from urllib3.util.retry import Retry

# Updated Chrome user agents
user_agents = [
    "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/125.0.0.0 Safari/537.36",
    "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/125.0.0.0 Safari/537.36",
    "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36",
    "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/125.0.0.0 Safari/537.36",
]

def create_session():
    """Create a requests session with retry logic and realistic headers."""
    session = requests.Session()
    # Add automatic retries for server errors
    retry_strategy = Retry(
        total=3,
        backoff_factor=1,
        status_forcelist=[429, 500, 502, 503, 504],
    )
    adapter = HTTPAdapter(max_retries=retry_strategy)
    session.mount("http://", adapter)
    session.mount("https://", adapter)
    # Set realistic browser headers
    session.headers.update({
        "User-Agent": random.choice(user_agents),
        "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
        "Accept-Language": "en-US,en;q=0.5",
        "Accept-Encoding": "gzip, deflate, br",
        "Connection": "keep-alive",
        "Upgrade-Insecure-Requests": "1",
    })
    return session

def make_request(session, url):
    """Fetch a page with delay and 403 detection."""
    time.sleep(random.uniform(1, 3))
    try:
        response = session.get(url, timeout=15)
        if response.status_code == 403:
            print(f"  Blocked (403) on {url}")
            return None
        if response.status_code == 200:
            return response
        print(f"  Error: status {response.status_code}")
        return None
    except Exception as e:
        print(f"  Request failed: {e}")
        return None

session = create_session()

create_session() builds a requests.Session with automatic retries for server errors and realistic browser headers. make_request() adds a random 1-3 second delay before each request and checks for 403 blocks.

Understanding AutoScout24's Page Architecture

AutoScout24 uses Next.js for server-side rendering. Every page includes a <script id="__NEXT_DATA__"> tag with the full page data as JSON. On search pages, the JSON payload is around 255 KB. On detail pages, around 134 KB.

Earlier versions of this guide used CSS class selectors like ListItem_title__ndA4s and Price_price__APlgs to parse listings. Next.js hashes those class names on each deploy, so CSS-based scrapers break regularly. The __NEXT_DATA__ approach pulls structured JSON directly, keeping the scraper stable.

AutoScout24 also uses data-testid attributes on some elements (like VehicleDetails-mileage_road and VehicleDetails-calendar). These are more stable than CSS classes because they exist for QA purposes. The data-testid attributes are a good fallback if __NEXT_DATA__ ever changes.

The JSON paths on search pages:

• data['props']['pageProps']['listings']: array of 20 listing objects per page
• data['props']['pageProps']['numberOfResults']: total result count
• data['props']['pageProps']['numberOfPages']: max page number (capped at 200)

Each listing object has nested data for vehicle, price, seller, location, images, and tracking fields. AutoScout24 renders the same data on the frontend, but here you get it pre-structured.

Extracting Listing Data from Search Pages

Search pages follow the URL pattern https://www.autoscout24.com/lst?atype=C&cy=D&sort=standard&ustate=N%2CU&page=1. Here's how to extract listings from __NEXT_DATA__:

def extract_next_data(html_content):
    """Parse __NEXT_DATA__ JSON from an AutoScout24 page."""
    soup = BeautifulSoup(html_content, "html.parser")
    script_tag = soup.find("script", id="__NEXT_DATA__")
    if not script_tag:
        print("  __NEXT_DATA__ script tag not found")
        return None
    return json.loads(script_tag.string)

def scrape_search_page(session, url):
    """Scrape car listings from a single AutoScout24 search page."""
    response = make_request(session, url)
    if not response:
        return []

    data = extract_next_data(response.text)
    if not data:
        return []

    page_props = data["props"]["pageProps"]
    raw_listings = page_props.get("listings", [])
    total_results = page_props.get("numberOfResults", 0)
    total_pages = page_props.get("numberOfPages", 0)
    print(f"  Found {len(raw_listings)} listings (total: {total_results}, pages: {total_pages})")

    listings = []
    for item in raw_listings:
        vehicle = item.get("vehicle", {})
        price = item.get("price", {})
        seller = item.get("seller", {})
        location = item.get("location", {})
        tracking = item.get("tracking", {})
        # Get vehicle detail chips (mileage, transmission, date, fuel, power)
        details = item.get("vehicleDetails", [])
        detail_map = {d.get("ariaLabel", ""): d.get("data", "") for d in details}

        listing = {
            "title": f"{vehicle.get('make', '')} {vehicle.get('model', '')} {vehicle.get('modelVersionInput', '')}".strip(),
            "price": price.get("priceFormatted", "N/A"),
            "price_raw": tracking.get("price"),
            "mileage": vehicle.get("mileageInKm", "N/A"),
            "mileage_raw": tracking.get("mileage"),
            "first_registration": detail_map.get("First registration", "N/A"),
            "fuel": vehicle.get("fuel", "N/A"),
            "transmission": vehicle.get("transmission", "N/A"),
            "power": detail_map.get("Power", "N/A"),
            "seller_name": seller.get("companyName") or seller.get("contactName", "Private"),
            "city": location.get("city", "N/A"),
            "country": location.get("countryCode", "N/A"),
            "url": "https://www.autoscout24.com" + item.get("url", ""),
        }
        listings.append(listing)

    return listings

# Scrape the first page
url = "https://www.autoscout24.com/lst?atype=C&cy=D&sort=standard&ustate=N%2CU&page=1"
listings = scrape_search_page(session, url)

# Print a sample
for car in listings[:3]:
    print(f"  {car['title']} | {car['price']} | {car['mileage']} | {car['fuel']}")

extract_next_data() uses BeautifulSoup to find the __NEXT_DATA__ script tag and parse the JSON. scrape_search_page() fetches a search URL, extracts the JSON, and maps each listing into a flat dictionary. The tracking object gives raw integer values for price and mileage, which help with sorting and filtering.

  Found 20 listings (total: 771404, pages: 200)
  Opel Astra Cabrio*Allwetter* | € 600 | 157,762 km | Gasoline
  Kia Stonic Dream Team Edition | € 13,490 | 31,436 km | Gasoline
  BMW X5 xDrive 30d M Sport | € 74,980 | 23,900 km | Diesel

Handling Pagination

AutoScout24 caps search results at 200 pages with 20 listings each, so 4,000 listings per query. To get more, narrow your search filters (make, model, year, price range) and run multiple queries. Here's the pagination loop:

def scrape_all_pages(session, base_url, max_pages=5):
    """Scrape multiple pages of AutoScout24 search results."""
    all_listings = []

    for page in range(1, max_pages + 1):
        # Add page parameter to URL
        separator = "&" if "?" in base_url else "?"
        page_url = f"{base_url}{separator}page={page}"
        print(f"Scraping page {page}...")

        page_listings = scrape_search_page(session, page_url)
        if not page_listings:
            print(f"  No listings on page {page}, stopping.")
            break

        all_listings.extend(page_listings)
        print(f"  Total collected: {len(all_listings)} listings")

    return all_listings

# Example: scrape first 3 pages
base_url = "https://www.autoscout24.com/lst?atype=C&cy=D&sort=standard&ustate=N%2CU"
all_cars = scrape_all_pages(session, base_url, max_pages=3)
print(f"\nScraped {len(all_cars)} total listings")

The pagination function loops through pages and appends results to one list. make_request() adds a random delay on each page to avoid triggering Akamai's rate limits. If a page returns nothing (or gets blocked), the loop stops early.

How to Scrape Individual AutoScout24 Car Details

Each vehicle detail page has the same __NEXT_DATA__ JSON pattern with the full spec sheet, all images, seller contact info, and pricing as structured data. Detail pages have more fields than search page cards.

Extracting Vehicle Specifications and Pricing

Detail page URLs follow the pattern https://www.autoscout24.com/offers/{slug}. The JSON lives at data['props']['pageProps']['listingDetails'] with full specs, pricing (including raw integers), equipment lists, and high-res image URLs (1280x960 vs 250x188 on search).

def scrape_car_details(session, url):
    """Scrape detailed information from a single AutoScout24 car page."""
    response = make_request(session, url)
    if not response:
        return None

    data = extract_next_data(response.text)
    if not data:
        return None

    listing = data["props"]["pageProps"].get("listingDetails", {})
    vehicle = listing.get("vehicle", {})
    prices = listing.get("prices", {})
    public_price = prices.get("public", {})
    seller = listing.get("seller", {})
    images = listing.get("images", [])

    # Fuel fields on detail pages are dicts with "raw" and "formatted" keys
    fuel_cat = vehicle.get("fuelCategory", {})
    fuel_name = fuel_cat.get("formatted", "N/A") if isinstance(fuel_cat, dict) else fuel_cat

    car = {
        "title": f"{vehicle.get('make', '')} {vehicle.get('model', '')} {vehicle.get('modelVersionInput', '')}".strip(),
        "price": public_price.get("price", "N/A"),
        "price_raw": public_price.get("priceRaw"),
        "negotiable": public_price.get("negotiable", False),
        "mileage": vehicle.get("mileageInKm", "N/A"),
        "mileage_raw": vehicle.get("mileageInKmRaw"),
        "first_registration": vehicle.get("firstRegistrationDate", "N/A"),
        "first_registration_raw": vehicle.get("firstRegistrationDateRaw"),
        "body_type": vehicle.get("bodyType"),
        "body_color": vehicle.get("bodyColor"),
        "paint_type": vehicle.get("paintType"),
        "fuel": fuel_name,
        "transmission": vehicle.get("transmissionType"),
        "drivetrain": vehicle.get("driveTrain"),
        "power_kw": vehicle.get("rawPowerInKw"),
        "power_hp": vehicle.get("rawPowerInHp"),
        "displacement_ccm": vehicle.get("rawDisplacementInCCM"),
        "cylinders": vehicle.get("cylinders"),
        "number_of_seats": vehicle.get("numberOfSeats"),
        "number_of_doors": vehicle.get("numberOfDoors"),
        "co2_emission": vehicle.get("co2emissionInGramPerKmWithFallback"),
        "description": listing.get("description", ""),
        "seller_name": seller.get("companyName") or seller.get("contactName", "Private"),
        "seller_type": seller.get("type"),
        "seller_id": seller.get("id"),
        "images": images[:5],  # First 5 high-res image URLs
        "url": url,
    }
    return car

# Example: scrape a car detail page
detail_url = listings[0]["url"]
car = scrape_car_details(session, detail_url)
if car:
    print(json.dumps(car, indent=2, ensure_ascii=False))

scrape_car_details() extracts 20+ fields from a single detail page. The raw integer values for price, mileage, and engine power save you from parsing formatted strings. Note that fuel fields on detail pages are dicts with "raw" and "formatted" keys, so the code extracts fuelCategory["formatted"] for a clean string like "Gasoline".

{
  "title": "Opel Astra Cabrio*Allwetter*",
  "price": "€ 600",
  "price_raw": 600,
  "negotiable": false,
  "mileage": "157,762 km",
  "mileage_raw": 157762,
  "first_registration": "06/2003",
  "body_type": "Convertible",
  "body_color": "Silver",
  "fuel": "Gasoline",
  "transmission": "Manual",
  "power_kw": 108,
  "power_hp": 147,
  "displacement_ccm": 2198,
  "seller_name": "Autohaus Panke",
  "seller_type": "Dealer",
  "url": "https://www.autoscout24.com/offers/opel-astra-..."
}

Extracting Seller Information

Seller data on detail pages includes dealer name, phone numbers, address, and a link to the dealer's profile. The seller object contains:

• companyName: the dealership name (for dealer listings)
• contactName: the contact person's name
• phones: an array of phone objects with formattedNumber and callTo fields
• type: either "Dealer" or "Private"
• links.infoPage: URL to the dealer's full profile

For private sellers, companyName is empty and only contactName plus a limited phone object are available. Be mindful of data sensitivity when collecting private seller details.

How to Handle AutoScout24's Anti-Bot Protection

Even with __NEXT_DATA__ extraction, your requests will hit Akamai's bot detection at scale. Here are the AutoScout24-specific strategies that work.

Session Management and Cookie Handling

Akamai sets _abck and ak_bmsc cookies after the initial JavaScript challenge. A pure requests-based approach skips JS execution, so these cookies never get set. For light scraping (under 20 pages), you may not need the cookies. For larger jobs, you need a strategy.

One approach uses curl_cffi to match a real browser's TLS fingerprint. curl_cffi sends the same JA3 fingerprint as Chrome, which stops Akamai from flagging the connection at the TLS level. Combined with session cookie persistence:

# Conceptual example: cookie patterns may change
from curl_cffi import requests as curl_requests

# Create a session that impersonates Chrome's TLS fingerprint
session = curl_requests.Session(impersonate="chrome")

# First request passes Akamai's TLS check and collects cookies
response = session.get("https://www.autoscout24.com/lst?atype=C&cy=D")
print(f"Status: {response.status_code}")

# Subsequent requests reuse the session cookies
# Akamai cookies (_abck, ak_bmsc) persist across requests
for page in range(2, 6):
    time.sleep(random.uniform(2, 4))
    response = session.get(f"https://www.autoscout24.com/lst?atype=C&cy=D&page={page}")
    print(f"Page {page}: {response.status_code}")
    # Refresh the session if cookies expire (typically after ~30 minutes)

curl_cffi matches Chrome's TLS fingerprint at the connection level, which is the first check Akamai runs. Without TLS matching, Akamai spots a Python HTTP library before even reading the request headers. For a walkthrough of TLS fingerprinting and JA3/JA4 signatures, see our TLS blocking guide.

Proxy Rotation and Geo-Targeting for European Markets

Residential proxies are key for scraping AutoScout24 at scale. Akamai's IP reputation database flags datacenter addresses right away. Match the proxy country to the target domain:

# Conceptual example: proxy configuration for European markets
proxy_pools = {
    "de": "http://user:pass@de-residential-proxy:port",  # autoscout24.de
    "it": "http://user:pass@it-residential-proxy:port",  # autoscout24.it
    "nl": "http://user:pass@nl-residential-proxy:port",  # autoscout24.nl
    "at": "http://user:pass@at-residential-proxy:port",  # autoscout24.at
    "be": "http://user:pass@be-residential-proxy:port",  # autoscout24.be
    "fr": "http://user:pass@fr-residential-proxy:port",  # autoscout24.fr
    "es": "http://user:pass@es-residential-proxy:port",  # autoscout24.es
}

def scrape_country(country_code, search_url):
    """Scrape AutoScout24 with a country-matched proxy."""
    proxy = proxy_pools.get(country_code)
    if not proxy:
        print(f"No proxy configured for {country_code}")
        return None
    proxies = {"http": proxy, "https": proxy}
    session = create_session()
    # Rotate IP per page, not per request (maintain session consistency)
    time.sleep(random.uniform(2, 5))
    response = session.get(search_url, proxies=proxies, timeout=15)
    return response

Rotate the IP between pages, not between individual requests on the same page. Akamai tracks session consistency, so switching IPs mid-session raises a red flag. Keep the same IP for a full page load, then rotate.

For more on proxy strategies, see our proxy detection bypass guide. Also check our guide on hiding your IP while scraping.

How to Scrape AutoScout24 with Scrapfly

ScrapFly provides web scraping, screenshot, and extraction APIs for data collection at scale. For teams that want to skip anti-bot engineering and go straight to data extraction, Scrapfly handles AutoScout24's Akamai protection automatically.

Key features for AutoScout24 scraping:

• Anti-Scraping Protection (ASP) bypasses Akamai Bot Manager without manual cookie or TLS handling
• Rotating residential proxies across 100+ countries to target .de, .it, .nl, or any AutoScout24 domain
• Built-in JavaScript rendering through headless browsers
• Python SDK for quick integration

Here's how to scrape AutoScout24 with Scrapfly:

from scrapfly import ScrapflyClient, ScrapeConfig, ScrapeApiResponse
import json
from bs4 import BeautifulSoup

scrapfly = ScrapflyClient(key="YOUR-SCRAPFLY-KEY")

# Scrape car listings
result: ScrapeApiResponse = scrapfly.scrape(ScrapeConfig(
    url="https://www.autoscout24.com/lst?atype=C&cy=D&sort=standard&ustate=N%2CU",
    tags=["autoscout24", "car-listings"],
    asp=True,          # Turn on Anti-Scraping Protection for Akamai bypass
    render_js=True,    # Render JavaScript for full page data
    country="DE",      # Use a German proxy for .de listings
))
# Parse __NEXT_DATA__ from the response
soup = BeautifulSoup(result.content, "html.parser")
data = json.loads(soup.find("script", id="__NEXT_DATA__").string)
listings = data["props"]["pageProps"]["listings"]
print(f"Found {len(listings)} listings via Scrapfly")

# Scrape individual car details
car_result: ScrapeApiResponse = scrapfly.scrape(ScrapeConfig(
    url="https://www.autoscout24.com/offers/opel-astra-cabrio-allwetter-gasoline-silver-ef373324-f78f-46e8-9cbc-641ad9af197d",
    tags=["autoscout24", "car-details"],
    asp=True,
    render_js=True,
    country="DE",
))
print(f"Detail page status: {car_result.status_code}")

asp=True turns on Anti-Scraping Protection, which handles Akamai's TLS fingerprinting, JS challenges, and cookie management. country="DE" routes the request through a German residential proxy for geo-restricted listings.

Self-hosted scraping stays viable for teams with existing proxy setups. Scrapfly is one managed option for teams that want speed over full control.

Summary

AutoScout24 is one of the richest automotive data sources in Europe. The gap between the official API (listing creation for dealers) and what users need (data extraction) means scraping is the practical path. __NEXT_DATA__ JSON extraction stays stable across deploys and gives you structured data without fragile CSS selectors.

You have three paths for getting AutoScout24 data. The official API works only for dealers publishing listings. DIY scraping with __NEXT_DATA__ plus anti-bot handling gives full control. Managed tools offer faster setup with per-result costs. For teams that want Akamai bypass without building proxy setups, Scrapfly's Anti-Scraping Protection handles it automatically.