VIN Decoder & Vehicle Recalls MCP Server

🚗 VIN Decoder & Vehicle Recalls MCP Server

VIN Decoder & Vehicle Recalls MCP Server is an MCP server that gives Claude, ChatGPT, Cursor, VS Code and other AI agents the public vehicle data published by the US National Highway Traffic Safety Administration (NHTSA). Its 10 read-only tools decode VINs, list makes and models, and read recalls, recall campaigns, owner complaints and NCAP crash-test ratings.

Paste a VIN and ask Claude "what car is this, and which recalls exist for that model?". It calls vehicle_decode_vin, then vehicle_get_recalls, and returns the make, model, year, trim and engine, followed by every recall for that model year with do-not-drive and park-outside warnings at the top. One question replaces three lookups on government websites, 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--vehicle-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 many complaints mention the engine on a 2021 Honda Accord?"

What this server exposes

This server gives an AI client 10 read-only tools over the public vehicle data of the US National Highway Traffic Safety Administration (NHTSA). From the vPIC catalogue it decodes a VIN (full, or partial with * for unknown characters), up to 20 VINs in one call and a manufacturer code (WMI), searches makes, and lists the models of a make by model year or vehicle type. From the NHTSA API it reads the safety recalls of a model year, make and model with their do-not-drive and park-outside warnings, the full text of one recall campaign, the complaints owners filed (crash, fire, injury and death counts, the components cited most often, and the narratives), and the NCAP 5-Star crash-test ratings. A menu tool gives the exact model spellings each NHTSA dataset expects. No account or API key is needed, and every answer names its source. This server is not affiliated with or endorsed by NHTSA or the U.S. Department of Transportation.

Tools

Tool	What it answers	Billed event
vehicle_decode_vin	Decode a VIN	tool-read
vehicle_decode_vins	Decode a list of VINs	tool-action
vehicle_decode_wmi	Identify the manufacturer behind a VIN code	tool-read
vehicle_search_makes	Search vehicle makes	tool-read
vehicle_list_models	List the models of a make	tool-read
vehicle_list_safety_models	List NHTSA model years, makes and models for recalls, complaints or ratings	tool-read
vehicle_get_recalls	Get the safety recalls of a vehicle model	tool-read
vehicle_get_recall_campaign	Get one recall campaign by its NHTSA number	tool-read
vehicle_get_complaints	Get owner complaints for a vehicle model	tool-action
vehicle_get_safety_ratings	Get NHTSA 5-Star crash-test ratings	tool-action

vehicle_decode_vin: Decode a VIN

Use this when you need to know what vehicle a VIN belongs to: make, model, model year, trim, body, engine, fuel, drive, plant and whether the VIN is valid, from the NHTSA vPIC catalogue. Do not use for several VINs at once (vehicle_decode_vins), a manufacturer code alone (vehicle_decode_wmi) or recall and complaint history (vehicle_get_recalls, vehicle_get_complaints). Parameters: vin (17 characters, or a partial VIN with * for unknown positions such as "5UXWX7C5*BA", letters I, O and Q are refused), model_year (optional, from 1980, recommended by NHTSA for older or partial VINs), response_format ("concise" or "detailed" to add every vPIC field and ids). The answer suggests the recall, complaint and crash-test lookups for the decoded vehicle.

Parameter	Type	Required	Example
vin	string	yes	"1HGCM82633A004352"
model_year	integer	no	2011
response_format	"concise" or "detailed"	no	"concise"

Returns { vin, partial, vehicle, decode_status, notice, ids, all_fields, next_steps[], attribution }. Upstream: NHTSA vPIC. Cache: reference (30 days). Read-only.

vehicle_decode_vins: Decode a list of VINs

Use this when you need to decode 2 to 20 VINs in one call, for example a fleet or a dealer stock list: make, model, model year, trim, body and fuel per VIN, from the NHTSA vPIC catalogue. Do not use for one VIN with every detail (vehicle_decode_vin) or for more than 20 VINs (split the list). Parameters: vins (1 to 20 VINs, full or partial with *, duplicates decoded once), response_format ("concise" or "detailed" for series, drive, doors, engine and plant columns). Each row carries a status: decoded, not_decoded (vPIC knows nothing about it), invalid (malformed, never sent) or failed (NHTSA error, retry later). Charged once per call when at least one VIN decodes.

Parameter	Type	Required	Example
vins	array of string	yes	["1HGCM82633A004352","5UXWX7C5*BA"]
response_format	"concise" or "detailed"	no	"concise"

Returns { rows[], summary, attribution }. Upstream: NHTSA vPIC. Cache: reference (30 days). Read-only.

vehicle_decode_wmi: Identify the manufacturer behind a VIN code

Use this when you need the manufacturer, make and vehicle type registered with NHTSA for a World Manufacturer Identifier (WMI), the first characters of a VIN, for example "which company is 1FD" or "who built a VIN starting with JTD". Do not use for decoding a whole vehicle (vehicle_decode_vin) or for listing makes by name (vehicle_search_makes). Parameters: wmi (3 characters such as "1FD", 6 characters for small makers whose third character is 9 such as "1T9131", or a full or partial VIN such as the 11-character prefix of a complaint, from which the code is taken), response_format ("concise" or "detailed" to add registration dates and the cache block). At most 20 manufacturers are listed, manufacturers_total gives the full count. The world region comes from the first character (ISO 3779) and is derived by this server.

Parameter	Type	Required	Example
wmi	string	yes	"1FD"
response_format	"concise" or "detailed"	no	"concise"

Returns { wmi, source, region, region_note, manufacturers_total, manufacturers[], attribution }. Upstream: NHTSA vPIC. Cache: reference (30 days). Read-only.

vehicle_search_makes: Search vehicle makes

Use this when you need the makes NHTSA vPIC knows by a name, or every make of a vehicle type, for example "is there a make called Rivian", "which makes build motorcycles" or the vPIC make id of "Mercedes". Do not use for the models of a make (vehicle_list_models) or for the spellings used by recalls, complaints and crash tests (vehicle_list_safety_models). Parameters: query (part of a make name, e.g. "ford"), vehicle_type (passenger_car, truck, mpv, bus, trailer, motorcycle, low_speed_vehicle, incomplete_vehicle, off_road_vehicle), at least one of the two, limit (1 to 100, default 20), offset, response_format ("concise" or "detailed" to add the vehicle type id). Exact names come first, then names starting with the query, then other matches.

Parameter	Type	Required	Example
query	string	no	"ford"
vehicle_type	"passenger_car" or "truck" or "mpv" or "bus" or "trailer" or "motorcycle" or "low_speed_vehicle" or "incomplete_vehicle" or "off_road_vehicle"	no	"motorcycle"
limit	integer	no	20
offset	integer	no	0
response_format	"concise" or "detailed"	no	"concise"

Returns { query, vehicle_type, makes[], pagination, attribution }. Upstream: NHTSA vPIC. Cache: reference (30 days). Read-only.

vehicle_list_models: List the models of a make

Use this when you need the models NHTSA vPIC lists for a make, optionally for one model year or one vehicle type, for example "which models did Honda sell in 2020" or "Harley-Davidson motorcycle models". Do not use for the model spellings accepted by the recall, complaint and crash-test tools (vehicle_list_safety_models), or for makes (vehicle_search_makes). Parameters: make (name, partial-matched by vPIC so a short name can return several makes, or a numeric vPIC make id such as "474" for exactly one make), model_year (from 1996, optional), vehicle_type (optional), query (optional part of a model name), limit (1 to 200, default 50), offset, response_format ("concise" or "detailed" to add the vehicle types the make builds). Models are sorted by make, then name.

Parameter	Type	Required	Example
make	string	yes	"honda"
model_year	integer	no	2020
vehicle_type	"passenger_car" or "truck" or "mpv" or "bus" or "trailer" or "motorcycle" or "low_speed_vehicle" or "incomplete_vehicle" or "off_road_vehicle"	no	"motorcycle"
query	string	no	"cr"
limit	integer	no	50
offset	integer	no	0
response_format	"concise" or "detailed"	no	"concise"

Returns { make_query, model_year, vehicle_type, makes_matched[], makes_matched_total, models[], vehicle_types[], vehicle_types_total, note, pagination, attribution }. Upstream: NHTSA vPIC. Cache: reference (30 days). Read-only.

vehicle_list_safety_models: List NHTSA model years, makes and models for recalls, complaints or ratings

Use this when a recall, complaint or crash-test lookup needs NHTSA's exact spelling, for example "CR-V HYBRID" or "F-150 SUPER CREW": the three datasets keep their own lists of model years, makes and models. Do not use for vPIC catalogue models (vehicle_list_models) or for the records themselves (vehicle_get_recalls, vehicle_get_complaints, vehicle_get_safety_ratings). Parameters: dataset ("recalls" default, "complaints" or "ratings"), model_year (optional: without it the model years are listed), make (optional, needs model_year: without it the makes of the year are listed, with it the models), query (optional part of a name), limit (1 to 200, default 50), offset, response_format ("concise" or "detailed" for the cache block).

Parameter	Type	Required	Example
dataset	"recalls" or "complaints" or "ratings"	no	"recalls"
model_year	integer	no	2020
make	string	no	"honda"
query	string	no	"hybrid"
limit	integer	no	50
offset	integer	no	0
response_format	"concise" or "detailed"	no	"concise"

Returns { dataset, level, items[], next_tool, note, pagination, attribution }. Upstream: NHTSA API. Cache: daily (1 day). Read-only.

vehicle_get_recalls: Get the safety recalls of a vehicle model

Use this when you need the NHTSA safety recalls for a model year, make and model, for example "recalls on a 2020 Honda CR-V", including do-not-drive (park it) and park-outside warnings. Do not use for one campaign by its number (vehicle_get_recall_campaign), owner complaints (vehicle_get_complaints) or the repair status of one VIN (NHTSA publishes no such API, see https://www.nhtsa.gov/recalls). Parameters: make (e.g. "honda"), model (NHTSA spelling, e.g. "CR-V"), model_year (from 1949), component (optional part of a component name, e.g. "air bag"), limit (1 to 50, default 10, at most 5 used in detailed mode), offset, response_format ("concise" shortens texts, "detailed" adds texts up to 2,500 characters, notes and raw dates). A misspelt model returns NOT_FOUND with NHTSA's closest spellings.

Parameter	Type	Required	Example
make	string	yes	"honda"
model	string	yes	"CR-V"
model_year	integer	yes	2020
component	string	no	"air bag"
limit	integer	no	10
offset	integer	no	0
response_format	"concise" or "detailed"	no	"concise"

Returns { vehicle, summary, recalls[], notice, pagination, attribution }. Upstream: NHTSA API. Cache: daily (1 day). Read-only.

vehicle_get_recall_campaign: Get one recall campaign by its NHTSA number

Use this when you have an NHTSA recall campaign number (for example "20V314000" from vehicle_get_recalls, a recall letter or a news article) and need its full text: defect summary, consequence, remedy, warnings, units affected and every model year, make and model it covers. Do not use for finding the recalls of a vehicle (vehicle_get_recalls) or for complaints (vehicle_get_complaints). Parameters: campaign_number ("20V314000", "20V-314" or "20v314" are the same campaign), limit (1 to 200 vehicles, default 50), offset, response_format ("concise" or "detailed" to add the raw NHTSA date and the cache block).

Parameter	Type	Required	Example
campaign_number	string	yes	"20V314000"
limit	integer	no	50
offset	integer	no	0
response_format	"concise" or "detailed"	no	"concise"

Returns { campaign, components[], components_total, vehicles[], pagination, attribution }. Upstream: NHTSA API. Cache: daily (1 day). Read-only.

vehicle_get_complaints: Get owner complaints for a vehicle model

Use this when you need the safety complaints owners filed with NHTSA for a model year, make and model: how many, how many crashes, fires, injuries and deaths, which components come up most, and the complaint narratives, newest first. Do not use for recalls (vehicle_get_recalls) or crash-test ratings (vehicle_get_safety_ratings). Complaints are unverified consumer reports, not proof of a defect. Parameters: make (e.g. "honda"), model (NHTSA spelling, e.g. "ACCORD"), model_year (from 1949), component (optional, e.g. "engine"), only_crash_or_fire and only_injuries_or_deaths (optional booleans), limit (1 to 50, default 10, at most 10 used in detailed mode), offset, response_format ("concise" cuts narratives to 400 characters, "detailed" returns them whole with products and raw dates). Narratives are scrubbed of e-mail addresses, phone numbers and full VINs.

Parameter	Type	Required	Example
make	string	yes	"honda"
model	string	yes	"ACCORD"
model_year	integer	yes	2021
component	string	no	"engine"
only_crash_or_fire	boolean	no	true
only_injuries_or_deaths	boolean	no	true
limit	integer	no	10
offset	integer	no	0
response_format	"concise" or "detailed"	no	"concise"

Returns { vehicle, statistics, matching, complaints[], notice, pagination, attribution }. Upstream: NHTSA API. Cache: daily (1 day). Read-only.

vehicle_get_safety_ratings: Get NHTSA 5-Star crash-test ratings

Use this when you need NHTSA New Car Assessment Program (NCAP) crash-test ratings for a vehicle: overall stars, frontal, side and side pole stars per seating position, rollover rating and risk, and the safety technologies noted by NHTSA, for example "how safe is a 2023 Toyota Camry". Do not use for recalls (vehicle_get_recalls), owner complaints (vehicle_get_complaints) or IIHS ratings (not covered). Parameters: model_year (from 1990), make and model (NHTSA spelling, e.g. "TOYOTA" and "CAMRY"), or vehicle_id (an NHTSA ratings variant id) instead of the three, limit (1 to 10 variants, default 5), offset, response_format ("concise" or "detailed" to add combined side ratings, crash photos and videos, and the raw labels). Unrated tests are null and listed in not_rated.

Parameter	Type	Required	Example
model_year	integer	no	2023
make	string	no	"toyota"
model	string	no	"camry"
vehicle_id	integer	no	19001
limit	integer	no	5
offset	integer	no	0
response_format	"concise" or "detailed"	no	"concise"

Returns { query, variants_total, vehicles[], notice, pagination, attribution }. Upstream: NHTSA API. Cache: daily (1 day). Read-only.

Connect

Endpoint (Streamable HTTP): https://mrbridge--vehicle-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 vehicle-data "https://mrbridge--vehicle-data-mcp.apify.actor/mcp" --header "Authorization: Bearer ${APIFY_TOKEN}"

Cursor, VS Code and other JSON configurations

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

claude.ai and Claude Desktop

Add a custom connector with the URL https://mrbridge--vehicle-data-mcp.apify.actor/mcp?token=YOUR_APIFY_TOKEN and no authentication. Prefilled link (replace the token placeholder before saving): add VIN Decoder & Vehicle Recalls MCP Server to Claude.

ChatGPT (developer mode)

Settings > Apps > Create, URL https://mrbridge--vehicle-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": "vehicle_data",
  "server_url": "https://mrbridge--vehicle-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--vehicle-data-mcp.apify.actor/mcp",
      "name": "vehicle-data",
      "authorization_token": "YOUR_APIFY_TOKEN"
    }
  ],
  "tools": [
    {
      "type": "mcp_toolset",
      "mcp_server_name": "vehicle-data"
    }
  ]
}

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

One-click OAuth alternative

https://mcp.apify.com/?tools=mrbridge/vehicle-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 VIN Decoder & Vehicle Recalls MCP Server

• One server for the whole vehicle record. VIN decoding, the make and model catalogue, recalls, recall campaigns, owner complaints and crash-test ratings.
• Complaint statistics in one call. Crashes, fires, injuries and deaths, the most cited components, and narratives with e-mail addresses, phone numbers and full VINs masked.
• Forgiving model names. Each NHTSA dataset spells models its own way. A misspelt model returns the closest names instead of an empty answer, and Chevy, VW or Mercedes are understood.
• Warnings first. Do-not-drive and park-outside recall warnings sit at the top of every recall answer.
• Batch decoding. Up to 20 VINs per call for a fleet list or a dealer stock file.

Pricing (Pay-per-Event)

VIN Decoder & Vehicle Recalls MCP Server uses pay-per-event pricing. Each successful call to vehicle_decode_vins, vehicle_get_complaints or vehicle_get_safety_ratings 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, and a batch of 20 VINs is one action. These are the prices on the Apify Free plan, and the discounts of paid plans lower them. 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. See the Pricing tab for the price on your Apify plan.

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

• Attribution. Every answer carries an attribution block: the NHTSA dataset, its page, the terms URL and the notices below. Keep it when you reuse the data. NHTSA makes no claims, promises or guarantees about the accuracy, completeness or adequacy of its data.
• VIN decoding. vPIC covers vehicles made for the US market. NHTSA puts its decoding success at about 99 percent from model year 1995, 60 to 65 percent for 1980 to 1994, and has no data before 1980. A missing value means NHTSA has no data on it, not that the vehicle lacks the feature. A wrong check digit is reported next to the decode, which is still returned.
• Recalls are per model. Recalls are listed by model year, make and model. They do not tell whether one vehicle is affected or already repaired, and NHTSA publishes no public API for that. Check the VIN at https://www.nhtsa.gov/recalls or with the manufacturer.
• Complaints. They are unverified reports filed by consumers and do not prove a defect. NHTSA publishes the narratives without edits. This server returns a fixed list of fields, the 11-character VIN prefix NHTSA publishes, and narratives with e-mail addresses, phone numbers and full VINs masked. It cannot spot a name typed into a narrative. The concise format cuts narratives at 400 characters.
• Crash-test ratings. Whole stars from 1 to 5, given per test and seating position and never added together. A test NHTSA did not rate comes back as null and is listed in not_rated. Ratings of model years before 2011 cannot be compared with newer ones, because the tests changed. Every rating answer carries the NCAP attribution statement.
• Model spellings. vPIC, the recall and complaint data, and the crash-test data each spell models their own way (F-150 for recalls, F-150 SUPER CREW for complaints). vehicle_list_safety_models lists NHTSA's spellings, and a misspelt model returns NOT_FOUND with the closest names instead of an empty answer. Chevy, VW and Mercedes are read as CHEVROLET, VOLKSWAGEN and MERCEDES-BENZ.
• Volume. NHTSA sends every record of a vehicle in one answer and the server pages through it. A complaint list over 8 MB is refused with a pointer to the NHTSA bulk files. NHTSA asks that large vPIC batches run at night or on weekends (US Eastern time), so one call decodes 20 VINs at most. No rate limit is documented, and each server instance paces itself at 5 requests per second to vPIC and 3 to api.nhtsa.gov.
• Freshness. VIN decodes, makes and models are cached for 30 days. Recalls, complaints, ratings and the spelling menus are cached for one day, and NHTSA updates recalls and complaints daily.

Data terms

NHTSA data is a work of the U.S. Government, and NHTSA's terms state that "Information presented on this web site is considered public information and may be distributed or copied" (https://www.nhtsa.gov/about-nhtsa/terms-use). When you reuse what this server returns:

• Do not suggest that NHTSA or the U.S. Department of Transportation endorses you, your product or this server.
• Do not use the NHTSA logo, the DOT seal or the 5-Star Safety Ratings logo. They are protected federal marks.
• When you publish star ratings, follow NHTSA's guidelines (https://www.nhtsa.gov/ratings/government-5-star-safety-ratings-motor-vehicles-advertising-and-communication-usage): keep each seating position separate, never add ratings together, and add the statement "Government 5-Star Safety Ratings are part of the National Highway Traffic Safety Administration's New Car Assessment Program (NHTSA.gov)."
• Present complaints as consumer reports, not as findings.

The fee for this server pays for the service (hosting, caching, normalisation, scrubbing), not for a licence on the data.

Use cases

• Used-car research. Decode the VIN of a listing, then read the recalls and complaint statistics of that model year before a viewing.
• Dealers and fleet managers. Decode a stock or fleet list 20 VINs at a time and see which models have recall campaigns.
• Claims and support desks. Fill in make, model, body, engine and fuel from a VIN instead of asking the customer.
• Journalism and research. Compare complaint counts, fires and crashes across model years, or quote the full text of a recall campaign.
• Buyer guides. Put the crash-test ratings of two models side by side, per test and seating position.

Recalls are listed per model year, make and model. To know whether one vehicle is affected or already repaired, check its VIN at https://www.nhtsa.gov/recalls or with the manufacturer. Government 5-Star Safety Ratings are part of the National Highway Traffic Safety Administration's New Car Assessment Program (NHTSA.gov).

More vehicle data tools

• car specs scraper: car specs and performance for any model: power, torque, 0-60 mph and top speed, with sources.
• auto-data.net car specs scraper: the full auto-data.net spec sheet of every engine variant of a brand or model, one row each.
• car specs MCP server: browse makes, models and engine variants, and compare up to four cars from Claude or ChatGPT.

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. That cold start took about 5 seconds in the last platform test. Calls made while the server is warm skip the delay.

Can it tell me whether my own car has an open recall?

No. NHTSA publishes recalls per model year, make and model, and offers no public API for a VIN-level check. The server lists every recall of the model. Confirm your vehicle with its VIN at https://www.nhtsa.gov/recalls or with the manufacturer.

Which vehicles can it decode?

Vehicles made for the US market. NHTSA reports about 99 percent decoding success from model year 1995, 60 to 65 percent for 1980 to 1994, and no data before 1980. A missing value means NHTSA has no data on it, not that the vehicle lacks the feature.

Are the complaints verified?

No. They are reports filed by consumers and do not prove a defect. Present them as consumer reports, not as findings.

Why does a model come back as NOT_FOUND?

The recall, complaint and rating datasets each spell models their own way. The answer suggests the closest names, and vehicle_list_safety_models lists the exact spellings for a model year and make.

Is this an official NHTSA service?

No. It is an independent server built on public data, not affiliated with or endorsed by NHTSA or the U.S. Department of Transportation.

Your feedback

Found a bug or a wrong answer? Open an issue on the Issues tab. VIN Decoder & Vehicle Recalls 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.

Changelog

• 0.1.4: Output, dataset and key-value store schemas, as Apify asks for publication: the Output tab of a run started from the Console shows the connection details and one row per tool.
• 0.1.3: the Input tab shows the endpoint and how to connect an AI client, and a run started from the Console outputs the connection details and the tool list
• 0.1.2: pricing events tool-read and tool-action. A batch VIN decode, the complaint statistics and the crash-test ratings (vehicle_decode_vins, vehicle_get_complaints, vehicle_get_safety_ratings) each bill one tool-action event, every other tool one tool-read event
• 0.1.1: server name aligned with the Store title (connector name and connection page). The endpoint and the tools do not change.
• 0.1.0: initial build (private, unpublished)