Auto Data Specs & Comparison MCP Server

🏎 Auto Data Specs & Comparison MCP Server

Auto Data Specs & Comparison MCP Server is an MCP server that gives Claude, ChatGPT, Cursor, VS Code and other AI agents the car catalogue of auto-data.net. Its 9 read-only tools walk from a make down to one engine variant and return its spec sheet: power, torque, 0-100 km/h, top speed, weight, dimensions and fuel consumption, plus battery and electric range when the car has them.

For whole spec sheets in a dataset, use the auto-data.net car specs scraper.

Ask Claude "which Audi RS3 versions have 400 hp or more, and how quick are they from 0 to 100 km/h?". It calls autodata_find_variants, then autodata_compare_variants on the versions it found, and returns the matching versions with their generation years, followed by a side-by-side table of power, torque, 0-100 km/h, top speed and weight. Each answer links to the auto-data.net page it comes from, and you need no account beyond your Apify token.

Quick start

1. Copy your API token from Apify Console > Settings > API & Integrations.
2. Add https://mrbridge--auto-data-mcp.apify.actor/mcp to your AI client with the header Authorization: Bearer <token>. The Connect section below has a ready-made snippet for each client.
3. Ask a question such as "how much torque does the Audi TT RS make, and how much does it weigh?"

What this server exposes

This server gives an AI client 9 read-only tools over the public car catalogue of auto-data.net: makes, models, generations, engine variants and the spec sheet of each variant (power, torque, 0-100 km/h, top speed, weight, dimensions, fuel consumption, battery and electric range when the car has them). Three tools walk the catalogue from a make down to one engine variant (autodata_list_models, autodata_list_generations, autodata_list_variants), autodata_list_makes gives the exact spelling of a make, and autodata_get_variant returns the data sheet of one variant. autodata_find_variants keeps the variants of one model by year and power in a single call, and autodata_compare_variants puts two to four variants side by side. search and fetch are the pair ChatGPT looks for: search takes a make and model in free text, fetch reads one result as text. No account or key is needed besides your Apify token, and every answer links to the auto-data.net page it comes from. This server is not affiliated with or endorsed by auto-data.net.

Tools

Tool	What it answers	Billed event
autodata_list_makes	List the car makes of auto-data.net	tool-read
autodata_list_models	List the models of a car make	tool-read
autodata_list_generations	List the generations of a car model	tool-read
autodata_list_variants	List the versions of a car generation	tool-read
autodata_get_variant	Get one engine variant data sheet	tool-read
autodata_compare_variants	Compare 2 to 4 engine variants	tool-action
autodata_find_variants	Find the versions of a car model by year and power	tool-action
search	Search	tool-read
fetch	Fetch	tool-read

autodata_list_makes: List the car makes of auto-data.net

Use this when you need the car makes (brands) auto-data.net covers, for example to check how a make is spelled or to get the make name to pass to autodata_list_models. Do not use for the models of a make (autodata_list_models), their generations (autodata_list_generations) or their versions (autodata_list_variants). Parameters: query (text, optional, part of a make name, case and accents ignored, example "mer" keeps Mercedes-Benz), limit (integer 1 to 400, default 50), offset (integer, default 0, use next_offset of the previous answer), response_format ("concise" by default, or "detailed" to add cache information). Each make has an id (its page slug), a name and its auto-data.net URL.

Parameter	Type	Required	Example
query	string	no	"mer"
limit	integer	no	50
offset	integer	no	0
response_format	"concise" or "detailed"	no	"concise"

Returns { makes[], pagination }. Upstream: auto-data.net. Cache: daily (1 day). Read-only.

autodata_list_models: List the models of a car make

Use this when you need the models auto-data.net lists for a make, for example "which Audi models are there" or to get the model id to pass to autodata_list_generations. Do not use for the list of makes (autodata_list_makes), the generations of a model (autodata_list_generations) or technical specifications (autodata_list_variants lists versions). Parameters: make (text, required, brand name or brand slug, case and accents ignored, example "Audi"), query (text, optional, part of a model name, example "rs"), limit (integer 1 to 200, default 50), offset (integer, default 0, use next_offset of the previous answer), response_format ("concise" by default, or "detailed" to add cache information). An unknown make answers NOT_FOUND with close names. When several brands share the name (for example "Audi" and "AUDI"), the exact spelling wins, else the first, and notice names the others with their slug. Each model has an id (its page slug), a name and its auto-data.net URL.

Parameter	Type	Required	Example
make	string	yes	"Audi"
query	string	no	"rs"
limit	integer	no	50
offset	integer	no	0
response_format	"concise" or "detailed"	no	"concise"

Returns { make, models[], pagination, notice }. Upstream: auto-data.net. Cache: daily (1 day). Read-only.

autodata_list_generations: List the generations of a car model

Use this when you need the generations of one model with their production years, for example "which Audi RS3 generations exist" or "which TT was built in 2016", or to get the generation id to pass to autodata_list_variants. Do not use for the list of makes (autodata_list_makes), the models of a make (autodata_list_models) or the versions of a generation (autodata_list_variants). Parameters: name the model either by model_id alone, or by make and model together. model_id (text, page slug or full URL, the id of autodata_list_models, example "audi-rs3-model-2067"), make (text, brand name or slug, case and accents ignored, example "Audi") with model (text, model name, example "RS3"), year (integer 1900 to 2100, optional, a production year as printed by auto-data.net, keeps the generations whose production years cover it, a generation still in production (in_production true) covers every year from its start on, a generation with no printed years is kept and marked years_unknown true, example 2021), limit (integer 1 to 200, default 50), offset (integer, default 0, use next_offset of the previous answer), response_format ("concise" by default, or "detailed" to add cache information). An unknown make or model answers NOT_FOUND with close names. When several brands share the make name (for example "Audi" and "AUDI"), the exact spelling wins, else the first, and notice names the others with their slug. Each generation has an id (its page slug), a name, years (from, and to when production ended), in_production true when production goes on, and its auto-data.net URL.

Parameter	Type	Required	Example
model_id	string	no	"audi-rs3-model-2067"
make	string	no	"Audi"
model	string	no	"RS3"
year	integer	no	2021
limit	integer	no	50
offset	integer	no	0
response_format	"concise" or "detailed"	no	"concise"

Returns { model, generations[], pagination, notice }. Upstream: auto-data.net. Cache: daily (1 day). Read-only.

autodata_list_variants: List the versions of a car generation

Use this when you need the versions (engine and gearbox variants) of one generation, for example "which RS3 Sportback 8Y versions exist" or "which version has 400 hp", or to get the variant id of a specification page. Do not use for the list of makes (autodata_list_makes), models (autodata_list_models) or generations (autodata_list_generations), or for the full specifications of a version. Parameters: generation_id (text, required, page slug or full URL, the id of autodata_list_generations, example "audi-rs3-sportback-8y-facelift-2024-generation-10147"), query (text, optional, part of a version name, case and accents ignored, example "400"), limit (integer 1 to 200, default 50), offset (integer, default 0, use next_offset of the previous answer), response_format ("concise" by default, or "detailed" to add the power in hp read from the version name, and cache information). Each version has an id (its page slug), a name and its auto-data.net URL.

Parameter	Type	Required	Example
generation_id	string	yes	"audi-rs3-sportback-8y-facelift-2024-generation-10147"
query	string	no	"400"
limit	integer	no	50
offset	integer	no	0
response_format	"concise" or "detailed"	no	"concise"

Returns { generation, variants[], pagination }. Upstream: auto-data.net. Cache: daily (1 day). Read-only.

autodata_get_variant: Get one engine variant data sheet

Use this when you need the technical data sheet of one engine variant of a car on auto-data.net: power, torque, 0-100 km/h, top speed, weight, consumption, dimensions, battery and electric range when the car has them. Do not use for browsing brands, models or generations to find a variant id, or for comparing several variants (autodata_compare_variants). Parameters: variant_id (string, required, the variant page slug or its full auto-data.net URL, example "audi-rs3-sportback-8y-facelift-2024-2.5-tfsi-400hp-quattro-s-tronic-52529"), response_format ("concise" by default for the flat summary, "detailed" for the six sections with units and measurement kind plus the raw spec table and cache information). The field scrapedAt is the time the page was read, so the real age of the data.

Parameter	Type	Required	Example
variant_id	string	yes	"audi-rs3-sportback-8y-facelift-2024-2.5-tfsi-400hp-quattro-s-tronic-52529"
response_format	"concise" or "detailed"	no	"concise"

Returns { variant }. Upstream: auto-data.net. Cache: reference (30 days). Read-only.

autodata_compare_variants: Compare 2 to 4 engine variants

Use this when you need two to four engine variants of cars side by side on auto-data.net, for example to choose between two versions of a model: power, torque, 0-100 km/h, top speed, weight, consumption and dimensions. Do not use for the full data sheet of one variant (autodata_get_variant) or for finding variant ids. Parameters: variant_ids (array of 2 to 4 distinct variant slugs or full auto-data.net URLs, required, example ["audi-rs3-sportback-8y-facelift-2024-2.5-tfsi-400hp-quattro-s-tronic-52529", "audi-tt-rs-coupe-8s-facelift-2019-heritage-edition-2.5-tfsi-394hp-quattro-s-tronic-45186"]), response_format ("concise" by default, "detailed" adds the six sections of each variant and cache information). Repeated ids are read once and count once. The answer has variants (one summary per variant) and comparison.rows, each row a field, its unit and one value per variant in the same order. If one variant cannot be read, the whole call fails and names the faulty slug. Failed calls are not charged.

Parameter	Type	Required	Example
variant_ids	array of string	yes	["audi-rs3-sportback-8y-facelift-2024-2.5-tfsi-400hp-quattro-s-tronic-52529","audi-tt-rs-coupe-8s-facelift-2019-heritage-edition-2.5-tfsi-394hp-quattro-s-tronic-45186"]
response_format	"concise" or "detailed"	no	"concise"

Returns { variants[], comparison }. Upstream: auto-data.net. Cache: reference (30 days). Read-only.

autodata_find_variants: Find the versions of a car model by year and power

Use this when you need the versions of one model filtered by year and engine power in a single call, for example "BMW 3 Series from 2019 above 250 hp" or "which Audi RS3 versions have 400 hp or more". Do not use for the list of makes (autodata_list_makes), the models of a make (autodata_list_models), the generations of a model (autodata_list_generations), the versions of one known generation (autodata_list_variants) or the full data sheet of a version (autodata_get_variant). Parameters: make (text, required, brand name or slug, case and accents ignored, example "Audi"), model (text, required, model name of that make, case and accents ignored, example "RS3"), year (integer 1900 to 2100, optional, a production year as printed by auto-data.net, keeps the generations whose production years cover it, a generation still in production (in_production true) covers every year from its start on, a generation with no printed years is kept and its versions are marked years_unknown true, example 2022), min_power_hp (integer 0 to 3000, optional, versions with at least this power in metric hp as printed in the version name, example 250), max_power_hp (integer 0 to 3000, optional, versions with at most this power, example 450), query (text, optional, part of a version name, case and accents ignored, example "quattro"), limit (integer 1 to 200, default 50), offset (integer, default 0, use next_offset of the previous answer), response_format ("concise" by default, or "detailed" to add cache information). At most 6 generations are read per call. When more match, the answer has truncated true and a hint to give a year or to call autodata_list_generations. A power filter drops the versions whose name prints no power, counted in skipped_without_power. When time runs out after at least one page was read, the answer is partial: truncated true with a hint on how to narrow the search, and it is still charged as one tool-action event. An unknown make or model answers NOT_FOUND with close names. When several brands share the make name (for example "Audi" and "AUDI"), the exact spelling wins, else the first, and notice names the others with their slug. Each version has an id (its page slug), a name, the name of its generation, the production years of that generation, the power in hp when printed, and its auto-data.net URL.

Parameter	Type	Required	Example
make	string	yes	"Audi"
model	string	yes	"RS3"
year	integer	no	2022
min_power_hp	integer	no	250
max_power_hp	integer	no	450
query	string	no	"quattro"
limit	integer	no	50
offset	integer	no	0
response_format	"concise" or "detailed"	no	"concise"

Returns { make, model, generations_scanned, variants[], skipped_without_power, truncated, hint, pagination, notice }. Upstream: auto-data.net. Cache: daily (1 day). Read-only.

search: Search

Use this when ChatGPT needs to find car models, generations or engine variants on auto-data.net from a free-text query that names a make, for example "audi rs3 2024" or "bmw 3 series". Returns up to 20 results with ids for fetch and their auto-data.net URLs: the generations of the best matching model (a four-digit year in the query keeps the generations produced that year), or the models of the make when the query holds only the make. A query that names no known make returns an empty list. Do not use for paging through a catalogue, for filtering versions by power (use autodata_find_variants) or for vehicle prices, which auto-data.net does not publish. Parameter query (string), for example "audi rs3 2024".

Parameter	Type	Required	Example
query	string	yes	"audi rs3 2024"

Returns { results[], notices[] }. Upstream: auto-data.net. Cache: daily (1 day). Read-only.

fetch: Fetch

Use this when ChatGPT needs one result of search as readable text: the data sheet of an engine variant (power, torque, 0-100 km/h, top speed, weight, consumption, battery and electric range when stated), the versions of a generation, or the generations of a model. Do not use for ids that did not come from search or from the autodata_ list tools. Parameter id (string), the page slug of a model, a generation or an engine variant, or its full auto-data.net URL, for example "audi-rs3-sportback-8y-facelift-2024-generation-10147".

Parameter	Type	Required	Example
id	string	yes	"audi-rs3-sportback-8y-facelift-2024-generation-10147"

Returns { id, title, text, url, metadata, notices[] }. Upstream: auto-data.net. Cache: daily (1 day). Read-only.

Connect

Endpoint (Streamable HTTP): https://mrbridge--auto-data-mcp.apify.actor/mcp

Every client authenticates with your Apify API token, found in Apify Console > Settings > API & Integrations. Clients that support custom headers send it as Authorization: Bearer <token>. The others use the ?token= URL variant, which must be treated as a secret: keep it out of commits, screenshots and shared logs.

Claude Code

$claude mcp add --transport http auto-data "https://mrbridge--auto-data-mcp.apify.actor/mcp" --header "Authorization: Bearer ${APIFY_TOKEN}"

Cursor, VS Code and other JSON configurations

{
  "mcpServers": {
    "auto-data": {
      "type": "http",
      "url": "https://mrbridge--auto-data-mcp.apify.actor/mcp",
      "headers": {
        "Authorization": "Bearer ${APIFY_TOKEN}"
      }
    }
  }
}

claude.ai and Claude Desktop

Add a custom connector with the URL https://mrbridge--auto-data-mcp.apify.actor/mcp?token=YOUR_APIFY_TOKEN and no authentication. Prefilled link (replace the token placeholder before saving): add Auto Data Specs & Comparison MCP Server to Claude.

ChatGPT (developer mode)

Settings > Apps > Create, URL https://mrbridge--auto-data-mcp.apify.actor/mcp?token=YOUR_APIFY_TOKEN, authentication "No authentication". ChatGPT snapshots the tool list: after a server update, an admin has to click Refresh on the app.

OpenAI Responses API

{
  "type": "mcp",
  "server_label": "auto_data",
  "server_url": "https://mrbridge--auto-data-mcp.apify.actor/mcp",
  "headers": {
    "Authorization": "Bearer YOUR_APIFY_TOKEN"
  },
  "require_approval": "never"
}

Add allowed_tools to restrict the tool list. Tool calls must finish within about 60 seconds on this API, and every tool of this server answers in under 50 seconds.

Anthropic Messages API

{
  "mcp_servers": [
    {
      "type": "url",
      "url": "https://mrbridge--auto-data-mcp.apify.actor/mcp",
      "name": "auto-data",
      "authorization_token": "YOUR_APIFY_TOKEN"
    }
  ],
  "tools": [
    {
      "type": "mcp_toolset",
      "mcp_server_name": "auto-data"
    }
  ]
}

Send the beta header anthropic-beta: mcp-client-2025-11-20.

One-click OAuth alternative

https://mcp.apify.com/?tools=mrbridge/auto-data-mcp connects through Apify OAuth without a token. It exposes the Actor as a single tool rather than the granular tools listed above.

Cost control

Each Standby run has a spending limit (maxTotalChargeUsd). When a call uses the last of it, the result is still returned, and later calls in that run answer CHARGE_LIMIT_REACHED until the limit is raised.

Why use Auto Data Specs & Comparison MCP Server

• The whole catalogue in one server. Makes, models, generations with their production years, engine and gearbox variants, and the spec sheet of each variant.
• Year and power filters in one call. autodata_find_variants scans up to six generations of a model and keeps the versions built in a given year, above or below a power figure.
• Side-by-side comparison. Two to four variants in one table, row by row: power, torque, 0-100 km/h, top speed, weight, consumption and dimensions, each with its unit.
• Figures you can trace. Every answer carries the URL of its source page. A figure the page does not state comes back as null instead of a guess, and the detailed format says whether a figure is measured, calculated or claimed by the maker.
• Ready for ChatGPT. The search and fetch pair finds a model from free text such as "audi rs3" and reads one result as text, the way ChatGPT expects.

Pricing (Pay-per-Event)

Auto Data Specs & Comparison MCP Server uses pay-per-event pricing. On the Apify Free plan, each successful call to autodata_find_variants or autodata_compare_variants is one tool-action event at $0.01, and each successful call to any other tool is one tool-read event at $0.005, so 1,000 reads cost $5 in events. The discounts of paid Apify plans lower these prices, and the Pricing tab shows the price on your plan. Apify also bills its standard apify-actor-start event when a Standby run starts, and you pay the platform usage of your own Standby run on top of the events, as explained below. Calls that end in an error carry no event charge.

Event	Charged when	Price
apify-actor-start	run start (platform default)	see the Store page
tool-read (primary event)	each successful read tool call	see the Store page
tool-action	each successful call of a detailed or computed tool	see the Store page

Never charged: initialize, tools/list, pings, readiness probes, and any call that ends in an error (invalid input, not found, upstream failure, timeout, spending limit).

Platform usage comes on top of these events. This server runs in Apify Standby mode, and you also pay the platform usage of your own Standby run, billed to your Apify account like any other run: the memory set for the Standby run, for as long as the server is up, idle time included, until the run stops at its idle timeout. The Apify pay-per-event documentation says so: "For runs in Standby mode, users always pay the platform usage costs in addition to the event charges."

Limits, caveats and attribution

• Source and terms. All data comes from the public pages of auto-data.net (https://www.auto-data.net), read when a tool is called. This server is not affiliated with, endorsed by or sponsored by auto-data.net, which has no public API and publishes its own terms of use. Read them before you reuse the figures beyond your own lookups. Every answer carries the URL of the page it comes from.
• First call is slower. A page that is not in the cache is read live from auto-data.net. A cold autodata_list_models reads two pages, a cold autodata_find_variants up to nine. Lists are then cached for one day and data sheets for 30 days, so repeated questions answer fast. The server paces its requests to auto-data.net, and a call that cannot read its pages in time answers with a timeout error, which is not billed. Measured on the platform: a cold start of about 4 seconds, a first simple answer within about 10 seconds, and up to about 35 seconds for a broad autodata_find_variants.
• Narrow searches in autodata_find_variants. It reads at most 6 generations per call. When more match, the answer has truncated true and a hint to give a year or to go through autodata_list_generations. If time runs out after at least one page was read, the answer is partial: truncated is true, the hint says how to narrow the search, and the call is billed as one tool-action event like any answer. Give a year or a narrower model to get a complete answer.
• No prices. auto-data.net publishes technical data, not the price of a vehicle. No tool returns one, and search does not answer price questions.
• Data as published. Figures are returned as auto-data.net prints them, with no correction and no conversion beyond units. A figure the page does not state is null (or absent for battery and electric range on a combustion car). Power in version lists is the "(N Hp)" printed in the version name, so a version whose name prints none is dropped by a power filter and counted in skipped_without_power. Specifications can differ between markets and model years, so check the page linked in the answer before you rely on a number.
• Years. year means a production year as auto-data.net prints it. A generation still in production has no end year, is marked in_production true and covers every year from its start. A generation with no printed years is kept and marked years_unknown true.
• Homonym makes. auto-data.net lists two brands that differ only by case, such as "Audi" and "AUDI". The exact spelling wins, otherwise the first in the index, and notice names the other brands with their slug so you can target one.
• Page changes. auto-data.net may change its markup or refuse a request. The server then answers an error (UPSTREAM_SCHEMA_CHANGED or UPSTREAM_BLOCKED) with a hint, never a guess, and errors are never billed.

Use cases

• Car shoppers and enthusiasts. Line up the versions of one model on power, 0-100 km/h, weight and consumption before a test drive.
• Motoring writers. Check the figures quoted in a review or a buyer guide, with the source page of each number at hand.
• Dealers and listing sites. Fill in the technical data of a used-car listing from its make, model, generation and version.
• EV research. Read the battery capacity and electric range of electric and plug-in versions next to their combustion siblings.
• Developers and data teams. Give an AI agent a spec lookup it can call, instead of writing and maintaining a page parser.

The server returns technical data as auto-data.net publishes it. It gives no vehicle prices, no safety ratings and no buying advice. Specifications can differ between markets and model years, so check the linked page before you rely on a figure.

More vehicle data tools

• car specs and 0-60 data: car specs and performance for any model: power, torque, 0-60 mph and top speed, with sources.
• car spec sheets by brand and model: the full auto-data.net spec sheet of every engine variant of a brand or model, one row each.
• VIN decoder and recalls MCP: VIN decoding, recalls, owner complaints and crash-test ratings for US-market vehicles.

FAQ

Why is the first call slower?

The server runs in Apify Standby mode. When no request comes in for a while, the run stops at its idle timeout, and the next call starts a new one. A cold start takes about 4 seconds, and the first answer at most 10 seconds for a simple question. A broad autodata_find_variants can take up to about 35 seconds. A page that is not in the cache is also read live from auto-data.net, and a cold autodata_find_variants reads up to nine pages. Lists then stay cached for a day and spec sheets for 30 days, so the same question answers fast the second time.

Why does a model come back as NOT_FOUND?

The make or the model is spelled another way on auto-data.net. The answer suggests up to five close names, and autodata_list_makes and autodata_list_models give the exact spellings. Two brands can also differ only by case, such as "Audi" and "AUDI": the exact spelling wins, otherwise the first in the index, and the notice field names the other brand with its slug so you can target it. A NOT_FOUND answer is not billed.

Where do the figures come from, and can I rely on them?

Every figure comes from the public auto-data.net page linked in the answer, read when the tool is called or taken from a cache of at most 30 days. The server converts units and corrects nothing. A figure the page does not state is null. Specifications can differ between markets, model years and test cycles, so treat the numbers as published reference data and check the linked page before you rely on one.

Does it give 0-60 mph times?

The summary gives 0-100 km/h. Ask for the detailed format: its performance section adds 0-60 mph when the page prints it, marked as measured, calculated or claimed by the maker. auto-data.net prints some 0-60 figures as calculated rather than measured, so check the mark before you quote one.

Does it give vehicle prices?

No. auto-data.net publishes technical data, not prices, so no tool returns a price and search does not answer price questions. The server gives no buying advice either.

Why can autodata_find_variants return a partial answer, and is it billed?

It reads at most six generation pages per call and stops shortly before its time limit. When more generations match, or when time runs out after at least one page was read, the answer has truncated true and a hint to narrow the search with a year or a narrower model. That partial answer is billed as one tool-action event like any other answer. If no page could be read, the call fails with a timeout and is not billed.

Is this an official auto-data.net service?

No. It is an independent server that reads the public pages of auto-data.net. It is not affiliated with, endorsed by or sponsored by auto-data.net, which publishes its own terms of use. Read them before you reuse the figures beyond your own lookups.

Does it decode VINs or list recalls?

No, this server covers technical specifications. For VIN decoding, recalls and crash-test ratings of US-market vehicles, see VIN Decoder & Vehicle Recalls MCP Server.

Your feedback

Found a bug or a wrong answer? Open an issue on the Issues tab. Auto Data Specs & Comparison MCP Server is built by MrBridge. More servers are listed in the MCP server catalogue, and more tools and data studies are at mr-bridge.com.

More from MrBridge

Found a bug or a wrong answer? Open an issue on the Issues tab. This server is built by MrBridge. More servers are listed in the MCP server catalogue, and more tools and data studies are at mr-bridge.com.

Changelog

• 0.1.4: dependency overrides for npm audit alerts
• 0.1.3: the server is renamed to the published Store title, "Auto Data Specs & Comparison MCP Server" (2026-10-25). No tool change.
• 0.1.2: cold-start figures from the platform acceptance (2026-10-25). The FAQ and the limits now give the measured times. No tool change.
• 0.1.1: Store copy and README marketing blocks (2026-10-25). The server is renamed to the Store title, "Car Specs & Comparison MCP Server". No tool change.
• 0.1.0: initial build (private, unpublished). Nine tools over auto-data.net: the catalogue walk (makes, models, generations, variants), the variant data sheet, the comparison of two to four variants, the search by year and power, and the ChatGPT search and fetch pair