[Blog](https://scrapfly.io/blog)   /  [python](https://scrapfly.io/blog/tag/python)   /  [How to Scrape AutoScout24: API, Anti-Bot Bypass, and Python Guide](https://scrapfly.io/blog/posts/how-to-scrape-autoscout24)   # How to Scrape AutoScout24: API, Anti-Bot Bypass, and Python Guide

 by [Ziad Shamndy](https://scrapfly.io/blog/author/ziad) May 23, 2026 11 min read [\#python](https://scrapfly.io/blog/tag/python) [\#requests](https://scrapfly.io/blog/tag/requests) [\#scrapeguide](https://scrapfly.io/blog/tag/scrapeguide) 

 [  ](https://www.linkedin.com/sharing/share-offsite/?url=https%3A%2F%2Fscrapfly.io%2Fblog%2Fposts%2Fhow-to-scrape-autoscout24 "Share on LinkedIn")    

 

 

         

   **Web Scraping API**Scrape any website with anti-bot bypass, proxy rotation, and JS rendering.

 

 [ Learn More  ](https://scrapfly.io/products/web-scraping-api) [  Docs ](https://scrapfly.io/docs/scrape-api/getting-started) 

 

 

AutoScout24's official API only lets dealers publish listings. Projects that need car prices, specs, or inventory data must scrape the site directly. The two obstacles are Akamai Bot Manager and Next.js class-name hashing. Akamai blocks automated requests at scale. Next.js hashing breaks any scraper built on CSS selectors within a release cycle.

In this guide, we'll use [Scrapfly's Web Scraping API](https://scrapfly.io/web-scraping-api) to bypass Akamai. We'll route requests through country-matched residential IPs for the `.de`, `.it`, and `.es` domains. Then we'll parse listings and detail pages from the `__NEXT_DATA__` JSON AutoScout24 embeds on every page. Let's get started.

[**Latest AutoScout24 Scraper Code**github.com/scrapfly/scrapfly-scrapers/autoscout24-scraper](https://github.com/scrapfly/scrapfly-scrapers/tree/main/autoscout24-scraper)



## Key Takeaways

- AutoScout24 runs on Next.js. Every page embeds a `<script id="__NEXT_DATA__">` tag with the full page payload as JSON. Parsing that JSON is more stable than CSS selectors. Next.js rehashes those selectors on each deploy.
- The official Listing Creation API is dealer-facing and write-only. It has no search, browse, or read endpoint for vehicle data. Scraping is the practical path.
- Akamai Bot Manager protects the site with TLS fingerprinting, JS challenges, and the `_abck` and `ak_bmsc` cookie pair. A single request may pass. Large crawls trigger blocks fast.
- AutoScout24 runs country-specific domains: `.de`, `.it`, `.nl`, `.at`, `.be`, `.fr`, `.es`, and `.ch`. Some listings are geo-restricted. You need residential proxies that match the target country.
- Scrapfly's `asp=True` solves Akamai's TLS, behavior, and cookie checks in one API call. `country="DE"` routes through a German residential IP. AutoScout24 treats that request as a real visit. See [Scrapfly's Akamai bypass](https://scrapfly.io/bypass/akamai) for the full feature set.

**Get web scraping tips in your inbox**Trusted by 100K+ developers and 30K+ enterprises. Unsubscribe anytime.







## Why Scrape AutoScout24?

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

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

## Does AutoScout24 Have a Public API?

AutoScout24 does have an official API, the Listing Creation API. The catch is simple. This API lets dealers create and manage vehicle listings. It does not extract car data.

The official API serves registered dealers and listing management platforms. It handles the listing life cycle. Dealers can create listings, upload images, publish, update, and remove listings. AutoScout24 documents the surface 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 through official channels. You can push listings into AutoScout24. You can't pull data out.

If you need car prices, specs, or seller details, the official API won't help. This gap is why AutoScout24 scraping exists as its own use case.



## How Does AutoScout24 Block Scrapers?

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

Akamai combines several 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 JS that collects browser data and generates the `_abck` and `ak_bmsc` validation cookies.
- **Behavior tracking**: request timing, navigation patterns, and mouse movement data feed Akamai's bot scoring model.

When blocked, you'll see a 403 Forbidden status, an "Access Denied" page, or an empty response body. The first request often returns 200 because Akamai's heavier checks start after repeated requests. Do not mistake that first 200 for reliable access at scale.

AutoScout24 also runs country-specific domains: `.de`, `.it`, `.nl`, `.at`, `.be`, `.fr`, `.es`, `.ch`, and `.com`. Some listings only render from specific countries. IP location shapes search results. Scraping `.de` needs a German IP. Scraping `.it` needs an Italian one.

[How to Bypass Akamai when Web Scraping in 2026In this article we'll take a look at a popular anti bot service Akamai Bot Manager. How does it detect web scrapers and bots and what can we do to prevent our scrapers from being detected?](https://scrapfly.io/blog/posts/how-to-bypass-akamai-anti-scraping)



Scrapfly

#### Scale your web scraping effortlessly

Scrapfly handles proxies, browsers, and anti-bot bypass — so you can focus on data.

[Try Free →](https://scrapfly.io/register)## How to Set Up Scrapfly for AutoScout24

The setup runs through the Scrapfly Python SDK. Install it first. Then configure a base request profile for Akamai and country routing.

bash```bash
pip install scrapfly-sdk
```



The SDK wraps the Scrapfly Web Scraping API. It exposes the `ScrapflyClient` and `ScrapeConfig` you need to send requests. Get an API key from the [Scrapfly dashboard](https://scrapfly.io/dashboard). Then export it as `SCRAPFLY_KEY`.

python```python
import os
import json
from scrapfly import ScrapeConfig, ScrapflyClient

SCRAPFLY = ScrapflyClient(key=os.environ["SCRAPFLY_KEY"])

BASE_CONFIG = {
    "asp": True,        # bypass Akamai Bot Manager
    "render_js": True,  # AutoScout24 hydrates parts of the page client-side
}
```



`asp=True` turns on Anti-Scraping Protection. It solves Akamai's TLS, JS challenge, and cookie management automatically. `render_js=True` waits for AutoScout24's client-side hydration before returning the HTML, so the `__NEXT_DATA__` script tag contains data. Every snippet below reuses `BASE_CONFIG` and pairs it with a `country="DE"` (or `"IT"`, `"ES"`) routing flag.

## How Do You Scrape AutoScout24 Car Listings?



A search page URL looks like `https://www.autoscout24.com/lst?atype=C&cy=D&sort=standard&ustate=N%2CU&page=1`. The visible HTML uses Next.js class hashes like `ListItem_title__ndA4s` that change on every deploy, so we ignore the markup and go straight to the JSON.

Every AutoScout24 page ships a `<script id="__NEXT_DATA__">` tag with the full page state. On search pages, the payload is around 255 KB. The paths that matter:

- `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 `vehicle`, `price`, `seller`, `location`, `tracking`, and `vehicleDetails` blocks with everything the card shows on the frontend, plus raw integer fields for sorting.

python```python
def parse_listings(result):
    """Parse AutoScout24 listings page from __NEXT_DATA__."""
    script_data = result.selector.css("script#__NEXT_DATA__::text").get()
    if not script_data:
        return []
    data = json.loads(script_data)
    return data.get("props", {}).get("pageProps", {}).get("listings", [])


async def scrape_listing_page(url: str):
    """Fetch a single AutoScout24 search page through Scrapfly."""
    result = await SCRAPFLY.async_scrape(
        ScrapeConfig(url, **BASE_CONFIG, country="DE")
    )
    return parse_listings(result)
```



`parse_listings` reads the script tag with a CSS selector, parses the JSON, and returns the raw listing array. The `country="DE"` flag on `ScrapeConfig` routes the request through a German residential IP. Swap `"IT"` for `autoscout24.it` or `"ES"` for `autoscout24.es` and the same parser keeps working.

 Example Outputjson```json

COUNT=20
{
  "make": "Volkswagen",
  "model": "Polo",
  "price": "€ 1,699",
  "mileage": "220,000 km",
  "fuel": "Gasoline",
  "city": "Seddiner See"
}
{
  "make": "Mercedes-Benz",
  "model": "GLC 300",
  "price": "€ 32,970",
  "mileage": "77,483 km",
  "fuel": "Electric/Gasoline",
  "city": "Gelsenkirchen"
}
  
```



### How Does AutoScout24 Handle Pagination?

AutoScout24 caps search results at 200 pages with 20 listings each, so 4,000 listings per query. To go deeper, narrow your filters (make, model, year, price range) and run multiple queries. Pagination uses a `page=N` query parameter:

```
https://www.autoscout24.com/lst?atype=C&cy=D            # page 1
https://www.autoscout24.com/lst?atype=C&cy=D&page=2     # page 2
https://www.autoscout24.com/lst?atype=C&cy=D&page=3     # page 3
```



The first page tells you `numberOfPages`, so you can pre-build the remaining requests and fire them in parallel through `SCRAPFLY.concurrent_scrape`:

python```python
async def scrape_listings(url: str, max_pages: int = 3):
    """Scrape multiple AutoScout24 search pages concurrently."""
    first = await SCRAPFLY.async_scrape(
        ScrapeConfig(url, **BASE_CONFIG, country="DE")
    )
    all_listings = parse_listings(first)

    sep = "&" if "?" in url else "?"
    other_pages = [
        ScrapeConfig(f"{url}{sep}page={p}", **BASE_CONFIG, country="DE")
        for p in range(2, max_pages + 1)
    ]
    async for response in SCRAPFLY.concurrent_scrape(other_pages):
        all_listings.extend(parse_listings(response))
    return all_listings
```



`concurrent_scrape` runs the remaining pages in parallel, so a three-page crawl finishes in roughly one page's worth of wall time. Scrapfly handles the Akamai bypass and IP rotation per request. Each page lands on a fresh German residential IP without any session juggling on your side.



## How Do You Scrape Individual AutoScout24 Car Details?

Detail page URLs follow the pattern `https://www.autoscout24.com/offers/{slug}`. Each detail page ships the same `__NEXT_DATA__` script tag, but with a larger payload. It is around 134 KB and includes the full spec sheet, 1280x960 images, equipment lists, and the full seller block.

The JSON lives at `data["props"]["pageProps"]["listingDetails"]` and has the same shape as a search listing plus 20+ extra fields: `priceRaw`, `mileageInKmRaw`, `firstRegistrationDate`, `bodyType`, `transmissionType`, `rawPowerInHp`, `cylinders`, `numberOfSeats`, `co2emissionInGramPerKmWithFallback`, and the full image gallery.

python```python
def parse_car_details(result):
    """Parse an AutoScout24 detail page from __NEXT_DATA__."""
    script_data = result.selector.css("script#__NEXT_DATA__::text").get()
    if not script_data:
        return None
    data = json.loads(script_data)
    return data.get("props", {}).get("pageProps", {}).get("listingDetails", {})


async def scrape_car_details(urls: list[str]):
    """Scrape multiple AutoScout24 detail pages concurrently."""
    configs = [
        ScrapeConfig(url, **BASE_CONFIG, country="DE") for url in urls
    ]
    cars = []
    async for response in SCRAPFLY.concurrent_scrape(configs):
        cars.append(parse_car_details(response))
    return cars
```



`parse_car_details` returns the full `listingDetails` dict. It gives you raw integers (`priceRaw`, `mileageInKmRaw`) for sorting and filtering, structured equipment lists, and the dealer contact block. That block includes `companyName`, `phones`, and `links.infoPage`. Combine `scrape_listings` and `scrape_car_details` by feeding each listing `url` into the detail scraper. You then get a two-stage pipeline: cheap listing pulls for discovery, then full detail pulls for cars you want to track.

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

## Powering AutoScout24 Scraping with Scrapfly



Scrapfly provides web scraping, screenshot, and extraction APIs for data collection at scale. For AutoScout24, the [Web Scraping API](https://scrapfly.io/web-scraping-api) handles the Akamai bypass, country-matched residential proxies, and TLS fingerprinting. Those layers stop DIY scrapers at production volume. With Scrapfly handling them, `parse_listings` and `parse_car_details` drop into a concurrent crawl.

- [Anti-Scraping Protection bypass](https://scrapfly.io/docs/scrape-api/anti-scraping-protection) solves Akamai's TLS, JS challenge, and `_abck` cookie management automatically with `asp=True`.
- [Smart proxy rotation](https://scrapfly.io/docs/scrape-api/proxy) routes traffic through country-matched residential IPs with `country="DE"`, `"IT"`, `"ES"`, or any other AutoScout24 domain.
- [JavaScript rendering](https://scrapfly.io/docs/scrape-api/javascript-rendering) waits for AutoScout24's Next.js hydration before returning HTML, so the `__NEXT_DATA__` payload contains data.
- [Smart caching](https://scrapfly.io/docs/scrape-api/getting-started#api_param_cache) keeps repeat scrapes cheap during selector development.
- [Python SDK](https://scrapfly.io/docs/sdk/python) with `concurrent_scrape` for parallel pagination and detail crawls across thousands of cars.



### Web Scraping API

Scrape any website with our powerful API. Anti-bot bypass, JavaScript rendering, and rotating proxies built-in.



[Try Web Scraping API](https://scrapfly.io/docs/scrape-api/getting-started)



## FAQ

Does AutoScout24 use Akamai bot protection?Yes. AutoScout24 uses Akamai Bot Manager with TLS fingerprinting, JS challenges, and the `_abck` and `ak_bmsc` cookie pair to detect and block automated access at scale.







Do you need country-specific proxies to scrape AutoScout24?Yes for most domains. Scraping `.de` needs a German IP, `.it` needs an Italian one, and so on. Scrapfly's `country="DE"` flag picks the right residential pool automatically.







Can you use the AutoScout24 official API instead of scraping?The official Listing Creation API is write-only and only available to registered dealers. There's no search or read endpoint, so scraping is the only path to vehicle data.







How many AutoScout24 listings can you pull per search?AutoScout24 caps search results at 200 pages with 20 listings each, so 4,000 listings per query. To go further, split the search by make, model, price range, or registration year and run multiple queries.









## Summary

Scraping AutoScout24 comes down to two things: getting past Akamai to receive clean HTML, and parsing the `__NEXT_DATA__` JSON Next.js ships on every page. The listings array lives at `props.pageProps.listings`, the detail payload lives at `props.pageProps.listingDetails`, and `numberOfPages` tells you how far the pagination can go before you start crawling.

[Scrapfly's Akamai bypass](https://scrapfly.io/bypass/akamai) handles the anti-bot layer. Country-matched residential proxies handle geolocation. These parsers fit into a concurrent crawl loop. You do not need `_abck` cookie juggling, TLS impersonation, or CSS selector repairs after each AutoScout24 deploy.



Legal Disclaimer and PrecautionsThis tutorial covers popular web scraping techniques for education. Interacting with public servers requires diligence and respect:

- Do not scrape at rates that could damage the website.
- Do not scrape data that's not available publicly.
- Do not store PII of EU citizens protected by GDPR.
- Do not repurpose *entire* public datasets which can be illegal in some countries.

Scrapfly does not offer legal advice but these are good general rules to follow. For more you should consult a lawyer.

 

   Table of Contents















 

  Table of Contents- [Key Takeaways](#key-takeaways)
- [Why Scrape AutoScout24?](#why-scrape-autoscout24)
- [Does AutoScout24 Have a Public API?](#does-autoscout24-have-a-public-api)
- [How Does AutoScout24 Block Scrapers?](#how-does-autoscout24-block-scrapers)
- [How to Set Up Scrapfly for AutoScout24](#how-to-set-up-scrapfly-for-autoscout24)
- [How Do You Scrape AutoScout24 Car Listings?](#how-do-you-scrape-autoscout24-car-listings)
- [How Does AutoScout24 Handle Pagination?](#how-does-autoscout24-handle-pagination)
- [How Do You Scrape Individual AutoScout24 Car Details?](#how-do-you-scrape-individual-autoscout24-car-details)
- [Powering AutoScout24 Scraping with Scrapfly](#powering-autoscout24-scraping-with-scrapfly)
- [FAQ](#faq)
- [Summary](#summary)
 
    Join the Newsletter  Get monthly web scraping insights 

 

  



Scale Your Web Scraping

Anti-bot bypass, browser rendering, and rotating proxies, all in one API. Start with 1,000 free credits.

  No credit card required  1,000 free API credits  Anti-bot bypass included 

 [Start Free](https://scrapfly.io/register) [View Docs](https://scrapfly.io/docs/onboarding) 

 Not ready? Get our newsletter instead. 

 

## Explore this Article with AI

 [ ChatGPT ](https://chat.openai.com/?q=Summarize%20this%20page%3A%20https%3A%2F%2Fscrapfly.io%2Fblog%2Fposts%2Fhow-to-scrape-autoscout24) [ Gemini ](https://www.google.com/search?udm=50&aep=11&q=Summarize%20this%20page%3A%20https%3A%2F%2Fscrapfly.io%2Fblog%2Fposts%2Fhow-to-scrape-autoscout24) [ Grok ](https://x.com/i/grok?text=Summarize%20this%20page%3A%20https%3A%2F%2Fscrapfly.io%2Fblog%2Fposts%2Fhow-to-scrape-autoscout24) [ Perplexity ](https://www.perplexity.ai/search/new?q=Summarize%20this%20page%3A%20https%3A%2F%2Fscrapfly.io%2Fblog%2Fposts%2Fhow-to-scrape-autoscout24) [ Claude ](https://claude.ai/new?q=Summarize%20this%20page%3A%20https%3A%2F%2Fscrapfly.io%2Fblog%2Fposts%2Fhow-to-scrape-autoscout24) 



 ## Related Articles

 [  

 blocking 

### How to Bypass Akamai when Web Scraping in 2026

In this article we'll take a look at a popular anti bot service Akamai Bot Manager. How does it detect web scrapers and ...

 

 ](https://scrapfly.io/blog/posts/how-to-bypass-akamai-anti-scraping) [  

 blocking 

### How to Bypass Cloudflare When Web Scraping in 2026

Cloudflare offers one of the most popular anti scraping service, so in this article we'll take a look how it works and h...

 

 ](https://scrapfly.io/blog/posts/how-to-bypass-cloudflare-anti-scraping) [  

 python scrapeguide 

### How to Scrape Zillow Real Estate Property Data in Python

Tutorial on how to scrape Zillow.com sale and rent property data, using Python and how to avoid blocking to scrape at sc...

 

 ](https://scrapfly.io/blog/posts/how-to-scrape-zillow) 

  



   



 Scale your web scraping effortlessly, **1,000 free credits** [Start Free](https://scrapfly.io/register)