# Car data scraper: specs, 0-60 times and power (`mrbridge/car-data-scraper`) Actor Extract consolidated car specs and performance for any brand or model: power, torque, 0-60 mph, top speed and full technical data. auto-data is the backbone, three more sources enrich a variant when they match, and every value carries its source. By MrBridge - **URL**: https://apify.com/mrbridge/car-data-scraper.md - **Developed by:** [MrBridge](https://apify.com/mrbridge) (community) - **Categories:** Automation, Developer tools, AI - **Features:** Limited permissions - **Stats:** 23 total users, 4 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 ## Car Data Scraper [![Watch the Car Data Scraper video walkthrough](https://img.youtube.com/vi/l49ZOC5Snnc/maxresdefault.jpg)](https://youtu.be/l49ZOC5Snnc) Car Data Scraper builds one consolidated technical and performance record per car variant. auto-data.net is the backbone catalogue and supplies the full spec sheet for every variant. Three further sources enrich it conditionally: carperformancedata.com is on by default, ultimatespecs.com and zeperfs.com are opt-in. Ask for a whole brand or a list of models and get a clean, deduplicated row for every engine variant, with each value traced back to the source it came from. Type `Audi` (or a list like `Audi RS3`, `Audi TT`) and get back one row per variant with power, torque, 0-100 km/h, top speed, weight, dimensions, fuel economy, gearbox, brakes and tyres, plus a per-field source tag and a conflict flag when two sources disagree. A full brand pull exports straight to JSON, CSV or Excel, no API key and no HTML parsing on your side. ### Features - **One consolidated row per car variant.** auto-data.net is the backbone catalogue. Up to three more sources are matched onto it by a make, model, displacement, power and years fingerprint: carperformancedata.com (on by default), ultimatespecs.com and zeperfs.com (opt-in). - **Every value traced to its source.** Each numeric or text field carries its `value`, its canonical `unit` and the `source` it was read from. - **Conflicts are kept, not hidden.** When sources disagree beyond a built-in tolerance, the highest-priority source gives the reference value, the others stay under `alternatives`, and `hasConflict` plus the maximum deviation is recorded. - **Brand runs or model lists.** Type `Audi` or a list such as `Audi RS3`, `Audi TT`, and get every generation and engine variant. - **Year filter that saves pages.** With `yearMin` or `yearMax`, generations that lie entirely outside your years are skipped before their variant pages are fetched. - **Electric and hybrid aware.** `powerHp` and `torqueNm` carry the system figure when the page prints one, and `powerBasis` and `torqueBasis` say which row was used. - **Rows arrive as each model completes.** A run you stop early keeps what it already delivered, and a run that reaches its time budget ends as a normal partial success with an `OUTPUT` record that says how it ended. - **Checked on a real run.** See the [Benchmarks](#benchmarks) for a measured `Audi RS3` run, 8 variants with 0 errors. - **Plain exports.** JSON, CSV, Excel, XML or HTML from the dataset, or the [Apify API](https://docs.apify.com/api/v2), with no API key of your own for the sources and no HTML parsing on your side. ### What is Car Data Scraper? Car Data Scraper resolves a brand or model into its full list of engine variants, scrapes each one from every enabled source, then matches and merges the results into a single consolidated row per physical variant. auto-data.net acts as the backbone catalog; the other sources enrich and cross-check its data. For the raw auto-data.net spec sheet of every engine variant, use the [auto-data.net car specs scraper](https://apify.com/mrbridge/auto-data-scraper). The consolidated model is built so you can trust and audit every figure: each field carries the source it came from, competing values from other sources are kept as alternatives, and a `hasConflict` flag is raised when numeric values diverge beyond a built-in tolerance. Car Data 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, from a backbone plus enrichment**: power, torque, acceleration, top speed, dimensions, weight, fuel economy, transmission and chassis, read from auto-data.net and merged with whichever extra sources are enabled. - **Trace and reconcile every value**: per-field source tag, alternative values, and a conflict flag with the maximum deviation between sources. #### What data can I extract with Car Data Scraper? | Group | Example fields | |---|---| | ⚡ Performance | 0-100 km/h, 0-60 mph, quarter mile, top speed, power-to-weight, peak G | | 🔧 Engine | power (hp / kW), torque, displacement, cylinders, aspiration, fuel type | | ⚙️ Transmission | drive wheels, gearbox type, number of gears | | 📏 Dimensions | length, width, height, wheelbase, kerb weight, drag coefficient | | 🔌 Electric & hybrid | system power and torque, electric motor output, gross battery capacity, all-electric range | | ⛽ Fuel economy | combined / urban / extra-urban consumption, CO2, fuel tank | | 🛞 Chassis | front / rear brakes, tyres, suspension, steering | #### How can I use data scraped from car reference sites? Build pricing and residual-value models, power a vehicle comparison or configurator, feed a performance database or enthusiast site, enrich a dealer or marketplace catalog, or run engineering and market research across an entire 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 Car Data Scraper Here's how to use Car Data Scraper in 5 steps: 1. Create a free [Apify account](https://apify.com/sign-up) using your email. 2. Open [Car Data Scraper](https://apify.com/mrbridge/car-data-scraper). 3. Pick the **Input mode** (Brand or Model names list), then add a brand (for example `Audi`) or a list of models (for example `Audi TT`), and 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. Prefer to watch? The [six-minute walkthrough](https://youtu.be/l49ZOC5Snnc) covers the input form, a live run, the four result views and the export. ### How much will scraping car data cost you? Car Data Scraper uses a **pay-per-event** pricing model. You are charged once per car data record saved to the dataset: one engine-variant record successfully extracted from auto-data.net, including any fields successfully matched from enabled enrichment sources, with per-field source traceability. Unavailable, failed, or unmatched enrichment sources may be absent. Error rows do not trigger the **Car data** event. The standard **Actor Start** event is charged separately for every run. See the [Pricing tab](https://apify.com/mrbridge/car-data-scraper/pricing) for the full price table by Apify subscription tier (Free, Starter, Scale, Business), where higher tiers unlock automatic discounts. 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. As a rule of thumb, a single-model run (a few dozen variants) costs roughly $0.10 to $0.30, and a full brand a few dollars; the exact figure depends on your subscription tier. ### ⬇️ Input The input is a JSON object specifying which brands or models to scrape, plus optional filters and source settings. See the [Input tab](https://apify.com/mrbridge/car-data-scraper/input-schema) for the full schema with all fields and defaults. #### Car Data 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. Year bounds and an `excludeModels` filter are available under Advanced options. `excludeModels` matches **exact** model names, case-insensitively: enter either the model (`TT`) or make and model (`Audi TT`). Excluding `TT` does not exclude `TTS`. Every run needs at least one limit. Through the API you can set `maxItems` to `0` to remove the record cap, but only on a run that has a timeout, otherwise the input is rejected: with neither limit nothing would ever stop the walk. Leaving `maxItems` empty means the default cap, not "no cap". ### ⬆️ Output Car Data Scraper stores results in a dataset, one car data record per row. Each numeric or text field is an object carrying its `value`, canonical `unit`, the `source` the reference value came from, and any `alternatives` from other sources. Error rows (carrying `_error: true`) are returned for visibility and do not trigger the **Car data** event. 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. It writes an `OUTPUT` record to the key-value store saying how it ended, how many records it delivered and which model was the last one fully completed. That record is written on every ending the Actor controls, and is the thing to share when reporting a problem. For programmatic access in Python, Node.js or PHP, see the [Apify API reference](https://docs.apify.com/api/v2). #### Sample output ![Sample output of Car Data Scraper for the input Audi RS3: make, model, generation, modification, years, fuel, power in hp, torque in Nm, 0-100 km/h time and top speed for 8 vehicle variants](https://api.apify.com/v2/key-value-stores/5gTeWNmoJiKNnfYoz/records/car-data-scraper-output.png) A real row from an `Audi RS3` run, which returns 8 variants across four generations (8PA to 8Y). This one is consolidated from two sources: auto-data.net supplies the full spec sheet, and carperformancedata.com adds measured performance (quarter mile, peak G) and disagrees on the 0-60 mph time, which is kept as a `conflict` with both values. Each row carries flat summary columns (for easy browsing, filtering and spreadsheet export), a stable `canonicalVariantId`, a numeric `dedupeConfidence`, plus nested sections that keep the per-field source and alternative values. ```json { "canonicalVariantId": "audi-rs3-sedan-2.5l-400hp-2021", "make": "Audi", "model": "RS3", "generation": "RS3 Sedan (8Y)", "modification": "2.5 TFSI (400 Hp) quattro S tronic", "yearStart": 2021, "yearEnd": 2024, "bodyType": "Sedan", "powerHp": 400, "torqueNm": 500, "zeroToHundredS": 3.8, "topSpeedKmh": 250, "engineCc": 2480, "cylinders": 5, "transmission": "automatic transmission S tronic", "driveType": "All wheel drive (4x4)", "curbWeightKg": 1575, "fuelConsumptionL100": 8.9, "co2GKm": 201, "sources": ["autodata", "carperformancedata"], "dedupeConfidence": 0.99, "scrapedAt": "2026-06-25T13:04:06.431Z", "engine": { "power_hp": { "value": 400, "unit": "hp", "source": "autodata", "alternatives": [{ "value": 401, "source": "carperformancedata" }] }, "engine_code": { "value": "EA855 evo / DNWC", "source": "autodata" } }, "performance": { "accel_0_100_kmh": { "value": 3.8, "unit": "s", "source": "autodata" }, "accel_0_60_mph": { "value": 3.6, "unit": "s", "source": "autodata", "alternatives": [{ "value": 3.4, "source": "carperformancedata" }] }, "quarter_mile_s": { "value": 11.7, "unit": "s", "source": "carperformancedata" }, "peak_g": { "value": 0.982, "source": "carperformancedata" } }, "sourcesDetail": [ { "source": "autodata", "sourceUrl": "https://www.auto-data.net/en/audi-rs3-sedan-8y-2.5-tfsi-400hp-quattro-s-tronic-44004" }, { "source": "carperformancedata", "sourceUrl": "https://carperformancedata.com/cars/37", "upstreamSourceName": "Car and Driver", "upstreamSourceUrl": "https://www.caranddriver.com" } ], "flags": { "hasConflict": true, "conflicts": [{ "field": "accel_0_60_mph", "maxDeviationPct": 5.9, "values": [{ "value": 3.6, "source": "autodata" }, { "value": 3.4, "source": "carperformancedata" }] }], "matchConfidence": { "autodata": "exact", "carperformancedata": "exact", "ultimatespecs": "none", "zeperfs": "none" } } } ``` `sourcesDetail` records the exact page read on each source. carperformancedata.com republishes measurements taken by someone else and credits that publication on some of its records, so its entries also carry an original-source attribution, `upstreamSourceName` and `upstreamSourceUrl`, when provided by carperformancedata.com. Those two describe the upstream publication, not the carperformancedata.com page in `sourceUrl`, and both are simply absent on records that credit no one. The other three sources publish no such credit. Flat summary columns also include `fuelType`, `powerKw`, `valves`, `gears`, `lengthMm`, `widthMm`, `heightMm`, `wheelbaseMm`, `doors`, `seats` and more, each mirrored by a fully traced entry in the `engine`, `transmissionDetail`, `dimensions`, `fuelEconomy` and `chassis` sections. ### Benchmarks A measured run on the current build, input `Audi RS3`: - **8 variants** returned, one per RS3 generation from the 8PA (340 hp, 2011) to the 8Y facelift (400 hp, 2024), in **33 seconds** for about **$0.04**, with **0 errors**. - The current-generation Sedan is cross-checked against carperformancedata.com, which adds a measured quarter mile and peak G and surfaces a 0-60 mph conflict (3.6 s vs 3.4 s) instead of silently picking one value. - Every row carries a stable `canonicalVariantId` and, when a second source is merged, a numeric `dedupeConfidence` (0.99 on the cross-checked row). The id groups a variant across runs, it does not identify one uniquely: variants differing only in fuel, gearbox or door count share it. For a unique key, use the auto-data source URL in `sourcesDetail`. Cross-source coverage depends on the model. Mainstream models match carperformancedata.com (and ultimatespecs.com when you enable it) more often than niche performance variants such as the RS3, which ultimatespecs.com nests under the A3 line, so those stay single-source more often. A whole-brand pull can walk hundreds of variants and take several minutes, so use **Max items** to bound a run (the default example is a single model for a fast, cheap first run). ### Known limitations - **Coverage varies by source.** auto-data.net is the backbone and is always present; carperformancedata.com enriches by default; ultimatespecs.com and zeperfs.com are off by default (opt-in via the **Extra sources** field) and enrich a variant only when enabled, present and reachable. When a source is unavailable it is logged and counted, not emitted as a data row, and the variant is still returned with whatever resolved. - **Cross-source matching is fingerprint-based** (make, model, displacement, power, production years). Near-identical variants (facelifts, regional or market versions, AWD vs FWD, DIN vs SAE power ratings) can occasionally stay single-source or, more rarely, be matched too loosely. The `matchConfidence` and `sources` fields let you audit this on every row. - **Electric and hybrid variants read their own rows.** auto-data.net publishes the total output of an electric, plug-in hybrid or full hybrid under `System power` and `System torque`, separately from the `Power` row that describes the combustion engine alone. `powerHp` and `torqueNm` carry the system figure whenever the page prints one, and `powerBasis` and `torqueBasis` tell you which of the two rows was used on every single row. The nested `engine` section keeps both as published, so the combustion figure of a hybrid is never lost. `batteryCapacityKwh` (gross) and `electricRangeKm` are filled only where the source publishes them, and stay null otherwise: nothing here is estimated, converted between test cycles, or read out of the variant name. A mild hybrid publishes no `System power` row, so it reads `engine`, which is correct for that architecture. - **Cross-source matching still compares the combustion figure on a hybrid.** The matcher reads the `Power` row rather than the system figure, so a hybrid may stay single-source more often than its headline power would suggest. This is a matching question and it is tracked separately from the output columns above. - **Figures are reported as published** by each source. Values are normalized to a canonical metric unit (each field carries its `unit`), but regional and market differences are not reconciled. - **No market or region field.** The sources describe each variant by generation and chassis code (for example 8V or 8Y), not by sales market, so there is no reliable per-variant market or region signal to extract and the output does not carry one. - **Source priority and the conflict tolerance are fixed** (auto-data, then ultimatespecs, then zeperfs, then carperformancedata; conflicts flagged at a built-in deviation tolerance), not per-run configurable. ### Use it with AI agents and MCP clients Car Data Scraper runs from AI agents and MCP clients such as Claude Desktop, Claude Code, Cursor or ChatGPT through the [Apify MCP server](https://mcp.apify.com). Connect to `https://mcp.apify.com`, add `mrbridge/car-data-scraper` as a tool and ask for a brand or a list of models. The agent starts a run and reads back one consolidated row per variant, with the source of every figure. See the [Apify MCP documentation](https://docs.apify.com/platform/integrations/mcp) for the client setup. For quick, interactive lookups where an agent browses makes and models and compares cars, [mrbridge/auto-data-mcp](https://apify.com/mrbridge/auto-data-mcp) is a public MCP server that serves auto-data.net specs. Use Car Data Scraper when you want the multi-source consolidation, the conflict flags and a dataset you can export. ### More vehicle data tools - [car spec sheets by brand and model](https://apify.com/mrbridge/auto-data-scraper): the full auto-data.net spec sheet of every engine variant of a brand or model, one row each. - [car specs MCP server](https://apify.com/mrbridge/auto-data-mcp): browse makes, models and engine variants, and compare up to four cars from Claude or ChatGPT. - [VIN decoder and recalls MCP](https://apify.com/mrbridge/vehicle-data-mcp): VIN decoding, recalls, owner complaints and crash-test ratings for US-market vehicles. ### Frequently asked questions #### How does Car Data Scraper work? It resolves each requested brand or model into its list of engine variants on auto-data.net (the backbone catalog), skips the generations that fall entirely outside your year filter if you set one, scrapes each remaining variant from every enabled source, then matches records across sources by a fingerprint (make, model, displacement, power and production years) and merges them into one row, picking a reference value per field by a fixed source priority (auto-data, then ultimatespecs, then zeperfs, then carperformancedata). #### Which sources does it cover? Four: auto-data.net and ultimatespecs.com (full technical sheets), carperformancedata.com (acceleration and quarter-mile figures, credited to the publication that measured them where it names one) and zeperfs.com (European performance figures). auto-data.net is always enabled as the backbone and carperformancedata.com enriches by default. ultimatespecs.com and zeperfs.com are off by default and opt-in (tick them under the **Extra sources** field, or set the API `sources` option): ultimatespecs.com is slower and nests performance variants under their base model, and zeperfs.com is rate-limited with stricter access terms. #### What happens when two sources disagree? The reference value is taken from the highest-priority source (a fixed order: auto-data, then ultimatespecs, then zeperfs, then carperformancedata), every other source's value is kept under `alternatives`, and a `hasConflict` flag plus the maximum deviation is recorded when numeric values differ beyond a built-in tolerance. Nothing is silently dropped. #### Can I integrate Car Data 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 Car Data 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 Car Data Scraper via MCP? Yes. Car Data 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 Car Data 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 Car Data Scraper or simply found a bug, please create an issue on the Actor's [Issues tab](https://apify.com/mrbridge/car-data-scraper/issues). An honest review helps other users decide, and you can bookmark this Actor too. For bugs or other problems, use the Issues tab. More free tools, scrapers, MCP servers and data studies from the same team: [mr-bridge.com](https://mr-bridge.com). The page for this Actor is at [mr-bridge.com/solutions/car-data-scraper](https://mr-bridge.com/solutions/car-data-scraper). ### Legal & responsible use Car Data Scraper extracts vehicle technical specifications and measured performance figures, which are factual data, not personal data. It does not extract names, contact details or any private user information. Each source has its own terms of use, and some restrict automated access or commercial reuse. For this reason ultimatespecs.com and zeperfs.com are disabled by default, and the input includes a rights-confirmation checkbox. Before enabling additional sources or using the output commercially, confirm that your use is permitted by each source you rely on. 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 each 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/car-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, consolidated across the enabled sources. 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. ## `extraSources` (type: `array`): Optionally enable additional sources for deeper coverage. auto-data.net and carperformancedata.com are always used; tick ultimatespecs.com (fuller technical sheets) or zeperfs.com (European performance figures) here to add them. Both are off by default because they are slower or rate-limited, so a run with them enabled takes longer. ## 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/car-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/car-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/car-data-scraper --silent --output-dataset ``` ## MCP server setup ```json { "mcpServers": { "apify": { "type": "http", "url": "https://mcp.apify.com/?tools=fetch-actor-details,mrbridge/car-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/GWTdsGoC6gO2MZUdt/builds/g75xVzjfJp2VoTGm6/openapi.json