TransparentCars MCP server
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@TransparentCars MCP serverIs €9,500 for a 2014 Renault Clio with 120,000 km a fair price?"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
TransparentCars MCP server
An MCP server that lets AI assistants work with TransparentCars — honest, budget used cars for the local Portuguese market. Search live stock, check whether a car's asking price is actually fair, estimate the yearly cost of keeping a car on the road, and get in touch.
It's a thin, open-source wrapper over the public transparent.pt API — no keys, no setup beyond adding the server.
Tools
Tool | What it does |
| Search current budget stock by make, model, fuel, gearbox, price, year |
| Full details + specs for one car |
| The market range a car sells for — plus a fair / above-market / below-market verdict on an asking price |
| The annual IUC road tax + a plain running-cost framing for budgeting |
| Canonical brand/model names the other tools expect |
| Ask a human to get in touch (needs the user's consent + contact) |
The fair-price check is the point: paste any listing's price and get a straight answer on whether it's a good deal — no sales spin.
Related MCP server: Clara Carros MCP server
Use it
Remote (add a URL)
https://transparent.pt/mcpAdd it in any client that supports remote/Streamable HTTP MCP servers.
Local (stdio, via npx)
Claude Desktop / Cline / Continue config:
{
"mcpServers": {
"transparentcars": {
"command": "npx",
"args": ["-y", "transparentcars-mcp"]
}
}
}Examples
"Find a manual petrol car under €10,000 in TransparentCars stock."
"A dealer wants €9,500 for a 2014 Renault Clio with 120,000 km — is that fair?"
"What's the yearly road tax on a 2016 petrol, 1200 cc, 120 g/km CO₂?"
"Ask TransparentCars to call me — my name is … and my number is …"
Configuration
Env var | Default | Purpose |
|
| Public API base |
|
| Site key the API is scoped to |
|
| Response language (pt/en) |
|
| HTTP server (remote mode) |
Develop
npm install
npm run build
node dist/index.js # stdio
npm run start:http # remote HTTP on :8099/mcpNotes
Estimates, not guarantees. The fair-price range and running-cost figures are estimates built from real comparable listings and the official road-tax table; treat them as guidance, not a formal valuation.
Privacy.
contact_mesends the details the user provides to TransparentCars (privacy policy); it requires explicit user intent and consent.No business logic or data lives in this repo — it only calls the public API.
MIT © TransparentCars
Available Tools
6 toolscheck_fair_priceAInspect
Check whether a car's asking price is fair for the Portuguese market — the TransparentCars transparency check. Given make, model, year and mileage, it returns the range comparable cars actually sell for (low / typical / high), built from real listings. If you pass asking_price, it also gives a plain verdict: fair, above market, or below market — so a buyer knows before they walk in. Works for ANY car (a listing you found elsewhere, or one of ours). IMPORTANT — pass make/model canonically in Latin: make = full brand name ('Renault', 'Volkswagen' not 'VW'); model = short name WITHOUT engine/trim ('Clio' not 'Clio dCi', 'Golf' not 'Golf 1.5 TSI'). If unsure of spelling, call list_makes_models first.
| Name | Required | Description | Default |
|---|---|---|---|
| hp | No | Power in hp (sharpens the comparison) | |
| km | Yes | Mileage in km | |
| fuel | No | Fuel: petrol, diesel, hybrid, electric | |
| make | Yes | Full brand name in Latin — 'Renault', 'Volkswagen' (not 'VW'), 'Peugeot', 'Seat'. | |
| year | Yes | Registration year | |
| model | Yes | Short model name WITHOUT engine or trim — 'Clio' (not 'Clio 1.5 dCi'), 'Golf' (not 'Golf TSI'). | |
| gearbox | No | Gearbox: manual or automatic | |
| asking_price | No | The price being asked for THIS car, in EUR — pass it to get a fair / above-market / below-market verdict. |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden. It transparently discloses the output behavior: a price range built from real listings, an optional plain verdict, and the canonical-format requirements for make/model. It does not mention potential failure modes or data freshness, but the disclosure is strong for a read-only comparison tool.
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 front-loaded with the core purpose, then explains output, scope, and parameter formatting in a logical order. Every sentence adds value; examples are concrete and the IMPORTANT caution is placed near the end without bloating the text.
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 has no output schema, the description adequately covers return semantics (low/typical/high range and fair/above/below verdict). It also handles the tricky naming prerequisite. It stops short of describing exact output structure or error behavior for unknown or misspelled models, but these are minor gaps for this query-style tool.
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%, so the baseline is 3. The description adds meaningful semantics beyond the schema by explaining why asking_price is passed, and by emphasizing canonical Latin make/model formats with concrete examples ('Renault' not 'VW', 'Clio' not 'Clio dCi'). This materially helps the agent invoke the tool correctly.
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 states a clear verb-resource pair: 'Check whether a car's asking price is fair for the Portuguese market.' It further specifies the inputs (make, model, year, mileage), what is returned (low/typical/high range plus a verdict), and distinguishes itself from inventory tools by noting it works for ANY car, including listings found elsewhere.
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 gives clear usage context—when evaluating a car's price before purchase—and explicitly directs the agent to call list_makes_models first if unsure of spelling. It does not explicitly enumerate exclusions for sibling tools like search_inventory or get_car, but the 'ANY car' statement provides enough distinction.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
contact_meAInspect
Send a contact request to TransparentCars so a human gets in touch. Only call this when the user explicitly asks to be contacted, provides their own name and a phone or email, AND agrees to share those details — pass consent=true only then. Submitting shares the provided contact details per the TransparentCars privacy policy.
| Name | Required | Description | Default |
|---|---|---|---|
| name | Yes | The person's name (as they gave it) | |
| consent | Yes | Set true ONLY if the user explicitly agreed to share their contact details and be contacted | |
| contact | Yes | A phone number or email where they can be reached | |
| message | No | What they want / their question |
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 clearly warns that submitting shares the user's contact details per the privacy policy, which is a critical side effect. It also highlights the strict consent requirement. It could additionally mention what happens after submission, but the essential behavioral traits are transparent.
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 three sentences with no filler. The primary purpose is front-loaded, followed by precise invocation conditions and a privacy consequence. Every sentence earns its place and the structure is easy for an agent 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 the absence of annotations and output schema, the description is remarkably complete for correct invocation. It covers the purpose, the exact preconditions, the consent flag semantics, and the privacy implication. Nothing needed to decide whether and how to call the tool is missing.
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 describes all parameters with 100% coverage, so the baseline is 3. The description adds meaningful context by tying the parameters to user conditions: the name must be the user's own, contact must be a phone/email, and consent must be true only when the user explicitly agrees. This reinforces and clarifies the schema without redundancy.
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 begins with a specific verb and resource ('Send a contact request to TransparentCars') and clearly states the intended outcome ('so a human gets in touch'). This clearly distinguishes the tool from the sibling search and information tools, which serve different purposes.
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 explicitly states when to use the tool: only when the user explicitly asks to be contacted, provides their own name and phone/email, AND agrees to share those details. It even instructs to pass consent=true only under that condition, providing clear and unambiguous usage guidance with exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
cost_to_ownAInspect
Estimate a car's yearly running-cost floor in Portugal — the annual IUC road tax (Imposto Único de Circulação) every owner pays, plus a plain running-cost framing. Needs engine displacement (cc), CO₂ (g/km), fuel and first-registration year. Use this to help a buyer budget the true cost of keeping a car, beyond the sticker price.
| Name | Required | Description | Default |
|---|---|---|---|
| cc | Yes | Engine displacement in cm³, e.g. 1200 | |
| co2 | Yes | CO₂ emissions in g/km, e.g. 120 | |
| fuel | Yes | Fuel: petrol, diesel, hybrid, phev, electric, lpg | |
| used | No | Used vehicle (true, default) | |
| year | Yes | First registration year, e.g. 2016 | |
| month | No | First-registration month (1-12), refines the CO₂ regime |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations exist, so the description carries the full burden. It usefully discloses the 'floor' nature, the annual IUC tax, geographic scope, and required inputs, but it does not explain output format, calculation assumptions, or how optional inputs such as month and used affect the estimate.
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?
Two tight sentences: the core purpose and scope are front-loaded, and the use-case sentence earns its place. There is no filler 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?
For a tax-estimation tool with no output schema and no annotations, the description should say more about what is returned and which factors drive the estimate. It communicates the domain well but leaves the 'plain running-cost framing' and output details vague.
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%, so the baseline is 3. The description only renames the four required parameters in plain terms and adds no meaning beyond the schema, such as how month refines the CO₂ regime or how the used flag affects the result.
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 opening phrase 'Estimate a car's yearly running-cost floor in Portugal' is a specific verb + resource, and naming the IUC road tax anchors the tool precisely. It is clearly distinct from siblings like check_fair_price and search_inventory, which concern price and availability rather than ownership running costs.
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 gives explicit context: 'Use this to help a buyer budget the true cost of keeping a car, beyond the sticker price,' and lists the required inputs. It stops short of a 5 because it does not state when not to use the tool or name a specific alternative tool.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_carAInspect
Get full details for one car in TransparentCars stock by its slug (from a search_inventory link, e.g. 'renault-clio-2016').
| Name | Required | Description | Default |
|---|---|---|---|
| slug | Yes | Car slug from a search_inventory result URL |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations exist, so the description carries the full burden. It conveys that this is a read-only retrieval operation ('Get full details') and gives the identifier source, but it does not disclose response structure, error behavior, or any side effects. This is adequate but not rich.
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 front-loads the core purpose, then adds the essential slug context and an example. Every word contributes.
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 get-by-slug tool, the description is mostly sufficient: it names the resource, input, and source. However, since there is no output schema, the phrase 'full details' is somewhat vague and does not fully specify what information will be returned.
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%, so the baseline is 3. The description adds value beyond the schema by giving a concrete slug format example ('renault-clio-2016') and reaffirming where the slug comes from, which helps an agent construct valid input.
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 uses a specific verb ('Get') and resource ('full details for one car in TransparentCars stock'), and clearly identifies the input mechanism (slug from a search_inventory link). This distinguishes it from sibling tools like search_inventory, which lists inventory, and cost_to_own or check_fair_price, which cover different concerns.
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 clear context: use this after obtaining a slug from a search_inventory result. It does not explicitly name alternatives or state when not to use it, but the workflow implication is strong and unambiguous enough for an agent to select it correctly.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
list_makes_modelsAInspect
List the exact canonical car makes (brands) TransparentCars can search and price — or, given a make, that brand's models — using the exact strings the other tools expect. Call this FIRST (or whenever unsure of spelling) and pass the returned values verbatim into search_inventory / check_fair_price. No make = the list of brands; with a make = that brand's models.
| Name | Required | Description | Default |
|---|---|---|---|
| make | No | Brand to list models for, e.g. 'Renault'. Omit to get the list of brands. |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the burden of behavioral disclosure. It explains the dual behavior (brands vs. models), emphasizes canonical/exact string output, and communicates that results are meant to be reused verbatim. It stops short of explicitly stating that the operation is read-only or describing the exact return format, but for a listing tool this is largely sufficient.
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 two sentences long, front-loaded with the core purpose, and then flows naturally into usage conditions and parameter behavior. Every sentence earns its place, with no filler or repetition of what the schema already states.
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 one optional parameter and no output schema, the description is complete: it explains the two modes, states how results should be used, and names the consumer tools. Nothing needed to call it correctly is missing.
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%, so the baseline is 3. The description goes beyond the schema by clarifying that the returned values are canonical and 'exact strings' that must be passed verbatim, which reinforces why this parameter matters and how the output should be consumed. This adds meaningful context beyond the schema definition.
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 identifies the tool as a reference lookup for canonical car makes and models, explicitly naming the exact strings that other tools expect. It distinguishes itself from sibling tools by positioning itself as the data source to use before search_inventory or check_fair_price.
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 gives explicit, actionable guidance: call this FIRST or whenever unsure of spelling, and pass returned values verbatim into other tools. It also clarifies the two usage modes, with and without the make parameter, leaving no ambiguity about when and how to invoke it.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
search_inventoryAInspect
Search TransparentCars' current stock of budget used cars in Portugal — honestly listed, everyday cars for the local market. Filter by make, model, fuel, gearbox and max price. Returns matching cars with price, year, mileage and a link. IMPORTANT — pass make/model canonically in Latin, as the Portuguese market lists them: make = full brand name ('BMW', 'Mercedes-Benz' not 'Mercedes', 'Volkswagen' not 'VW'); model = the short series/model WITHOUT the engine or trim suffix ('Golf' not 'Golf 1.5 TSI', 'Clio' not 'Clio dCi'). Put the fuel in the fuel field, not the model. If unsure of the spelling, call list_makes_models first.
| Name | Required | Description | Default |
|---|---|---|---|
| fuel | No | Fuel: petrol, diesel, hybrid, phev, electric, lpg | |
| make | No | Full brand name in Latin, as the market lists it — 'Renault', 'Volkswagen' (not 'VW'), 'Peugeot', 'Seat'. | |
| limit | No | Max results (default 20) | |
| model | No | Short model name WITHOUT engine or trim — 'Clio' (not 'Clio 1.5 dCi'), 'Golf' (not 'Golf TSI'). | |
| gearbox | No | Gearbox: manual or automatic | |
| min_year | No | Earliest registration year | |
| max_price | No | Maximum price in EUR |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full behavioral disclosure burden. It reveals return contents, requires canonical Latin make/model spelling, warns against putting fuel in the model field, and instructs to call list_makes_models for uncertain spellings. It does not cover rate limits, errors, or no-match behavior, but the key operational quirks are disclosed.
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 purpose is front-loaded, the critical formatting instructions are grouped under 'IMPORTANT', and the inline examples are useful rather than filler. It is longer than a minimal definition, but every sentence serves either scoping or input-formatting, so the length is justified.
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 7-parameter search with no output schema and no annotations, the description covers the core call envelope: what inventory is searched, how to format make/model correctly, what filters exist, and what the response will contain. It omits mention of min_year and limit in the narrative, and does not address sorting or pagination, but the schema supplies the remaining parameter detail.
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?
Although the input schema already describes all parameters, the description adds substantial meaning beyond those labels: concrete examples and anti-examples ('Mercedes-Benz' not 'Mercedes', 'Golf' not 'Golf 1.5 TSI') and a warning to place fuel only in the fuel field. This is exactly the kind of practical clarification schema descriptions rarely provide.
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 names a specific verb and resource: 'Search TransparentCars' current stock of budget used cars in Portugal.' It also lists the filter dimensions and the returned fields (price, year, mileage, link), which distinguishes it from sibling tools like get_car, check_fair_price, or list_makes_models.
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 clearly establishes when to use this tool—searching current inventory—and explicitly points to list_makes_models as a fallback when spelling is uncertain. It does not explicitly exclude other siblings like check_fair_price or get_car, but the inventory-search context and the named alternative give solid practical guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
6 tool updates
v0.1.0- First observed
check_fair_price - First observed
contact_me - First observed
cost_to_own - First observed
get_car - First observed
list_makes_models - First observed
search_inventory
TDQS
Scored across 6 tools
Each tool has a distinct role: searching stock, retrieving car details, checking fair price, estimating running costs, listing canonical makes/models, and requesting contact. There is no meaningful overlap, and the descriptions clearly separate list-level from detail-level operations.
Most tools follow a clear verb_noun snake_case pattern such as search_inventory, get_car, check_fair_price, and list_makes_models. cost_to_own is a minor deviation since it reads as a noun phrase rather than a verb-object command, but the overall convention is consistent.
Six tools is a well-scoped set for a car marketplace and transparency assistant. Each tool covers a necessary step in the buyer journey without redundancy or bloat.
The tool set covers the full user flow: discover available cars, inspect a specific car, validate price fairness, estimate ownership costs, resolve canonical model names, and initiate contact. No obvious dead ends or missing core operations for the stated purpose.
Related MCP Connectors
Automotive inventory search for AI assistants: vehicles, dealers, deals, and market data.
Used-car listings in Portugal: search, price statistics, comparables and articles.
AI-native used car marketplace. 145K+ vehicles, 4300+ dealers, 13 US states, 20 MCP tools.
Car dealer AI: search inventory, match Car Wanted buyer requests, and draft private offers.
Related MCP Servers
- FlicenseNot gradedqualityDmaintenanceProvides 25 interactive automotive intelligence tools for real-time market data, including VIN decoding, price predictions, and inventory analytics. It enables AI assistants to perform car searches, trade-in estimations, and market trend analysis using the Model Context Protocol.2-
- AlicenseAqualityBmaintenanceEnables AI assistants to search car inventory, estimate import taxes (ISV) and resale values, and request quotes from Clara Carros, a Portuguese used and imported cars marketplace.940 npm1MIT

Vincario MCP Serverofficial
FlicenseNot gradedqualityDmaintenanceEnables AI assistants to decode VINs, check stolen vehicle databases, and retrieve market valuations through natural language.2-- AlicenseAqualityDmaintenanceEnables AI assistants to search and aggregate used-vehicle listings across Cars.com, Autotrader, and KBB, with filters for price, mileage, dealer information, and CARFAX-style history conditions.1MIT