# AutoScout24 Scraper (`lowlanddata/autoscout24-scraper`) Actor Car offers from AutoScout24 in Germany, Austria, Belgium, the Netherlands, Italy, Spain, France and the international site as clean JSON: make, model, price, price rating, year, mileage, fuel, gearbox, power, photos. Dealer or private as a flag; seller identity never collected. Pay per result. - **URL**: https://apify.com/lowlanddata/autoscout24-scraper.md - **Developed by:** [Lowland Data](https://apify.com/lowlanddata) (community) - **Categories:** E-commerce, Automation, Business - **Stats:** 2 total users, 1 monthly users, 0.0% runs succeeded, 0 bookmarks - **User rating**: No ratings yet ## Pricing from $2.40 / 1,000 results This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events. Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have. Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event ## What's an Apify Actor? An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes. In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours, and optionally produces a well-defined JSON output, datasets with results, or files in key-value store. In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server. Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md. ## How to integrate an Actor? If asked about integration, you help developers integrate Actors into their projects. You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready. Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run. For examples already wired to this Actor's own input schema, see the [API](#api) section below. Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`). # README ## AutoScout24 Scraper — car listings from eight countries, GDPR-safe Extract car offers from **autoscout24.de** and its sister sites in Austria, Belgium, the Netherlands, Italy, Spain, France and the international autoscout24.com — Europe's largest car marketplace — as clean, structured JSON. Make, model, version, price, the site's own price rating, first registration, mileage, fuel, transmission, power, consumption, CO2, location and photos on every row; description, posting time, net price, equipment list and the full spec sheet when you ask for the offer pages. Ready for price monitoring, dealer stock analysis, market research and data pipelines. **No seller personal data, ever.** This scraper is built GDPR-first: seller names, dealer names, phone numbers, street addresses and coordinates never appear in the output — not as an option you have to remember to switch off, but by design. The only seller information included is whether the offer comes from a dealer or a private seller. ### Quick start (30 seconds) 1. Put the make into **make**, as the site spells it in its address bar — e.g. `bmw`, `mercedes-benz`, `volkswagen`. Add a **model** if you want one (`320`, `golf`, `c-200`). 2. Click **Start**. That's the whole minimum setup. 3. When the run finishes, open the dataset's **Overview** tab for a clean table, or **Export** it as CSV/Excel/JSON. Pick another **country** site, switch **vehicleType** to motorbikes, caravans or transporters, add price, year, mileage, fuel, gearbox, body or seller-type filters, or a postcode and radius; keep **sortBy** on newest and put the run on a schedule for a daily watch. ### What you can build with it - **Price a car before you buy or sell it.** Search `make: bmw`, `model: 320`, `yearMin: 2019`, `mileageMaxKm: 80000`, `fuel: diesel` and get every matching offer with `priceCents`, `priceRating` (the site's own verdict: very_good to high), `firstRegistration`, `mileageKm`, `powerKw` and `sellerType` — a price distribution in one run. - **Watch a segment for new offers.** Keep `sortBy: newest`, cap `maxItems` at a page or two, and schedule the run hourly; the newest private-seller Golfs in Belgium land in your sheet or Slack with the price already parsed. - **Compare countries.** The same query on `country: de`, `nl`, `be`, `it` or `es` returns the same columns; `fuelCode` and `countryCode` stay identical across sites while `fuel` and `transmission` carry each site's label, so a cross-border arbitrage sheet needs no translation table. - **Feed an AI agent clean data.** Every field is structured, predictable and free of personal data, so an assistant or pipeline can consume it directly — no scrubbing, no compliance review before you store it. ### What you get Each offer is one dataset item: ```json { "listingId": "3ca5ccaa-7748-4101-b4e3-a7c71ecd4e00", "url": "https://www.autoscout24.de/angebote/bmw-3er-320-d-sport-line-diesel-weiss-cat_ma13gr100038ge26va104mt118tr479990-3ca5ccaa-7748-4101-b4e3-a7c71ecd4e00", "title": "320 d Sport Line", "make": "BMW", "model": "320", "modelGroup": "3er", "variant": "Gran Turismo", "motorType": "320d", "version": "320 d Sport Line", "priceCents": 2450000, "currency": "EUR", "priceRating": "fair", "firstRegistration": "2020-02", "mileageKm": 72000, "fuel": "Diesel", "fuelCode": "D", "transmission": "Automatik", "powerKw": 140, "powerHp": 190, "engineDisplacementCcm": 1995, "fuelConsumption": "5,00 l/100 km (komb.)", "co2Emission": "131 g/km (komb.)", "offerCode": "U", "damaged": false, "vehicleType": "car", "countryCode": "DE", "postcode": "53879", "city": "Euskirchen, Stadt", "sellerType": "private", "imageUrls": [ "https://prod.pictures.autoscout24.net/listing-images/3ca5ccaa-7748-4101-b4e3-a7c71ecd4e00_53068c22-96bb-4c8a-bf41-d391275bf4de.jpg/1280x960.webp" ] } ``` With **Fetch offer pages** on (or for offers named in `listingIds`), each item also carries `description`, `postedAt`, `status`, `negotiable`, `netPriceCents`, `vatRate`, `vatDeductible`, `condition`, `bodyType`, `seats`, `doors`, `color`, `paintType`, `upholstery`, `gears`, `cylinders`, `driveTrain`, `weightKg`, `emissionClass`, `particleFilter`, `previousOwners`, `fullServiceHistory`, `nonSmoking`, `hadAccident`, `damageConditions`, `nextInspection`, `productionYear`, `warranty` and `equipment` — the whole spec sheet the offer page shows. Field notes, so you know exactly what you are buying: - `priceCents` is the asking price in euro cents; `previousPriceCents` appears when the site shows the offer as reduced. `priceRating` is the site's own comparison against similar offers, present when the site shows one. - `firstRegistration` is year and month (`2020-02`); `nextInspection` the same. `postedAt` (offer pages only) is a full timestamp. - `fuel`, `transmission`, `fuelConsumption`, `co2Emission`, `bodyType`, `color` and `equipment` are the site's labels in the site's language: German on .de and .at, Dutch or French on .be, English on .com. `fuelCode` is the same letter on every site (B petrol, D diesel, E electric, 2 and 3 hybrids, L LPG, C CNG, H hydrogen). - `fuelConsumption` and `co2Emission` are absent when the seller gave none, never a dash. - `postcode` and `city` are municipality-level; street and coordinates are never collected, for dealers as for private sellers. - `damaged` is the list's flag on search rows; `hadAccident` and `damageConditions` are the seller's declaration on offer pages. - `imageUrls` are 1280x960 photos; the search row carries the first few, the offer page every one. - The international site (`country: com`) mixes every country's offers; `countryCode` says where each car is. ### How much does it cost to scrape AutoScout24? $3.00 per 1,000 offers delivered, pay-as-you-go: no subscription, and you pay per result rather than per hour. A run that finds nothing still costs the $0.005 actor start. In plain dollars: - **100 offers ≈ $0.30** — a daily segment watch. - **500 offers ≈ $1.50** — a solid price snapshot. - **A 4,000-offer crawl ≈ $12.00** — a full make, deduplicated. Your own Apify platform usage comes on top and is small: a scoped few-hundred-offer run costs well under a cent; the offer pages (`scrapeDetails`) add one page fetch per offer. Datacenter proxies are sufficient — no residential proxy surcharge needed. Free-plan runs are limited to a sample of 5 items, enough to evaluate the output format against your real query. ### Not technical? Let your AI assistant set it up Copy this into ChatGPT, Claude or any AI assistant, fill in the one line, and follow the conversation: ```text Help me set up the "AutoScout24 Scraper" actor on Apify (https://apify.com/lowlanddata/autoscout24-scraper). Guide me one step at a time. What I want to watch: [E.G. "used BMW 320 diesels under 25,000 euro in Germany"] Guide me to: 1. Propose my input values: make and model (as the site's address bar spells them, e.g. bmw and 320), country (de, at, be, be-fr, nl, it, es, fr or com), the price, year, mileage, fuel, transmission, body and sellerType filters I need, sortBy "newest" for monitoring, and maxItems. 2. Decide whether I need scrapeDetails (the description, posting time and full spec sheet from each offer page) or whether the search rows are enough. 3. Create a free Apify account (apify.com), open the actor page, paste the values into the Input form, and start a run. 4. Set up a daily Schedule in the Apify Console with the same input, plus an email or Slack integration so new results reach me automatically. 5. Show me how to export results as CSV/Excel, or read them from the API if I code. 6. If the results are what I wanted, remind me at the end to leave a quick rating on the actor page, and to report anything broken or missing on its Issues tab. ``` ### Input | Field | Description | | ------------------------------ | ---------------------------------------------------------------------------------------------------------------------------------------------------------- | | `vehicleType` | `car` (default), `motorbike`, `caravan` (caravans and campers) or `transporter` (vans). Same filters, same columns; caravan rows add `beds` and `persons`. | | `make` | The make, as the site's address bar spells it (`bmw`, `mercedes-benz`, `alfa-romeo`); plain spelling such as "Mercedes-Benz" works too. | | `model` | Optional model inside the make (`320`, `golf`, `c-200`). | | `country` | Which site: `de` (default), `at`, `be` (Dutch), `be-fr` (French), `nl`, `it`, `es`, `fr`, `com` (international, English). | | `listingIds` | Re-check known offers by id or address instead of searching; each read from its own page; gone offers are skipped and not billed. Up to 50. | | `priceMinEur`, `priceMaxEur` | Price band in euros. | | `yearMin`, `yearMax` | First-registration years. | | `mileageMinKm`, `mileageMaxKm` | Mileage band in km. | | `fuel` | `petrol`, `diesel`, `electric`, `hybrid_petrol`, `hybrid_diesel`, `lpg`, `cng`, `hydrogen`, `ethanol`, `other`. | | `transmission` | `automatic`, `manual`, `semi_automatic`. | | `bodyType` | `small_car`, `convertible`, `coupe`, `suv`, `estate`, `saloon`, `van`, `transporter`, `other`. | | `sellerType` | `any` (default), `dealer`, `private`. | | `postcode`, `radiusKm` | Radius search around a postcode of the chosen country (10 to 400 km). | | `sortBy` | `newest` (default), `price_asc`, `price_desc`, `mileage_asc`, `year_desc`, `relevance`. | | `maxItems` | Stop after this many offers (default 1000). | | `scrapeDetails` | Read each offer's page for the description, posting time, status and full spec sheet. One extra request per offer. | A run needs a `make` or a list of `listingIds`; anything else is optional. An unknown make or model, an inverted price or year band, or a radius without a postcode fails before the run starts, with the reason in the status message. #### Finding a make or model Open the make or model on AutoScout24 and read its address: `https://www.autoscout24.de/lst/mercedes-benz/c-200` means `make: mercedes-benz`, `model: c-200`. Capitals, spaces and accents are normalised for you ("Alfa Romeo" becomes `alfa-romeo`, "Citroën" becomes `citroen`). ### Use it from your code Run the actor and get items straight back with one HTTP call (fine for scoped runs up to ~5 minutes): ```bash curl "https://api.apify.com/v2/acts/lowlanddata~autoscout24-scraper/run-sync-get-dataset-items?token=" \ -X POST -H "Content-Type: application/json" \ -d '{"make": "bmw", "model": "320", "maxItems": 100}' ``` Node.js: ```js import { ApifyClient } from 'apify-client'; const client = new ApifyClient({ token: '' }); const run = await client.actor('lowlanddata/autoscout24-scraper').call({ make: 'bmw', model: '320', maxItems: 100, }); const { items } = await client.dataset(run.defaultDatasetId).listItems(); ``` Python: ```python from apify_client import ApifyClient client = ApifyClient("") run = client.actor("lowlanddata/autoscout24-scraper").call( run_input={"make": "bmw", "model": "320", "maxItems": 100}) items = client.dataset(run["defaultDatasetId"]).list_items().items ``` For large crawls, start the run asynchronously and fetch the dataset when the finished-run webhook fires. Schedules (e.g. a daily price snapshot), webhooks and the Make/Zapier/n8n integrations all work out of the box — this is a standard Apify actor. ### Use it with AI agents (MCP) Claude, Cursor and other MCP-capable agents can run this scraper as a tool through Apify's hosted MCP server: the agent fills in the search itself, starts the run and reads the results — no glue code. Claude Code: ```bash claude mcp add apify --transport http "https://mcp.apify.com?actors=lowlanddata/autoscout24-scraper" ``` Cursor or Claude Desktop (add a custom connector / MCP server with this URL): ```text https://mcp.apify.com?actors=lowlanddata/autoscout24-scraper ``` Sign in with your Apify account when prompted — runs are billed to it. Setup details per client: [Apify MCP docs](https://docs.apify.com/platform/integrations/mcp), or start from this actor's own MCP page: [apify.com/lowlanddata/autoscout24-scraper/api/mcp](https://apify.com/lowlanddata/autoscout24-scraper/api/mcp). Prompts that work once connected: - "Find the 50 cheapest BMW 320d from 2019 or later under 80,000 km on autoscout24.de and summarise the price range by first-registration year." - "Snapshot every private-seller Volkswagen Golf in Belgium between 8,000 and 15,000 euro and give me the median price per year." - "List today's newest Tesla offers on autoscout24.nl rated very_good or good by the site and flag any below 25,000 euro." ### Beyond the 4,000-result window AutoScout24 serves at most 200 pages of 20 offers for any one query, however many match. A run with `maxItems` within that window simply walks the pages in the order you chose. Above it, the run splits the query into price bands, as many as the order needs, so a full make of tens of thousands of offers comes through deduplicated — slower, because every band is its own paged walk, and said so in the run status. Narrow queries (a model, a year band, a region) stay inside the window and run in seconds. ### Is it legal to scrape AutoScout24? Public listing data — prices, specs, locations, photos — is public commercial information, and this scraper is built so that the hard part of the question never arises: **no personal data enters your dataset in the first place.** German, Austrian, Belgian and Dutch data-protection authorities are strict on personal data; an output that carries none is the point of this actor, not an afterthought. The output is produced by a whitelist: only named, non-personal fields are read from each offer; the seller block — name, company, contact person, phones, logo, dealer links — and the street and coordinates are never touched, for dealers as for private sellers, and a test on every build fails if any of them appears. Requests are paced, run through standard datacenter proxies, and nothing is done to defeat the site's access controls. One honest limit: titles, versions and descriptions are the seller's own words, delivered as-is. If a seller chooses to type contact details into their offer text, that text is not rewritten — the guarantee covers the data fields, not the content sellers publish about themselves. ### Is there an AutoScout24 API alternative? AutoScout24 publishes no public API for its listings. This actor is the practical alternative: the same offers as structured JSON through one HTTP call (`run-sync-get-dataset-items`), on a schedule, or as an MCP tool for AI agents — with the GDPR question already answered in the data itself. ### Does AutoScout24 block scrapers? The site serves its search results and offer pages openly to any visitor, with the data embedded in the page — and this actor stays inside that welcome: paced requests, standard datacenter proxies, load kept negligible. No CAPTCHA fights, no bot-wall cat-and-mouse — which is also why runs are fast and reliable enough for daily schedules. Should the site refuse a request anyway, the run retries on a fresh proxy exit a few times, then stops and says in its status how many offers it collected. ### How do I monitor AutoScout24 prices? Keep `sortBy: newest` with your make, model and filters, cap `maxItems` to a page or two, and add a daily (or hourly) Schedule in the Apify Console with an email/Slack integration on the runs — every new offer lands in your inbox with the price already parsed. To follow particular offers over time, put their ids into `listingIds`: each run returns their current price and status, and a sold or removed offer is reported in the log and not billed. The AI-assistant prompt above walks a non-technical user through exactly this setup. ### FAQ **Can I get seller names or phone numbers?** No — by design. That is the product: data you can store, share and process without a GDPR review. The output tells you only whether the seller is a dealer or a private person. **Does it do motorbikes, campers or vans?** Yes: set `vehicleType` to `motorbike`, `caravan` or `transporter` and search the make the same way. Those are the site's own sections (`/lst-moto`, `/lst-caravan`, `/lst-transporter`), with the same filters and the same row shape; caravan rows add berths and seats. **Which countries does it cover?** Germany, Austria, Belgium (Dutch and French), the Netherlands, Italy, Spain and France, each on its own country site, plus the international autoscout24.com in English. Switzerland's autoscout24.ch is a different platform and is not covered. **Can I get only the newest offers?** Sort by `newest` and cap `maxItems`; the site has no posting-date filter, so a daily schedule with a small cap is the way to a daily watch. With `scrapeDetails` on, every row carries `postedAt`. **How fresh is the data?** Live at run time — every run queries the site directly. For continuous freshness, schedule the actor. **Can I export to Excel or CSV?** Yes — every dataset exports as CSV, Excel, JSON or XML from the Apify Console or API. **What happens above 4,000 results?** The run splits the query by price band and walks each band, so the whole query comes through; raise `maxItems` above 4,000 to ask for it. A `maxItems` within the window walks the pages in your sort order and stops. **Do I get the full spec sheet?** Search rows carry the key specs (registration, mileage, fuel, gearbox, power, displacement, consumption, CO2). Turn on `scrapeDetails` for the offer page's description, posting time, status, net price and VAT, body, seats, doors, colour, gears, drivetrain, emission class, owners, service history, next inspection, warranty and the equipment list. **Does it work with Make, Zapier or n8n?** Yes — it is a standard Apify actor; all platform integrations, webhooks and schedules apply. ### Related scrapers Working the European second-hand car market? The same GDPR-clean guarantee, same output shape: - [Kleinanzeigen Scraper](https://apify.com/lowlanddata/kleinanzeigen-scraper) — Germany's classifieds site, cars included, with the same seller-free output. - [willhaben Car Scraper](https://apify.com/lowlanddata/willhaben-car-scraper) — Austria's car listings with make, model, mileage and fuel as columns. - [Blocket.se Car Scraper](https://apify.com/lowlanddata/blocket-car-scraper) — Sweden's car listings. ### Troubleshooting The actor fails fast with the reason in the run's status message: - **"AutoScout24 has no make or model at ..."** — spell the make and model the way the site's address bar does (`bmw`, `mercedes-benz`, `alfa-romeo`; `320`, `golf`, `c-200`), or leave `model` empty. - **"Provide a make to search (e.g. bmw), or the listingIds to re-check."** — the form was submitted without either. - **"AutoScout24 returned no readable results before anything could be fetched."** — the site refused every proxy exit tried; retry in a few minutes. - **Fewer items than requested on a free plan** — the 5-item free sample cap; run on a paid Apify plan for full results. ### Support Found an issue or missing a field you need? Open an issue on the actor's **Issues tab** — reports get fixed, this actor is actively maintained. Working well for you? A **rating on this page** takes ten seconds and helps other buyers find a GDPR-clean option among the lookalikes — it is also the clearest signal of what we should build next. # Actor input Schema ## `vehicleType` (type: `string`): Cars (default), motorbikes, caravans and campers, or transporters and vans: each is its own part of the site with the same filters and the same row shape. Motorbike rows carry no body type; caravan rows add berths and seats. ## `make` (type: `string`): The car make to search, as AutoScout24 spells it in its address bar: bmw, mercedes-benz, alfa-romeo, volkswagen. Plain spelling works too ("Mercedes-Benz", "Alfa Romeo"). Leave it out only when you re-check offers through listingIds. ## `model` (type: `string`): Optional model inside the make, as the address bar spells it: 320, golf, c-200, x5. Leave empty for every model of the make. ## `country` (type: `string`): Which AutoScout24 site to read. Each lists the offers of its own country, with labels in its language; com is the international site with every country's offers in English. ## `listingIds` (type: `array`): Re-check offers you already know instead of searching: one offer ID per line (the long id at the end of every offer address, and the listingId of every dataset item), or the offer's full address. Each one is read from its own page, so it carries the description, the posting time, the site's own status and the full spec sheet. An offer that is gone from the site is skipped, named in the log and not billed. When given, the search fields of this form are ignored and the run status says which; country still picks the site. Up to 50. ## `priceMinEur` (type: `integer`): Only include offers priced at least this many euros. ## `priceMaxEur` (type: `integer`): Only include offers priced at most this many euros. ## `yearMin` (type: `integer`): Only include cars first registered in this year or later, e.g. 2018. ## `yearMax` (type: `integer`): Only include cars first registered in this year or earlier. ## `mileageMinKm` (type: `integer`): Only include cars with at least this many kilometres. ## `mileageMaxKm` (type: `integer`): Only include cars with at most this many kilometres, e.g. 100000. ## `fuel` (type: `string`): Only include cars running on this fuel. Leave empty for any. ## `transmission` (type: `string`): Only include cars with this gearbox. Leave empty for any. ## `bodyType` (type: `string`): Only include this body type. Leave empty for any. ## `sellerType` (type: `string`): Dealers only, private sellers only, or both. ## `postcode` (type: `string`): Centre of a radius search, a postcode of the chosen country site, e.g. 10115. Needs radiusKm to have an effect. ## `radiusKm` (type: `integer`): Only include offers within this many kilometres of the postcode. The site accepts 10 to 400. ## `sortBy` (type: `string`): Order of results: newest (best for monitoring), price_asc, price_desc, mileage_asc, year_desc, or relevance (the site's own order). ## `maxItems` (type: `integer`): Stop after this many offers. Free-plan runs are capped at 5 items. The form starts at 25 for a cheap first run - that is the form's prefill, not a cap on your plan; clear it to use the default of 1000. The site serves 4,000 offers per query; above that the run splits the query by price band to reach the rest. ## `scrapeDetails` (type: `boolean`): The search row carries the price, the key specs and the photos but no description and no posting time. Turn this on to read each offer's own page for the seller's description, the posting time, the site's own status, the net price and VAT, body, seats, doors, colour, gears, drivetrain, emission class, owners, service history, next inspection and the equipment list. One extra request per offer, so a run is slower. Seller name, phone, street and coordinates are never read. ## `proxyConfiguration` (type: `object`): Proxy settings. Keep Apify proxy enabled. ## `reportFailures` (type: `boolean`): When a run fails, send the developer the actor name and build, an error category, the error message (truncated) and a one-way hash of your input - so a bug can be fixed without anyone asking you to reproduce it. Your input itself, your results and your identity are never sent, and successful runs send nothing at all. Switch this off and the actor behaves exactly the same. ## Actor input object example ```json { "vehicleType": "car", "make": "bmw", "country": "de", "listingIds": [], "sellerType": "any", "sortBy": "newest", "maxItems": 25, "scrapeDetails": false, "proxyConfiguration": { "useApifyProxy": true }, "reportFailures": true } ``` # Actor output Schema ## `offers` (type: `string`): Scraped AutoScout24 car offers, one JSON object per offer. # API You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup. ## JavaScript example ```javascript import { ApifyClient } from 'apify-client'; // Initialize the ApifyClient with your Apify API token // Replace the '' with your token const client = new ApifyClient({ token: '', }); // Prepare Actor input const input = { "vehicleType": "car", "make": "bmw", "country": "de", "listingIds": [], "sellerType": "any", "sortBy": "newest", "maxItems": 25, "proxyConfiguration": { "useApifyProxy": true } }; // Run the Actor and wait for it to finish const run = await client.actor("lowlanddata/autoscout24-scraper").call(input); // Fetch and print Actor results from the run's dataset (if any) console.log('Results from dataset'); console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`); const { items } = await client.dataset(run.defaultDatasetId).listItems(); items.forEach((item) => { console.dir(item); }); // 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs ``` ## Python example ```python from apify_client import ApifyClient # Initialize the ApifyClient with your Apify API token # Replace '' with your token. client = ApifyClient("") # Prepare the Actor input run_input = { "vehicleType": "car", "make": "bmw", "country": "de", "listingIds": [], "sellerType": "any", "sortBy": "newest", "maxItems": 25, "proxyConfiguration": { "useApifyProxy": True }, } # Run the Actor and wait for it to finish run = client.actor("lowlanddata/autoscout24-scraper").call(run_input=run_input) # Fetch and print Actor results from the run's dataset (if there are any) print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}") for item in client.dataset(run.default_dataset_id).iterate_items(): print(item) # 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start ``` ## CLI example ```bash echo '{ "vehicleType": "car", "make": "bmw", "country": "de", "listingIds": [], "sellerType": "any", "sortBy": "newest", "maxItems": 25, "proxyConfiguration": { "useApifyProxy": true } }' | apify call lowlanddata/autoscout24-scraper --silent --output-dataset ``` ## MCP server setup ```json { "mcpServers": { "apify": { "type": "http", "url": "https://mcp.apify.com/?tools=fetch-actor-details,lowlanddata/autoscout24-scraper" } } } ``` The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer ` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations). ## OpenAPI specification Download the OpenAPI definition: https://api.apify.com/v2/actors/A7r6JR0QZPeMVoD3o/builds/n9wP9Qs5asY5awckI/openapi.json