# Auto-Data.net Scraper: Car Specs by Brand and Model (`mrbridge/auto-data-scraper`) Actor Scrape auto-data.net car specs for any brand or model: power, torque, 0-100 km/h, top speed, dimensions, weight, fuel consumption, CO2, battery and electric range. One row per engine variant across every generation, with the full spec sheet. Export JSON, CSV or Excel, or call it via API. - **URL**: https://apify.com/mrbridge/auto-data-scraper.md - **Developed by:** [MrBridge](https://apify.com/mrbridge) (community) - **Categories:** Automation, Developer tools, AI - **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks - **User rating**: No ratings yet ## Pricing from $3.00 / 1,000 car specs 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 ## Auto-Data.net Scraper Auto-Data.net Scraper reads car technical specifications from auto-data.net and returns one clean row per engine variant. Type a brand such as `Audi`, or a list of models such as `Audi RS3` and `Audi TT`, and get power, torque, 0-100 km/h, top speed, weight, dimensions, fuel economy, gearbox, brakes and tyres for every generation. Each row also carries the complete spec sheet exactly as auto-data.net publishes it. Export to JSON, CSV or Excel, with no API key and no HTML parsing on your side. ### What is Auto-Data.net Scraper? Auto-Data.net Scraper turns a brand or a model name into the full list of its engine variants on auto-data.net, opens each variant page and saves a structured record in an Apify dataset. The only source it reads is auto-data.net. Auto-Data.net Scraper supports the following: - **Scrape a whole brand**: one entry like `Audi` expands to every model, generation and engine variant. - **Scrape a model list**: `Audi TT` expands to all TT generations and engine variants. Mix several models in one run. - **One row per variant**: power, torque, acceleration, top speed, dimensions, weight, fuel economy, transmission and chassis, normalized to metric units. - **Full spec sheet on every row**: the `rawSpecs` array keeps every label and value of the variant page, in page order, so nothing the site publishes is lost to the flat columns. - **Electric and hybrid variants**: system power and torque, gross battery capacity and all-electric range, filled only where auto-data.net publishes them. #### What data can I extract with Auto-Data.net Scraper? | Group | Example fields | |---|---| | Performance | 0-100 km/h, 0-60 mph, top speed, power-to-weight | | Engine | power (hp and kW), torque, displacement, cylinders, valves, compression, fuel type | | Transmission | drive wheels, gearbox type, number of gears | | Dimensions | length, width, height, wheelbase, kerb weight, drag coefficient | | Electric and hybrid | system power and torque, gross battery capacity, all-electric range | | Fuel economy | combined consumption, CO2 and its test standard, fuel tank | | Chassis | front and rear brakes, suspension, steering | #### How can I use data scraped from a car reference site? Build pricing and residual-value models, power a vehicle comparison or a configurator, feed a performance database or an enthusiast site, enrich a dealer or marketplace catalog, or run engineering and market research across a whole brand history. Because the output is one tidy row per variant, it drops straight into a spreadsheet, a database or a BI tool. ### How to use Auto-Data.net Scraper Here's how to use Auto-Data.net Scraper in 5 steps: 1. Create a free [Apify account](https://apify.com/sign-up) using your email. 2. Open [Auto-Data.net Scraper](https://apify.com/mrbridge/auto-data-scraper). 3. Pick the **Input mode** (Brand or Model names list), then choose a brand (for example `Audi`) or list models (for example `Audi RS3`). Optionally set a year range or a max items cap. 4. Click the **Start** button and wait for the data to be extracted. 5. Download your data in JSON, XML, CSV, Excel or HTML. ### How much will scraping car data cost you? Auto-Data.net Scraper uses a **pay-per-event** pricing model. - **Car specs**: from $0.003 to $0.005 per variant depending on your Apify subscription tier, which is $3 to $5 per 1,000 variants. One event is charged for each engine-variant record saved to the dataset, with its full spec sheet. - **Actor Start**: the standard Apify event, charged once for every run. - **Error rows are never charged.** A row carrying `_error: true` is returned for visibility and does not trigger the Car specs event. See the [Pricing tab](https://apify.com/mrbridge/auto-data-scraper/pricing) for the current prices. You can cap the spend of any single run from the Apify Console with `ACTOR_MAX_TOTAL_CHARGE_USD`, and the `maxItems` input gives you a hard limit on how many variants are emitted. ### ⬇️ Input The input is a JSON object that says which brand or models to scrape, plus optional filters. See the [Input tab](https://apify.com/mrbridge/auto-data-scraper/input-schema) for the full schema with all fields and defaults. #### Auto-Data.net Scraper input examples Scrape a list of specific models (set `inputMode` to `models`): ```json { "inputMode": "models", "models": ["Audi RS3", "Audi TT"], "yearMin": 2015, "maxItems": 200 } ``` Scrape a whole brand (set `inputMode` to `brand`): ```json { "inputMode": "brand", "brand": "Audi", "maxItems": 500 } ``` Only the field matching `inputMode` is used, the other is ignored. Always set `inputMode` to match how you are targeting cars. - `models` entries are always written as `Brand Model`, for example `Audi RS3`. A model typed without its brand is ignored. - `yearMin` and `yearMax` (inclusive) filter variants after the generation pages are read, so they narrow the output but do not make a run shorter. - `excludeModels` matches **exact** model names, case-insensitively. Enter either the model (`TT`) or make and model (`Audi TT`). Excluding `TT` does not exclude `TTS`. - `maxItems` defaults to 1000. Through the API you can set it to `0` to remove the record cap, but only on a run that has a timeout, otherwise the input is rejected. Options that belonged to the multi-source Car Data Scraper (`sources`, `extraSources`, `sourcePriority`, `conflictThresholdPct`) are still accepted by the API so existing integrations do not break. They are ignored, and the run log carries one warning per key. #### Calling the Actor from the API Use `apify-client` for Node.js or Python to start a run and read the dataset. Python example: ```python from apify_client import ApifyClient client = ApifyClient("") run = client.actor("mrbridge/auto-data-scraper").call( run_input={"inputMode": "models", "models": ["Audi RS3"], "maxItems": 50} ) for item in client.dataset(run["defaultDatasetId"]).iterate_items(): print(item["modification"], item["powerHp"], item["zeroToHundredS"]) ``` ### ⬆️ Output Auto-Data.net Scraper stores results in a dataset, one record per engine variant. Each row carries flat summary columns for browsing, filtering and spreadsheet export, a set of nested sections that keep the unit of each value, and the complete spec sheet in `rawSpecs`. Rows are written **as each model completes**, not in one block at the end, so a long brand run fills its dataset progressively and a run you stop early keeps everything already produced. A run that reaches its time budget stops on its own, shortly before the platform timeout, and finishes as a normal successful run with a partial dataset. An `OUTPUT` record in the key-value store says how the run ended, how many records it delivered and which model was the last one fully completed. It is the thing to share when reporting a problem. #### Dataset views The Output tab offers five views. | View | What it shows | |---|---| | `overview` | Make, model, generation, modification, years, fuel type, engine size, power, torque, 0-100 km/h, top speed, `url` | | `performance` | Power and its basis, 0-100 km/h, 0-60 mph and how it was obtained, top speed, power-to-weight, electric range | | `detailed` | All the flat columns listed below except `zeroToSixtyMphS`, `zeroToSixtyMphMethod` and `powerToWeightHpPerT`, which are in `performance` | | `fullSpecSheet` | Identification columns, `url` and the `rawSpecs` array | | `errors` | Error rows only: `error`, `errorMessage`, `source`, `url`, `scrapedAt` | #### Flat columns - **Identity**: `make`, `model`, `generation`, `modification`, `yearStart`, `yearEnd`, `bodyType`, `doors`, `seats`, `canonicalVariantId`, `url`, `autodataId`, `scrapedAt`. - **Engine**: `fuelType`, `engineCc`, `powerHp`, `powerKw`, `torqueNm`, `powerBasis`, `torqueBasis`, `cylinders`, `valves`, `compression`. - **Electric and hybrid**: `batteryCapacityKwh`, `electricRangeKm`. - **Performance**: `zeroToHundredS`, `topSpeedKmh`, `zeroToSixtyMphS`, `zeroToSixtyMphMethod`, `powerToWeightHpPerT`. - **Drivetrain**: `transmission`, `gears`, `driveType`. - **Dimensions and weight**: `lengthMm`, `widthMm`, `heightMm`, `wheelbaseMm`, `curbWeightKg`. - **Fuel economy**: `fuelConsumptionL100`, `co2GKm`, `co2Standard`. Values auto-data.net does not publish for a variant are `null`. Nothing is estimated or read out of the variant name. On an electric, plug-in hybrid or full hybrid, auto-data.net prints the total output under `System power` and `System torque`, separately from the `Power` row of the combustion engine. `powerHp` and `torqueNm` carry the system figure whenever the page prints one. `powerBasis` and `torqueBasis` tell you which row was used on every row, and the nested `engine` section keeps both as published. #### Nested sections `performance`, `engine`, `transmissionDetail`, `dimensions`, `fuelEconomy` and `chassis` hold one entry per field, each with its `value`, a canonical `unit` where it applies and `source`, which is always `autodata`. #### The `rawSpecs` array `rawSpecs` is the full spec sheet of the variant page: an array of `{ "label": ..., "value": ... }` entries in page order, with repeated labels kept. Entries with no value are omitted, and so are the entries auto-data.net replaces with `Log in to see.` for visitors who are not signed in. Error rows have no `rawSpecs`. Because `rawSpecs` is an array, a CSV export flattens it into numbered columns (`rawSpecs/0/label`, `rawSpecs/0/value`, and so on), which makes a wide and hard-to-read file. **Prefer JSON when you need the full spec sheet.** For CSV or Excel, use the flat columns or the `overview`, `performance` and `detailed` views. #### Sample output A real row from an `Audi RS3` run, shortened for this page: the nested sections `engine`, `transmissionDetail`, `dimensions`, `fuelEconomy` and `chassis` are left out, and `rawSpecs` shows its first 4 entries out of 68. ```json { "make": "Audi", "model": "RS3", "generation": "RS3 Sportback (8Y, facelift 2024)", "modification": "2.5 TFSI (400 Hp) quattro S tronic", "yearStart": 2024, "yearEnd": null, "bodyType": "Hatchback", "doors": 5, "seats": 5, "canonicalVariantId": "audi-rs3-hatchback-2.5l-400hp-2024", "url": "https://www.auto-data.net/en/audi-rs3-sportback-8y-facelift-2024-2.5-tfsi-400hp-quattro-s-tronic-52529", "autodataId": "52529", "fuelType": "Petrol (Gasoline)", "engineCc": 2480, "powerHp": 400, "powerKw": null, "torqueNm": 500, "powerBasis": "engine", "torqueBasis": "engine", "batteryCapacityKwh": null, "electricRangeKm": null, "cylinders": 5, "valves": 4, "compression": "10:1", "zeroToHundredS": 3.8, "topSpeedKmh": 250, "zeroToSixtyMphS": 3.6, "zeroToSixtyMphMethod": "calculated", "powerToWeightHpPerT": 255.6, "transmission": "automatic transmission S tronic", "gears": 7, "driveType": "All wheel drive (4x4)", "lengthMm": 4381, "widthMm": 1851, "heightMm": 1430, "wheelbaseMm": 2631, "curbWeightKg": 1565, "fuelConsumptionL100": 9.3, "co2GKm": 211, "co2Standard": "WLTP", "scrapedAt": "2026-10-19T20:55:57.576Z", "performance": { "accel_0_100_kmh": { "value": 3.8, "unit": "s", "source": "autodata" }, "accel_0_60_mph": { "value": 3.6, "unit": "s", "source": "autodata", "measurementKind": "calculated" }, "top_speed_kmh": { "value": 250, "unit": "km/h", "source": "autodata" }, "power_to_weight_hp_per_t": { "value": 255.6, "unit": "hp/t", "source": "autodata" } }, "rawSpecs": [ { "label": "Brand", "value": "Audi" }, { "label": "Model", "value": "RS3" }, { "label": "Generation", "value": "RS3 Sportback (8Y, facelift 2024)" }, { "label": "Modification (Engine)", "value": "2.5 TFSI (400 Hp) quattro S tronic" } ] } ``` #### Differences from Car Data Scraper Auto-Data.net Scraper keeps the same name, type and value for every column it shares with [Car Data Scraper](https://apify.com/mrbridge/car-data-scraper), so a pipeline built on the multi-source Actor reads these rows without change. The differences: - **Removed** (they only exist when several sources are merged): `sources`, `conflicts`, `dedupeConfidence`, `sourcesDetail`, `flags`, `quarterMileS`, `peakG`. The `alternatives` entries of the nested fields are gone for the same reason. - **Added**: `url` (the auto-data.net page of the variant), `autodataId` (its identifier, as text) and `rawSpecs` (the full spec sheet). For programmatic access in Python, Node.js or PHP, see the [Apify API reference](https://docs.apify.com/api/v2). ### Known limitations - **One source.** Every figure is reported as auto-data.net publishes it. Values are normalized to metric units, but regional and market differences are not reconciled. - **No market or region field.** auto-data.net describes each variant by generation and chassis code (for example 8V or 8Y), not by sales market. - **Coverage depends on the site.** A model or generation page that cannot be read comes back as an error row (not charged), and the rest of the run carries on. - **Run time follows the number of variants.** A whole-brand pull can walk hundreds of variants and take several minutes. Use **Max items** to bound a run. - **Use autodataId as the row key.** autodataId and url are unique per variant. canonicalVariantId groups variants that share make, model, body, engine size, power and start year, so variants that differ only by gearbox, drive or fuel share one id. Use it to group rows, not to deduplicate them. - **Ranges keep their lower figure.** When auto-data.net prints a range, such as "9-9.5 l/100 km" or "520-534 km", fuelConsumptionL100, co2GKm and electricRangeKm hold the first figure, the lower one. The full range stays in rawSpecs. - **powerKw is always empty.** auto-data.net prints power in horsepower, the Actor reads no kilowatt row and never converts powerHp, so the column stays empty. Use powerHp. - **Battery capacity is the gross figure.** batteryCapacityKwh reads the gross capacity. A page that prints only the net (usable) capacity, as some Tesla pages do, leaves it empty, and the net figure stays in rawSpecs. - **An empty zeroToSixtyMphMethod means the page carries no calculation note.** The column says calculated when auto-data.net marks the 0-60 mph time as computed by the site, and stays empty otherwise. - **Electric consumption is in rawSpecs only.** Electric cars have no fuel consumption or CO2 figure, and their energy consumption in kWh/100 km is not a flat column. Read it from rawSpecs. - **Old cars have sparse pages.** Pages of cars from the 1970s, such as the Alpine 1300 and 1600, carry about a dozen figures, so many columns stay empty. These rows are billed like any other. - **Production years are copied as printed.** auto-data.net can contradict itself, for example an end of production before its start on the Audi 100 C3 2.3 E Automatic. The Actor does not correct it. - **Pages are cached in your account for 30 days.** Variant pages already read are kept in a key-value store named auto-data-html-cache in your Apify account, so a later run on the same models does not fetch them again. A cached page can be up to 30 days old. The store outlives the run and counts towards your storage usage. You can delete it at any time from Storage, and the next run starts a new one. The `scrapedAt` column is the time the row was emitted, so a row built from a cached page can rest on a page up to 30 days old. The cache saves requests to auto-data.net and not run time, because the list pages (brand, model, generation) are read again on every run. In a measured rerun of Audi RS3 with its 8 variant pages already cached, the run was not faster than the first one. ### Frequently asked questions #### How does Auto-Data.net Scraper work? It resolves each requested brand or model into its list of generations and engine variants on auto-data.net, reads each variant page, normalizes the values to metric units and saves one row per variant. Variant pages already read are kept for 30 days in the auto-data-html-cache store of your account, so repeated runs on the same models are lighter on the source. #### What is the difference between Auto-Data.net Scraper and Car Data Scraper? Auto-Data.net Scraper reads auto-data.net only and returns one row per variant with the full spec sheet. [Car Data Scraper](https://apify.com/mrbridge/car-data-scraper) is the multi-source version: it merges several sources into one consolidated row and traces every value back to where it came from. #### Why are some `rawSpecs` entries missing? Entries with no value are dropped, and so are the entries auto-data.net hides behind `Log in to see.` for visitors who are not signed in. The Actor never signs in. #### Can I integrate Auto-Data.net Scraper with other apps? Yes. Results can flow into Make, Zapier, n8n, Google Sheets, Looker Studio or Power BI through Apify's integrations, or be pulled directly with the Apify API. #### Can I use Auto-Data.net Scraper as its own API? Yes. Use `apify-client` for Node.js or Python to start runs and fetch the dataset. See the API tab on the Actor page. #### Can I use Auto-Data.net Scraper via MCP? Yes. Auto-Data.net Scraper can be accessed by AI assistants like Claude or ChatGPT through the Apify MCP server. Go to the **MCP tab** on the Actor page for setup, or connect to [mcp.apify.com](https://mcp.apify.com) and add Auto-Data.net Scraper as a tool. #### Your feedback We're always working on improving the performance of our Actors. So if you've got any technical feedback for Auto-Data.net Scraper or simply found a bug, please create an issue on the Actor's [Issues tab](https://apify.com/mrbridge/auto-data-scraper/issues). More free tools, scrapers, MCP servers and data studies from the same team: [mr-bridge.com](https://mr-bridge.com). ### Related Actors - [Car Data Scraper](https://apify.com/mrbridge/car-data-scraper): the multi-source version, which merges several car data sources into one consolidated row per variant. ### Legal & responsible use Auto-Data.net Scraper extracts vehicle technical specifications, which are factual data, not personal data. It does not extract names, contact details or any private user information. auto-data.net has its own terms of use, and it may restrict automated access or commercial reuse. Before you rely on the output, in particular for commercial use, confirm that your use is permitted by those terms. We believe that scraping public factual data for ethical purposes is safe. You remain responsible for how you use the results and for complying with the source's terms and with the laws that apply to you. If you're unsure whether your use is legitimate, consult your lawyers. You can also read the Apify blog post on the [legality of web scraping](https://blog.apify.com/is-web-scraping-legal/). # Changelog This Actor's version history is a separate document: https://apify.com/mrbridge/auto-data-scraper/changelog.md # Actor input Schema ## `inputMode` (type: `string`): Choose what to scrape. 'Brand' uses the Brand menu below to scrape every model of one make. 'Model names list' uses the Models field below to scrape only the specific models you list. Both fields stay visible (Apify forms cannot hide fields), but only the one matching this choice is used. ## `brand` (type: `string`): Pick a car brand to scrape. The Actor returns all its models and engine variants. Used only when Input mode is 'Brand'; to target specific models, set Input mode to 'Model names list' and use the Models field. ## `models` (type: `array`): Specific models to scrape, one entry per model, ALWAYS written as 'Brand Model' with the make included. For example write 'Audi RS3', not 'RS3' on its own: a model typed without its brand is ignored. Each entry expands to all generations and engine variants for that model. Used only when Input mode is 'Model names list'. ## `yearMin` (type: `integer`): Earliest production year to include (inclusive). Leave empty for no lower bound. ## `yearMax` (type: `integer`): Latest production year to include (inclusive). Leave empty for no upper bound. ## `excludeModels` (type: `array`): Exact model names to exclude, case-insensitive. Enter either the model name (TT) or make and model (Audi TT). TT does not exclude TTS. ## `maxItems` (type: `integer`): Maximum number of records. Run time depends on how many variants a model or brand carries, not on this number alone: a model with many generations can take several minutes even at a low cap. Keep the total within your run timeout. ## Actor input object example ```json { "inputMode": "models", "brand": "Audi", "models": [ "Audi RS3" ], "maxItems": 20 } ``` # Actor output Schema ## `variants` (type: `string`): Direct link to all dataset items produced by the run. # 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 = { "inputMode": "models", "brand": "Audi", "models": [ "Audi RS3" ], "maxItems": 20 }; // Run the Actor and wait for it to finish const run = await client.actor("mrbridge/auto-data-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 = { "inputMode": "models", "brand": "Audi", "models": ["Audi RS3"], "maxItems": 20, } # Run the Actor and wait for it to finish run = client.actor("mrbridge/auto-data-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 '{ "inputMode": "models", "brand": "Audi", "models": [ "Audi RS3" ], "maxItems": 20 }' | apify call mrbridge/auto-data-scraper --silent --output-dataset ``` ## MCP server setup ```json { "mcpServers": { "apify": { "type": "http", "url": "https://mcp.apify.com/?tools=fetch-actor-details,mrbridge/auto-data-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/15ONfjK56VmPaW0US/builds/PWIsGwIzgf6dX6TRH/openapi.json