CarsXE
The CarsXE MCP server allows you to query and analyze comprehensive vehicle data from the CarsXE API, delivering Markdown-rich output optimized for LLMs and chatbots. Key capabilities include:
๐ Vehicle Specs โ Retrieve detailed specs (engine, dimensions, trim, equipment, etc.) by VIN
๐ท๏ธ License Plate Decoding โ Look up a VIN and basic info from a license plate and state/country
๐ International VIN Decoder โ Decode international VINs for manufacturer, emissions, and detailed specs
๐ฐ Market Value โ Get estimated retail, trade-in, and MSRP values by VIN
๐ Vehicle History โ Full history reports including accidents, ownership, salvage, odometer, and title brands
๐จ Recalls โ Check open or past safety recalls by VIN
๐ Lien & Theft Info โ Check for active liens or theft/recovery records by VIN
๐ Year/Make/Model Lookup โ Find vehicle details by year, make, model, and optional trim
๐ผ๏ธ Vehicle Images โ Search for vehicle photos filtered by make, model, year, trim, color, angle, and more
๐ ๏ธ OBD Code Decoding โ Decode On-Board Diagnostics trouble codes (e.g., P0115) for diagnosis info
๐ VIN OCR โ Extract a VIN from a vehicle image URL
๐ท๏ธ Plate Image Recognition โ Extract license plate numbers from a vehicle image URL
Multiple queries can be chained in a single conversation (e.g., decode a plate โ get specs โ check recalls โ get market value), and the server integrates with MCP-compatible clients like Claude Desktop, Cursor, VS Code, and Windsurf.
Enables GitHub Copilot in VS Code to access real-time vehicle data from CarsXE API, allowing developers to query vehicle specifications, market values, and history reports directly within their coding environment.
๐ CarsXE MCP Server
A modular, extensible Model Context Protocol (MCP) server for querying and analyzing vehicle data from the CarsXE API, with beautiful, chat-friendly Markdown output for LLMs and chatbots.
โน๏ธ What is CarsXE MCP Server?
The CarsXE MCP server is a Node.js/TypeScript application that exposes a suite of tools for querying comprehensive vehicle data from the CarsXE API. It is designed for seamless integration with LLMs (like Anthropic Claude, OpenAI GPT, etc.), chatbots, and developer tools, providing:
๐งฉ Clean, modular code for each CarsXE endpoint
๐ Consistent, Markdown-rich output for chat/LLM environments
๐ก๏ธ Robust error handling and user-friendly messages
๐ Easy extensibility for new endpoints and features
Related MCP server: Vehicle Database MCP Server
๐ก Why Use CarsXE with MCP?
Connecting CarsXE to your AI editor or chat client via MCP gives you a supercharged vehicle data experience โ directly inside the tools you already use:
Benefit | Description |
Ask in plain English | No need to know API endpoints or parameters โ just describe what you want |
Context-aware answers | The AI combines live vehicle data with your question for tailored, actionable responses |
No tab switching | Get VIN specs, history, recalls, and values without leaving your editor or chat |
Chain requests effortlessly | Decode a plate โ get full specs โ check recalls โ get market value, all in one conversation |
Always live data | Every query hits the CarsXE API in real time โ no stale cache or outdated results |
Works in your favorite editor | Claude Desktop, Cursor, VS Code, Windsurf, and any MCP-compatible client |
โจ Features
๐ค Uses Anthropic Claude to generate comprehensive, professional answers based on the API data and user query
๐ Query vehicle specs, history, images, recalls, market value, and more
๐ท๏ธ Decode license plates and VINs (including OCR from images)
๐ ๏ธ Decode OBD (On-Board Diagnostics) codes
๐จ All endpoints return elegant, grouped, emoji-rich Markdown
๐งโ๐ป Modular code: types, API logic, and formatters are separated for maintainability
๐งช Simple to run, test, and extend
โ๏ธ Prerequisites
CarsXE API key (get one here)
๐ฅ๏ธ Installation by Editor
All editors use the same remote MCP endpoint. Replace YOUR_API_KEY with your actual CarsXE API key in every config below.
Claude Desktop
1๏ธโฃ Download and Install Claude Desktop
Go to the official Claude Desktop download page
Download the installer for your operating system (macOS, Windows, or Linux)
Install Claude Desktop by following the on-screen instructions
2๏ธโฃ Configure Claude Desktop to Use the CarsXE MCP Server
a. Open Claude Desktop Settings
Launch the Claude Desktop app
Click on Claude in the menu bar
Select Settings
In the Settings window, go to the Developer tab (you may need to scroll or expand advanced options)
Click Edit Config (or Open Config File)
b. Edit the Configuration File
This will open the
claude_desktop_config.jsonfile in your default text editor.Locate the
"mcpServers"section. If it does not exist, add it as shown below.Add or update the following entry for CarsXE:
"mcpServers": { "carsxe": { "command": "npx", "args": [ "mcp-remote@latest", "https://mcp.carsxe.com/mcp", "--header", "X-API-Key: YOUR_API_KEY" ] } },Replace
YOUR_API_KEYwith your actual CarsXE API KeyTip: You can add multiple MCP servers under
"mcpServers"if you use more than one.Save the configuration file and close your editor.
c. Restart Claude Desktop
Close and reopen the Claude Desktop app to apply the new configuration.
It may take a short delay for the changes to take effect.
3๏ธโฃ Verify the CarsXE MCP Server is Available
After restarting, open Claude Desktop.
Go to the tools or plugins section (usually in the search bar or under a tools menu).
You should see CarsXE listed as an available MCP server/tool.
Try running a CarsXE tool (e.g., get_vehicle_specs) to verify everything is working.
This will only work if your API key is associated with an active subscription.
Cursor
The install dialog will open pre-filled with:
Field | Value |
Name | CarsXE |
Type | streamableHttp |
URL | |
Header |
|
Replace YOUR_API_KEY with your actual CarsXE API key, then click Install.
Visual Studio Code (GitHub Copilot)
Install CarsXE MCP for VS Code
After clicking install, you'll need to add your API key manually:
Open Command Palette (
Ctrl+Shift+P/Cmd+Shift+P)Run MCP: List Servers
Find CarsXE in the list and click on it
Click Show Configuration
Replace
YOUR_API_KEYwith your actual CarsXE API key:
"CarsXE": {
"type": "http",
"url": "https://mcp.carsxe.com/mcp",
"headers": {
"X-API-Key": "YOUR_ACTUAL_KEY_HERE"
}
}Save the file โ VS Code will connect automatically.
Note: Make sure you have the GitHub Copilot extension installed and agent mode enabled (
chat.agent.enabledin VS Code settings).
Windsurf
1๏ธโฃ Open MCP Configuration
Go to Windsurf Settings โ MCP (or press
Ctrl+,and search for MCP)Click "Edit Config" to open
~/.codeium/windsurf/mcp_config.json
2๏ธโฃ Add the CarsXE Server
{
"mcpServers": {
"carsxe": {
"command": "npx",
"args": [
"mcp-remote@latest",
"https://mcp.carsxe.com/mcp",
"--header",
"X-API-Key: YOUR_API_KEY"
]
}
}
}3๏ธโฃ Restart Windsurf
Reload the window or restart Windsurf. Open the Cascade chat panel โ CarsXE tools will appear automatically.
Other Editors (Manual / Generic)
For any other MCP-compatible client, register a remote MCP server using:
Endpoint:
https://mcp.carsxe.com/mcpTransport: HTTP (Streamable HTTP)
Auth header:
X-API-Key: YOUR_API_KEY
Consult your editor's MCP documentation for the exact configuration format.
๐ ๏ธ Available Tools & Example Prompts
Below is a list of all available CarsXE tools, their parameters, and example prompts. These prompts work in any MCP-connected client.
1. get_vehicle_specs ๐
Description: Get comprehensive vehicle specifications by VIN
Parameters:
vin(string, required): 17-character Vehicle Identification Number
Example Prompts:
What are the full specs for VIN
WBAFR7C57CC811956?Is this a V6 or V8? VIN:
WBAFR7C57CC811956What trim level is
WBAFR7C57CC811956?Output: Markdown-formatted vehicle specs (year, make, model, engine, dimensions, colors, equipment, etc.)
2. decode_license_plate ๐ท๏ธ
Description: Decode a vehicle's license plate to get VIN and basic info
Parameters:
plate(string, required): License plate numberstate(string, optional): State abbreviation (e.g., CA)country(string, required, default: US): Country code
Example Prompts:
What car has license plate
7XER187in California?Decode plate
7XER187stateCALook up the plate
ABC1234in TexasOutput: Markdown summary of decoded vehicle info (VIN, make, model, year, etc.)
3. decode_international_vin ๐
Description: Decode an international VIN for detailed info
Parameters:
vin(string, required): 17-character VIN
Example Prompts:
Decode this European VIN:
WF0MXXGBWM8R43240What car is
WAUZZZ8K9AA123456? It's a German VIN.Output: Markdown with international vehicle details (manufacturer, specs, emissions, etc.)
4. get_market_value ๐ฐ
Description: Get estimated market value for a vehicle by VIN
Parameters:
vin(string, required): 17-character VINstate(string, optional): US state abbreviationmileage(number, optional): Current mileage of the vehicle to adjust the market valuecondition(string, optional): Overall condition of the vehicle โexcellent,clean,average, orrough
Example Prompts:
How much is
WBAFR7C57CC811956worth?I'm thinking of buying VIN
WBAFR7C57CC811956โ what's a fair price?What's the trade-in value for
WBAFR7C57CC811956in Florida with 45,000 miles in clean condition?Output: Markdown with market value breakdown (retail, trade-in, MSRP, etc.)
5. get_vehicle_history ๐
Description: Get a comprehensive vehicle history report by VIN
Parameters:
vin(string, required): 17-character VINformat(string, optional): Response format (json or xml)
Example Prompts:
Has
WBAFR7C57CC811956ever been in an accident?Show me the full history for VIN
WBAFR7C57CC811956How many owners has
WBAFR7C57CC811956had?Output: Markdown with history records (junk/salvage, insurance, brands, titles, odometer, etc.)
6. get_vehicle_images ๐ผ๏ธ
Description: Get vehicle images by make, model, and filters
Parameters:
make(string, required)model(string, required)year,trim,color,transparent,angle,photoType,size,license,format(all optional)
Example Prompts:
Show me photos of a blue 2018 Toyota Tacoma
Get images of a red 2022 Ford Mustang GT
What does a white 2020 Tesla Model 3 look like?
Output: Markdown with up to 5 images (links, thumbnails, details)
7. get_vehicle_recalls ๐จ
Description: Get vehicle recall information by VIN
Parameters:
vin(string, required): 17-character VIN
Example Prompts:
Does
1C4JJXR64PW696340have any open recalls?I just bought VIN
1C4JJXR64PW696340โ should I be worried about recalls?Check for safety recalls on
WBAFR7C57CC811956Output: Markdown with recall details (date, description, risk, remedy, status, etc.)
8. read_license_plate_from_image ๐ท๏ธ
Description: Recognize and extract license plate(s) from a vehicle image URL
Parameters:
imageUrl(string, required): Direct URL to an image of a vehicle's license plate
Example Prompts:
What's the plate number in this image?
https://api.carsxe.com/img/apis/plate_recognition.JPGRead the license plate from this photo:
[image URL]Output: Markdown with detected plates, confidence scores, bounding boxes, vehicle type, etc.
9. extract_vin_from_image ๐
Description: Extract the VIN from a vehicle image using OCR
Parameters:
imageUrl(string, required): Direct URL to an image of a vehicle's VIN
Example Prompts:
Extract the VIN from this image:
https://user-images.githubusercontent.com/5663423/30922082-64edb4fa-a3a8-11e7-873e-3fbcdce8ea3a.pngWhat's the VIN in this photo?
https://res.cloudinary.com/carsxe/image/upload/q_auto/f_auto/v1713204144/base/images/vin-ocr/vin.jpgOutput: Markdown with detected VIN, confidence, bounding box, and candidates
10. get_year_make_model ๐
Description: Get comprehensive vehicle info by year, make, model, and optional trim
Parameters:
year(string, required)make(string, required)model(string, required)trim(string, optional)
Example Prompts:
What are the specs for a 2020 Toyota Camry?
Tell me about the 2019 Honda Civic Sport trim
What colors were available on the 2021 Ford F-150?
Output: Markdown with vehicle details, colors, features, options, and packages
11. decode_obd_code ๐ ๏ธ
Description: Decode an OBD code and get diagnosis information
Parameters:
code(string, required): OBD code (e.g., P0115)
Example Prompts:
My check engine light is on with code
P0115โ what does it mean?Decode OBD code
P0300I have a
C1234code on my dashboard โ is it serious?Output: Markdown with code, diagnosis, and date
12. check_lien_and_theft ๐
Description: Get lien and theft information for a vehicle by VIN
Parameters:
vin(string, required): 17-character Vehicle Identification Number
Example Prompts:
Is there a lien on
WBAFR7C57CC811956?I'm buying a used car with VIN
WBAFR7C57CC811956โ check if it's stolenVerify the title is clean for
WBAFR7C57CC811956Output: Markdown with lien holder information, theft records, recovery dates, and status
๐ Chaining Tools โ Power User Examples
The real power of CarsXE MCP comes from chaining tools in a single conversation:
Scenario 1 โ Pre-purchase due diligence:
Decode plate
7XER187in CaliforniaNow get its full history
Does it have any open recalls?
What's it worth if I buy it today?
Scenario 2 โ Spotted a car on the street:
Read the plate from this image:
[photo URL]Look up that plate in Texas
Show me photos of that car model
Scenario 3 โ Mechanic / service shop:
Decode this VIN from the dashboard photo:
[image URL]Get its full specs
My customer says the check engine code is P0300 โ what does that mean for this vehicle?
๐ OAuth 2.1 (Claude.ai custom connector)
The hosted server at https://mcp.carsxe.com/mcp supports two authentication methods:
API key (unchanged) โ
X-API-Keyheader,Authorization: Bearer <api-key>, or?key=query parameter. Used by Claude Desktop /mcp-remoteand local clients.OAuth 2.1 โ used by hosted MCP clients such as the Claude.ai custom connector. Clicking Connect in Claude.ai runs a standard Authorization Code + PKCE flow: dynamic client registration (RFC 7591), browser sign-in on the CarsXE consent page, then token exchange. Access tokens (
mcp_at_*, 1 h) map to the user's CarsXE API key; refresh tokens (mcp_rt_*, 90 d) are rotated on every refresh.
Requests with no credentials get 401 with a WWW-Authenticate challenge, which is what prompts Claude.ai to start the flow.
Environment variables
Variable | Default | Purpose |
|
| Issuer / endpoint base in the discovery metadata |
|
| CarsXE web app hosting the OAuth logic |
| (unset) | Set in the host environment, never commit. When unset, OAuth bearer tokens are rejected but API-key auth keeps working. |
The Cloudflare Workers deployment (
src/index.ts) does not serve the OAuth surface โ only the GCP Cloud Run deployment (src/index.gcp.ts) behindmcp.carsxe.comdoes.
Available Tools
12 toolsdecode-obd-codeBInspect
Decode an OBD code and get diagnosis information
| Name | Required | Description | Default |
|---|---|---|---|
| code | Yes | OBD code to decode (e.g., P0115) |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description must fully disclose behavior. It only states the action and output type but omits details like input format validation, error handling, or response structure.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence. While very concise, it could be slightly more structured (e.g., noting the output format) without becoming verbose.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's simplicity (one parameter, no output schema), the description is adequate but leaves room for improvement, such as clarifying what 'diagnosis information' entails.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema already covers the parameter with an example. The description adds no further parameter-level detail, but with 100% schema coverage, the baseline is met.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool decodes an OBD code and provides diagnosis information, which distinguishes it from sibling tools that deal with vehicle plates, VINs, or other data.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage when an OBD code is available, but lacks explicit guidance on when to use this tool versus alternatives or any prerequisites.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
decode-vehicle-plateBInspect
Decode a vehicle's license plate to get VIN and basic vehicle info
| Name | Required | Description | Default |
|---|---|---|---|
| plate | Yes | License plate number | |
| state | Yes | State abbreviation (e.g., CA) | |
| country | No | Country code (default: US) | US |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are present, so the description bears full responsibility for behavioral disclosure. It merely restates the purpose, offering no details on data sources, failure modes, rate limits, or any side effects beyond decoding.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, concise sentence with no wasted words. However, it lacks any structural elements like headings or bullet points that could improve readability.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Without an output schema, the description should clarify what 'basic vehicle info' includes, but it only mentions VIN. This leaves the agent uncertain about the return format and completeness, especially given the rich sibling tool set.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, with each parameter having a description. The description adds no extra meaning beyond the schema, so baseline score 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('Decode') and the resource ('vehicle's license plate'), with a specific outcome ('get VIN and basic vehicle info'). It distinguishes from siblings like recognize-plate-image and vin-ocr, which deal with images or OCR.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No usage guidance is provided. The description does not specify when to use this tool versus alternatives, nor does it mention prerequisites or scenarios to avoid.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get-lien-theftAInspect
Get lien and theft information for a vehicle by VIN
| Name | Required | Description | Default |
|---|---|---|---|
| vin | Yes | 17-character Vehicle Identification Number |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description implies a read operation ('Get'), which aligns with typical expectations. However, without annotations, it does not disclose potential limitations, such as whether the data is real-time, cached, or requires special permissions. For a simple retrieval, this is adequate but not exceptional.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, concise sentence that conveys the tool's purpose without any superfluous words. It is well-structured and front-loaded with the action and subject.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple one-parameter retrieval tool with no output schema, the description adequately explains what the tool does and requires. It does not elaborate on return format or data freshness, but given the tool's simplicity, it is reasonably complete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema already fully describes the 'vin' parameter with constraints (17 characters). The description adds no new semantic information beyond stating 'by VIN', which is already implicit. With 100% schema coverage, the description meets the baseline but adds little extra value.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states it retrieves lien and theft information by VIN, using a specific verb and resource. It distinguishes itself from sibling tools like get-vehicle-history, which covers broader history, and get-vehicle-specs, which covers specifications.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives such as get-vehicle-history or decode-vehicle-plate. It does not mention prerequisites, exclusions, or contexts where another tool would be more appropriate.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get-market-valueBInspect
Get the estimated market value for a vehicle by VIN
| Name | Required | Description | Default |
|---|---|---|---|
| vin | Yes | 17-character Vehicle Identification Number | |
| state | No | US state abbreviation (optional) | |
| mileage | No | Current mileage of the vehicle used to adjust the market value (optional) | |
| condition | No | Overall condition of the vehicle: excellent, clean, average, or rough (optional) |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are present, and the description does not disclose any behavioral traits such as data freshness, accuracy guarantees, or that it requires only a VIN to function. It also does not mention if there are any side effects or dependencies (e.g., external data source).
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, concise sentence that effectively communicates the tool's purpose without any superfluous words. It is well-structured and easy to parse.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no output schema, the description should explain what the tool returns (e.g., estimated value, confidence level, source). It only states 'estimated market value' without mentioning the format or additional details. Optional parameters like 'state' and 'mileage' are not explained in context of their effect on the estimate.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 100% description coverage, so each parameter is documented. The description adds no extra meaning beyond what the schema already provides. Baseline score of 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's action ('Get the estimated market value') and the resource ('a vehicle by VIN'), making its purpose unambiguous. It effectively distinguishes from siblings like 'get-vehicle-specs' or 'get-vehicle-history' which have different outputs.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool versus alternatives. For example, 'get-vehicle-history' also uses VIN, and a user might need to decide based on whether they need market value or full history. The description does not mention typical use cases or prerequisites.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get-vehicle-historyCInspect
Get a comprehensive vehicle history report by VIN
| Name | Required | Description | Default |
|---|---|---|---|
| vin | Yes | 17-character Vehicle Identification Number | |
| format | No | Response format (json or xml, default: json) |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, so the description must convey behavioral traits. It only states the general action, omitting details like data sources, response structure, error handling, or rate limits, which are critical for safe invocation.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single sentence with no unnecessary words. It is front-loaded with the key action and resource, efficiently conveying the purpose without clutter.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the complexity of a vehicle history report (likely many output fields) and no output schema, the description lacks completeness. It does not describe return values, possible errors, or provide context for sibling tools, leaving the agent underinformed.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema already explains both parameters (vin and format). The description adds no additional meaning beyond what the schema provides, meeting the baseline but not exceeding it.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool retrieves a vehicle history report by VIN, which is a specific action and resource. It distinguishes from sibling tools like get-vehicle-specs or get-vehicle-recalls by focusing on 'history report', but lacks explicit differentiation.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance on when to use this tool versus alternatives such as decode-vehicle-plate or get-lien-theft. The description does not mention prerequisites, exceptions, or related tools.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get-vehicle-imagesBInspect
Get vehicle images by make, model, and optional filters
| Name | Required | Description | Default |
|---|---|---|---|
| make | Yes | Vehicle make (required) | |
| model | Yes | Vehicle model (required) | |
| year | No | Vehicle year (optional) | |
| trim | No | Vehicle trim (optional) | |
| color | No | Vehicle color (optional) | |
| transparent | No | Transparent background (optional) | |
| angle | No | Angle: front, side, back (optional) | |
| photoType | No | interior, exterior, engine (optional) | |
| size | No | Small, Medium, Large, Wallpaper, All (optional) | |
| license | No | Public, Share, ShareCommercially, Modify, ModifyCommercially (optional) | |
| format | No | json or xml (optional, default: json) |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description must cover behavioral traits, but it only says 'Get vehicle images' without disclosing return format, authentication, rate limits, or error behavior.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Single sentence, 9 words, no redundancy. Front-loaded with key information.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For an 11-parameter tool with no output schema, the description is too sparse. It does not explain how images are delivered, what filtering combinations work, or any limitations.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so parameters are well-documented in the schema. The description adds no extra meaning beyond summarizing their purpose.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action (Get) and resource (vehicle images) with filtering criteria (by make, model, optional filters), distinguishing it from sibling tools that handle decoding or valuation.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance on when to use this tool versus alternatives, prerequisites, or limitations. The description implies retrieval but does not specify context for use.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get-vehicle-recallsBInspect
Get vehicle recall information by VIN
| Name | Required | Description | Default |
|---|---|---|---|
| vin | Yes | 17-character Vehicle Identification Number |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description should disclose behavioral traits (e.g., rate limits, cache behavior, response format), but it does not. Only states the basic function.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Single sentence is efficient and fronts the key information. Could be more structured but no wasted words.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple tool with no output schema, the description omits what recall information is returned, error handling, and behavior for invalid VINs, leaving the agent underinformed.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema already fully describes the 'vin' parameter (17 characters, required). The description adds minimal additional meaning ('by VIN'), so a baseline 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool retrieves recall information using a VIN, which is specific and distinguishes from sibling tools like decode-obd-code or get-vehicle-history.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance on when to use this tool versus alternatives, such as for filtering recalls or prerequisites like VIN validity.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get-vehicle-specsBInspect
Get comprehensive vehicle specifications by VIN
| Name | Required | Description | Default |
|---|---|---|---|
| vin | Yes | 17-character Vehicle Identification Number |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, so description bears full burden. It does not disclose what 'comprehensive' includes, response structure, authentication needs, or side effects. Vague.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Single sentence, no fluff. Could add a bit more context without being verbose, but current structure is efficient.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Despite minimal parameters, lack of annotations and output schema means description should compensate. It does not specify scope of 'comprehensive' or expected results, leaving ambiguity.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema covers 100% of parameters with description for 'vin'. Description adds no extra meaning beyond 'by VIN', which is already implied. Baseline 3 for high coverage.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Clear verb ('get'), resource ('vehicle specifications'), and method ('by VIN'). Distinguishes from sibling tools like 'get-vehicle-history' or 'get-market-value' by focusing on specifications.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance on when to use this tool versus alternatives (e.g., when to prefer decode-obd-code or I international-vin-decoder). No mention of prerequisites or limitations.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get-year-make-modelBInspect
Get comprehensive vehicle info by year, make, model, and optional trim
| Name | Required | Description | Default |
|---|---|---|---|
| year | Yes | Manufacturing year of the vehicle (e.g., 2023) | |
| make | Yes | Vehicle make (e.g., Toyota) | |
| model | Yes | Vehicle model (e.g., Camry) | |
| trim | No | Vehicle trim (optional, e.g., XLE) |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description must disclose behavioral traits. However, it only mentions 'comprehensive vehicle info' without specifying what that includes (e.g., specs, recalls, images), any side effects (e.g., mutating data), or required permissions. This is insufficient for a tool with no annotation safety net.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, concise sentence that starts with the action verb 'Get'. It is not verbose, but could benefit from additional context without becoming overly long.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no output schema, the description should explain what 'comprehensive vehicle info' entails (e.g., returned fields, format). It also fails to mention any constraints (e.g., valid year range, supported makes/models). The tool's complexity (4 params, no output schema) demands a richer description.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the baseline is 3. The description adds 'comprehensive' and notes trim is optional, but these details are already implicit in the schema. No new semantic information beyond the schema is provided.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: retrieving comprehensive vehicle information based on year, make, model, and optional trim. It uses a specific verb ('Get') and resource ('vehicle info'), differentiating it from sibling tools that handle decoding plates, market values, or history.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool versus its siblings (e.g., get-vehicle-specs, get-vehicle-history). The description does not indicate any prerequisites or limitations, leaving the agent without context for selection.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
international-vin-decoderBInspect
Decode an international VIN and get detailed vehicle info
| Name | Required | Description | Default |
|---|---|---|---|
| vin | Yes | 17-character Vehicle Identification Number |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided. The description does not disclose read-only nature, authentication needs, or what 'detailed vehicle info' includes. This under-specifies behavioral traits.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Single sentence that is front-loaded and contains no fluff. Appropriate length for this simple tool.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
No output schema and no description of return format, error handling, or what 'detailed vehicle info' entails. Incomplete for an agent to predict outcomes.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100% with clear constraints on the vin parameter. The description adds no extra meaning beyond the schema, so baseline 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool decodes an international VIN and returns detailed vehicle info. It is distinct from sibling tools like decode-vehicle-plate or get-vehicle-specs.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance on when to use this tool vs alternatives. It is implied for VIN decoding, but lacks explicit context like not for plates or OBD codes.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
recognize-plate-imageBInspect
Recognize and extract license plate(s) from a vehicle image URL
| Name | Required | Description | Default |
|---|---|---|---|
| imageUrl | Yes | Direct URL to an image of a vehicle's license plate |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It only states the basic action and source, but omits critical details like output format, error handling, input constraints, or limitations (e.g., image quality, plate orientation).
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, well-structured sentence that is front-loaded with the key information. No extraneous words or repetition.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the lack of output schema and annotations, the description should provide more context about return values, possible multiple plates, and failure modes. It is insufficient for an agent to fully understand the tool's behavior.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema already provides a description for the parameter ('Direct URL to an image of a vehicle's license plate'), achieving 100% coverage. The tool description adds no further semantic detail about the parameter beyond what the schema offers.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: recognize and extract license plate(s) from a vehicle image URL. It uses a specific verb-resource combination and distinguishes from sibling tools like 'decode-vehicle-plate' or 'vin-ocr'.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool over alternatives. There is no mention of prerequisites, context, or exclusions, leaving the agent to infer usage.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
vin-ocrBInspect
Recognize and extract the VIN from a vehicle image URL using OCR
| Name | Required | Description | Default |
|---|---|---|---|
| imageUrl | Yes | Direct URL to an image of a vehicle's VIN (photo or scan) |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries full responsibility for behavioral disclosure, but it only states the basic function. It does not mention potential failure conditions (e.g., poor image quality), output format, or any side effects. This leaves significant gaps for an agent.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, well-structured sentence with no filler. It efficiently conveys the core function.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple OCR tool with one parameter and no output schema, the description is minimally adequate. However, it lacks details about return values, error handling, or examples, which would improve completeness given the presence of related siblings.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 100% description coverage for the single parameter (imageUrl), and the description merely restates the purpose. No additional semantic value is added beyond what the schema already provides.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('Recognize and extract'), the resource ('VIN from a vehicle image URL'), and the method ('using OCR'). It effectively distinguishes this tool from siblings like 'recognize-plate-image' (for license plates) and 'decode-vehicle-plate' (for decoding plate data).
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no explicit guidance on when to use this tool versus alternatives, nor does it mention prerequisites or limitations. Without any usage context, the agent must rely only on the tool name and siblings.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
TDQS
Each tool has a clearly distinct purpose: OBD decoding, plate decoding, VIN-based lookups (lien, market value, history, recalls, specs), image retrieval by make/model, and OCR for plates and VINs. No two tools overlap in functionality.
All tool names follow a consistent hyphenated verb_noun pattern (e.g., decode-obd-code, get-vehicle-history). The naming is predictable and clearly indicates the action and resource.
With 12 tools, the set is well-scoped for a vehicle information server. Each tool addresses a specific need without being excessive or insufficient.
The tool set covers major vehicle data categories: VIN decoding, plate decoding, OBD codes, history, market value, theft/lien, recalls, specs, images, and OCR. No obvious gaps exist for the stated purpose.
Maintenance
Resources
Unclaimed servers have limited discoverability.
Looking for Admin?
If you are the server author, to access and configure the admin panel.
Related MCP Connectors
Vehicle data for AI: VIN decoder, automotive specs, stolen checks, valuation and way more.
VIN decoding and European vehicle data for automotive workflows.
Decode any VIN and check open NHTSA safety recalls. Free official US government data, no auth.
MarketCheck automotive data: search US/UK listings, predict prices, decode VINs, market history.
Related MCP Servers
- AlicenseAqualityDmaintenanceAggregates and searches used car listings from multiple sources (Cars.com, Autotrader, KBB) with price, mileage, dealer info, and optional CarFax-style filters (1-owner, no accidents, personal use).14MIT
- AlicenseCqualityDmaintenanceEnables access to comprehensive vehicle information including VIN decoding, license plate OCR, vehicle history checks (theft, title, salvage records), market valuations, specifications, and warranty data for vehicles across North America and Europe.6611MIT
- AlicenseNot gradedqualityDmaintenanceProvides comprehensive vehicle reports by aggregating data from multiple public sources to decode VINs, check recalls, and view safety ratings. It enables users to validate VINs locally and retrieve technical specifications, fuel economy, and vehicle photos without requiring API keys.16MIT

Vincario MCP Serverofficial
FlicenseNot gradedqualityDmaintenanceEnables AI assistants to decode VINs, check stolen vehicle databases, and retrieve market valuations through natural language.2
Latest Blog Posts
- Who's Calling? MCP Hosts Are an Identity Blind Spot (And the Spec Knows It)By Om-Shree-0709 on .mcpAgent IdentityOAuth 2.1
- Your AI Chatbot Just Exposed Your CEO's Salary to an InternBy Om-Shree-0709 on .Agent IdentityMCP SecurityOAuth Delegation
- Why MCP Servers Need Execution Sandboxing (And Why Your Current Stack Isn't Enough)By Om-Shree-0709 on .Agentic AiPrompt InjectionWebAssembly
MCP directory API
We provide all the information about MCP servers via our MCP API.
curl -X GET 'https://glama.ai/api/mcp/v1/servers/carsxe/carsxe-mcp-server'
If you have feedback or need assistance with the MCP directory API, please join our Discord server