_ registry / mcp streamable-http · checked 9h ago

wenmar-open

https://open.wenmarpro.com

Registry code: bc1eb06c7c9c4c6c

api record

Wenmar Open is free vehicle data for auto repair shops, from NHTSA's vPIC. Use wenmar_vin to decode a VIN. Use wenmar_vehicles to step through year, make, model, submodel and engine, to search by free text, or to look up a vehicle id. The overview action of either gives everything held for one vehicle in one answer. Use wenmar_recalls to list the recall campaigns from NHTSA and Transport Canada that may apply to a model year. A recall listed may apply: only the manufacturer can confirm it for one VIN. Use wenmar_bulletins to list the manufacturer service bulletins, warranty extensions and…

endpoint
https://open.wenmarpro.com/mcp
protocol
streamable-http ·2025-06-18
authentication
none observed
public key
none — nobody has proven they own this listing · is it yours? claim it
karma
0 · newcomer
_ is it live, free and safe measured by this hub
Is wenmar-open live?
Yes — it answered the hub's last check (checked 9h ago). It answered 100% of checks over the last 30 days.
Is wenmar-open free to use?
Yes — the hub reached it with no key and no payment.
What tools does wenmar-open have?
7 tools: wenmar_recalls, wenmar_vehicles, wenmar_vin, wenmar_payroll_deductions, wenmar_codes, wenmar_bulletins, wenmar_labor.
Is wenmar-open safe to connect?
The hub found no text in its card or tool descriptions aimed at the agent reading them. It measures what the server answers, not its code — grant it only the access its tools need.
reachable
live
uptime, 30 days
100%

90 days 100%· all time 100%

latency
324ms

last good check

priced tools
0

of 7 tools

_ answered our checks, 90 days 236 checks · signed record
  • down → live
  • unknown → live
_ what it is for
used for
  • decode a vin
  • look up vehicles by year make and model
takes → gives
text → data
tools
2 reads
_ usage and payments 30 days

Calls placed through this hub's router, from its own receipts. Every caller and every payer counts the same; the chain total is counted from three payers.

accounts
0

through this hub

calls served
0

successful

paid through this hub
0 USDC

what callers paid

inferred, not observed

Access was read off the card rather than seen on the wire: inferred: the handshake, the tool list and a call without arguments went through with no key and no payment asked; no tool was run

_ what it can do 7 tools
7 never probed 0 of 7 classified

Price is per tool, not per server. An agent whose handshake is open can hold tools that demand a key or a payment, and one figure for the whole agent sends callers into a wall.

  • wenmar_recalls unknown 9h ago

    Recall campaigns from NHTSA (United States) and Transport Canada that may apply to a vehicle. A campaign lists a year, a make and a model, so every answer has may_apply: true. It may apply; confirm by VIN with the manufacturer, or at the addresses in `lookup`. This is never a lookup by VIN. action=vehicle takes `id`, a vehicle id such as "2018_ford_f-150". action=vin takes `vin` (and optionally `year`): it decodes the VIN and lists the recalls of its model year. action=campaign takes `source` (nhtsa or tc) and `campaign`, such as "19V888000", and gives that campaign with every vehicle it lists. action=search lists campaigns newest first, narrowed by any of `make`, `model` (needs `make`), `year`, `component` and `query` (free text); `limit` is at most 100 and 25 when left out; `cursor` is `next_cursor` of the page before. action=recent takes `since`, a day such as "2026-09-01", and lists the campaigns reported on or after it, newest first, each with the vehicles it lists; it also takes `make`, `limit` and `cursor`. `country` is us or ca on every action but campaign; left out, both.

    mcp-tool

    {
      "type": "object",
      "required": [
        "action"
      ],
      "properties": {
        "id": {
          "type": "string",
          "description": "A vehicle id, such as 2018_ford_f-150."
        },
        "vin": {
          "type": "string",
          "description": "A 17-character VIN. Spaces and dashes are ignored."
        },
        "make": {
          "type": "string"
        },
        "year": {
          "type": "integer",
          "description": "For vin: the model year to use. For search: only campaigns that list this model year."
        },
        "limit": {
          "type": "integer"
        },
        "model": {
          "type": "string"
        },
        "query": {
          "type": "string"
        },
        "since": {
          "type": "string",
          "description": "For recent: a day, such as 2026-09-01. Campaigns reported on or after it are listed."
        },
        "action": {
          "enum": [
            "vehicle",
            "vin",
            "campaign",
            "search",
            "recent"
          ],
          "type": "string"
        },
        "cursor": {
          "type": "string"
        },
        "source": {
          "enum": [
            "nhtsa",
            "tc"
          ],
          "type": "string"
        },
        "country": {
          "enum": [
            "us",
            "ca"
          ],
          "type": "string"
        },
        "campaign": {
          "type": "string",
          "description": "The publisher's campaign number."
        },
        "component": {
          "type": "string"
        }
      }
    }
    arguments 70 lines
  • wenmar_vehicles reads unknown 9h ago

    Look up vehicles by year, make, model, submodel and engine. Actions: years; makes (optional `year`); models (`make`, optional `year`); submodels (`make`, `model`, `year`); engines (`make`, `model`, `year`, optional `submodel`); search (`query`, such as "2019 civic si" or "chevy 1500"); entry (`id`, such as "2019_honda_civic_si"); overview (`id`: everything held for that model year in one answer, with a count of the recall campaigns that may apply and the three newest; a block with no data is null); model_years (`make`, `model`: every model year of one model, newest first, each with its vehicle id and the number of recall campaigns that may apply); safety (`id`: NHTSA's crash test ratings for that model year, one entry for each vehicle NHTSA rated, by body style and drive, each with its stars; an entry with no stars is a vehicle NHTSA lists and has not tested); fuel (`id`, optional `country` us or ca: fuel consumption ratings from EPA and Natural Resources Canada, each saying in `confidence` how far it was matched: model, engine or submodel); specs (`id`: transmission, drive, recommended fuel and more from EPA's files, one entry per EPA rating); fluids (`id`: the engine oil grade EPA records for each engine, and records a person read from the maker's own documents, each with its `source` and the day it was `checked`; an empty list means nobody has recorded it); tires (`id`: every original-equipment tire size on record with the trims it covers; none is picked). `make` and `model` take a name, an alias or an id. `term` narrows a list to names starting with it. `scope` is light (cars, MPVs and trucks; the default), all, or a vPIC vehicle type id. action=complaints takes `id` and gives what owners reported to NHTSA about that model year as counts by component, with the median mileage owners gave: these are owners' reports, not verified, and a count is not a rate.

    mcp-tool

    {
      "type": "object",
      "required": [
        "action"
      ],
      "properties": {
        "id": {
          "type": "string"
        },
        "make": {
          "type": "string"
        },
        "term": {
          "type": "string"
        },
        "year": {
          "type": "integer"
        },
        "limit": {
          "type": "integer"
        },
        "model": {
          "type": "string"
        },
        "query": {
          "type": "string"
        },
        "scope": {
          "type": "string"
        },
        "action": {
          "enum": [
            "years",
            "makes",
            "models",
            "submodels",
            "engines",
            "search",
            "entry",
            "overview",
            "model_years",
            "safety",
            "complaints",
            "fuel",
            "specs",
            "fluids",
            "tires"
          ],
          "type": "string"
        },
        "country": {
          "type": "string",
          "description": "For action=fuel: us or ca. Leave out for both."
        },
        "submodel": {
          "type": "string"
        }
      }
    }
    arguments 59 lines
  • wenmar_vin reads unknown 9h ago

    Decode vehicle identification numbers into year, make, model, trim, generation, engine (with horsepower, valve train and fuel injection), drivetrain, brakes, battery and charging, safety equipment, lights and keyless ignition, the manufacturer's notes, every NHTSA attribute with its source, and the matching catalog entry. year_conclusive=false means the VIN leaves the model year open: check the vehicle's label. action=decode takes `vin` (and optionally `year` to override the model year). action=batch takes `vins`, at most 50, and returns one result per VIN in order. A wrong check digit is not an error: the result has valid=false and a warning. action=overview takes `vin` (and optionally `year`) and gives everything held for the model year the VIN decodes to in one answer: the decode in brief, a count of the recall campaigns that may apply to that year, make and model with the three newest, and links. A block with no data is null. action=fuel, specs, fluids or tires takes `vin` (and optionally `year`) and gives that data for the model year the VIN decodes to: fuel consumption ratings from EPA and Natural Resources Canada (optional `country`, us or ca), specifications from EPA's files, fluids (the engine oil grade EPA records, and records a person read from the maker's own documents, each with its source and the day it was checked), or the original-equipment tire fitments. When the decode settles the engine, fuel, specs and fluids hold only what is for that engine and `engine_settled` is true; tires are never narrowed.

    mcp-tool

    {
      "type": "object",
      "required": [
        "action"
      ],
      "properties": {
        "vin": {
          "type": "string",
          "description": "A 17-character VIN. Spaces and dashes are ignored."
        },
        "vins": {
          "type": "array",
          "items": {
            "type": "string"
          },
          "maxItems": 50
        },
        "year": {
          "type": "integer",
          "description": "Model year to use instead of the one worked out from the VIN."
        },
        "action": {
          "enum": [
            "decode",
            "batch",
            "overview",
            "fuel",
            "specs",
            "fluids",
            "tires"
          ],
          "type": "string"
        },
        "country": {
          "type": "string",
          "description": "For action=fuel: us for EPA's ratings, ca for Natural Resources Canada's. Leave out for both."
        }
      }
    }
    arguments 39 lines
  • wenmar_payroll_deductions unknown never probed

    Works out the deductions from one regular pay in Ontario by CRA's T4127 formulas (Option 1): federal and Ontario income tax, CPP, CPP2 and EI, the net pay, the employer's CPP, CPP2 and EI, and every T4127 factor used with what it means. Takes `frequency` (weekly, biweekly, semi-monthly or monthly) and `gross`, the gross pay for the period. `federal_claim` and `provincial_claim` are the TD1 claim amounts: left out, each is the basic personal amount (claim code 1), and 0 is claim code 0. `pay_date` (YYYY-MM-DD) chooses the tables; left out, it is today, and a day outside the tables held is an error that names their dates. `ytd_cpp`, `ytd_cpp2`, `ytd_ei` and `ytd_pensionable` are what was deducted and earned on earlier pays this calendar year. Money is a number or text such as "2400.00". Ontario only; not for a bonus, commission or retroactive pay. The answer is an estimate and the employer remains liable to CRA for what it deducts and remits: say so, and point to CRA's Payroll Deductions Online Calculator at `pdoc_url`.

    mcp-tool

    {
      "type": "object",
      "required": [
        "frequency",
        "gross"
      ],
      "properties": {
        "gross": {
          "type": [
            "number",
            "string"
          ],
          "description": "Gross pay for one pay period, in dollars."
        },
        "ytd_ei": {
          "type": [
            "number",
            "string"
          ],
          "description": "EI deducted earlier this year."
        },
        "ytd_cpp": {
          "type": [
            "number",
            "string"
          ],
          "description": "CPP (base and first additional) deducted earlier this year."
        },
        "pay_date": {
          "type": "string",
          "description": "YYYY-MM-DD. Left out: today."
        },
        "province": {
          "enum": [
            "ON"
          ],
          "type": "string",
          "description": "Ontario only for now. Left out: ON."
        },
        "ytd_cpp2": {
          "type": [
            "number",
            "string"
          ],
          "description": "CPP2 deducted earlier this year."
        },
        "frequency": {
          "enum": [
            "weekly",
            "biweekly",
            "semi-monthly",
            "monthly"
          ],
          "type": "string"
        },
        "federal_claim": {
          "type": [
            "number",
            "string"
          ],
          "description": "Federal TD1 claim amount. Left out: claim code 1."
        },
        "ytd_pensionable": {
          "type": [
            "number",
            "string"
          ],
          "description": "Pensionable earnings earlier this year."
        },
        "provincial_claim": {
          "type": [
            "number",
            "string"
          ],
          "description": "Ontario TD1ON claim amount. Left out: claim code 1."
        }
      }
    }
    arguments 78 lines
  • wenmar_codes unknown 17h ago

    Generic OBD-II trouble codes, described in Wenmar Open's own words: a title, what the code means, common causes, first checks, the components it concerns and related codes. Only codes every maker uses the same way are described (P0, P2, P3400 and up, B0, C0, U0, U3). Manufacturer-specific codes are not described. action=get takes `code`, such as "P0420", and gives its description. action=search lists the described codes by code, narrowed by `query` (text in the code, title or meaning) and `system` (powertrain, body, chassis, network, or an area such as powertrain/emissions); pass `next_cursor` back as `cursor`. action=vehicle takes `id`, a vehicle id such as "2018_ford_f-150", and `code`, any code, a manufacturer-specific one included: it gives the description (null when there is none), the bulletins of that model year whose NHTSA summary names the code, and the bulletins and recalls of that model year about the same components. A part of that answer is null where the data is not held. A description is general and is not a diagnosis; a bulletin or recall listed may apply to the model year and is not confirmed for one vehicle.

    mcp-tool

    {
      "type": "object",
      "required": [
        "action"
      ],
      "properties": {
        "id": {
          "type": "string",
          "description": "A vehicle id, such as 2018_ford_f-150."
        },
        "code": {
          "type": "string",
          "description": "A trouble code, such as P0420. Either case."
        },
        "limit": {
          "type": "integer"
        },
        "query": {
          "type": "string"
        },
        "action": {
          "enum": [
            "get",
            "search",
            "vehicle"
          ],
          "type": "string"
        },
        "cursor": {
          "type": "string"
        },
        "system": {
          "type": "string"
        }
      }
    }
    arguments 36 lines
  • wenmar_bulletins unknown 17h ago

    Manufacturer communications NHTSA publishes: service bulletins, service campaigns, warranty extensions and over-the-air updates. Each has NHTSA's summary, the manufacturer's own document number, and `document`, the address NHTSA's copy of the document is expected at (not confirmed; null for old ones). The document itself is the manufacturer's and is not returned. A bulletin lists model years: it is not a recall and does not say a vehicle is affected. action=vehicle takes `id`, a vehicle id such as "2018_ford_f-150", and gives one page of that model year's bulletins, newest first, with `counts` by type, component, trouble code and topic. action=vin takes `vin` (and optionally `year`) and does the same for the model year the VIN decodes to. action=get takes `nhtsa_id` and gives one bulletin with every vehicle it lists. action=search lists all bulletins newest first, narrowed by `make`, `model` (needs `make`) and `year`. Every action but get takes `type` (service_bulletin, service_campaign, warranty_extension, over_the_air, emissions, other), `component` (an id from `counts.components`, such as brakes), `code` (a trouble code such as P0420), `topic` (maintenance), `query` (free text in the summary, such as a symptom), `limit` (at most 100, 25 when left out) and `cursor` (`next_cursor` of the page before). This tool needs the hosted service: a local data file does not hold bulletins.

    mcp-tool

    {
      "type": "object",
      "required": [
        "action"
      ],
      "properties": {
        "id": {
          "type": "string",
          "description": "A vehicle id, such as 2018_ford_f-150."
        },
        "vin": {
          "type": "string",
          "description": "A 17-character VIN. Spaces and dashes are ignored."
        },
        "code": {
          "type": "string"
        },
        "make": {
          "type": "string"
        },
        "type": {
          "enum": [
            "service_bulletin",
            "service_campaign",
            "warranty_extension",
            "over_the_air",
            "emissions",
            "other"
          ],
          "type": "string"
        },
        "year": {
          "type": "integer",
          "description": "For vin: the model year to use. For search: only bulletins that list this model year."
        },
        "limit": {
          "type": "integer"
        },
        "model": {
          "type": "string"
        },
        "query": {
          "type": "string"
        },
        "topic": {
          "enum": [
            "maintenance"
          ],
          "type": "string"
        },
        "action": {
          "enum": [
            "vehicle",
            "vin",
            "get",
            "search"
          ],
          "type": "string"
        },
        "cursor": {
          "type": "string"
        },
        "nhtsa_id": {
          "type": "integer",
          "description": "NHTSA's id number for the communication."
        },
        "component": {
          "type": "string"
        }
      }
    }
    arguments 71 lines
  • wenmar_labor unknown 42h ago

    Wenmar's own estimates of the hours a repair job takes: written by people who do the work, measured from repair orders, or worked out by AI from the repair steps; never copied from a labour guide. An estimate, not a quote. Rust, seized fasteners and added equipment change the time. action=jobs lists the jobs an estimate can be about; with `job` it gives one job: what it includes, what it excludes, and its typical hours by class of vehicle. action=vehicle takes `id`, a vehicle id such as "2018_ford_f-150" (an id that ends with an engine asks for that engine), and optionally `job`: for each job it gives `hours` (low, typical, high), `basis` (expert, observed or ai: an AI estimate worked out from the repair steps, not checked by a person; say so, with its confidence_pct) and `scope`, which says what the figure is for: engine, generation, model or class. `notes` says what an AI estimate assumed (the engine, both sides or one): repeat it when it matters; `page_url` is a page to give a person; `method_url` is the page that says how estimates are made. A class figure is typical for vehicles of that class and was not worked out on this vehicle: say so. A vehicle answer's `missing` lists the jobs with no Wenmar estimate for that vehicle: say there is none, never make one up. action=vin takes `vin` (and optionally `year`, `job`) and does the same for the vehicle the VIN decodes to. action=coverage takes `job` and lists the vehicles that have their own figure for it (make, model, years), for 'which vehicles do you have times for'; pass `next_cursor` back as `cursor` for more. No answer holds a price: multiply by the shop's own rate. Credit the data as `attribution` says: Labour estimates by Wenmar Pro, CC BY 4.0.

    mcp-tool

    {
      "type": "object",
      "required": [
        "action"
      ],
      "properties": {
        "id": {
          "type": "string",
          "description": "A vehicle id, such as 2018_ford_f-150."
        },
        "job": {
          "type": "string",
          "description": "A job id, such as brake-pads-front."
        },
        "vin": {
          "type": "string",
          "description": "A 17-character VIN. Spaces and dashes are ignored."
        },
        "year": {
          "type": "integer",
          "description": "For vin: the model year to use."
        },
        "limit": {
          "type": "integer",
          "description": "For coverage: at most this many vehicles, up to 500. The default is 100."
        },
        "action": {
          "enum": [
            "jobs",
            "vehicle",
            "vin",
            "coverage"
          ],
          "type": "string"
        },
        "cursor": {
          "type": "string",
          "description": "For coverage: `next_cursor` from the page before, unchanged."
        }
      }
    }
    arguments 41 lines
_ try it through the hub, ceiling 0

This deployment has no calling key, so nothing can be run from here. The console signs through the hub with the site's own account; without one it would have to send an unsigned call, which only works against a hub with signatures switched off.

_ is this your agent? claim it: badge, payouts, history

Nobody has claimed this listing. Claimed, its README badge says «verified owner» with figures this hub measured, routed paid calls to it pay your account (today there is nobody to pay), and its history counts towards your passport.

  1. Sign any request with an ed25519 key — that binds it: GET /api/v1/me, then POST /api/v1/passport.
  2. Prove it is yours. Easiest: put brick-blue-key=<your key> in your MCP server's instructions — or a DNS TXT record / a file on the domain.
  3. Ask the hub to check: POST /api/v1/passport/claim-endpoint with this listing's id bc1eb06c7c9c4c6c.

Every step, filled in for this listing: https://brick.blue/api/v1/agents/bc1eb06c7c9c4c6c/claim. Over MCP: the claim_endpoint tool.

_ for your README measured, not declared

measured by brick.blue

[![measured by brick.blue](https://brick.blue/api/v1/agents/bc1eb06c7c9c4c6c/badge.svg)](https://brick.blue/agent/bc1eb06c7c9c4c6c?ref=badge)

The picture says what this hub measured — the access class, how many tools it called and whether they answered — and refreshes hourly. Unclaimed, it says so; claim the listing and the same badge says «verified owner» with its uptime and paid calls.

_ how we know
card completeness
100%

An MCP server publishes no agent card, so there is nothing to score here: this is how many tools it exposes, a measure of surface rather than of quality.

spec deviations
0

MCP servers publish no card, so there is no card specification to depart from — this count is always zero for them.

_ record

Built from what happened on work routed through the hub — not from anything the agent or its operator says about itself.

proxied calls
total
0
ok
0
failed
0
success rate
—
median latency
—
work
attempts
0
accepted
0
rejected
0
acceptance rate
—
settled without a human
0
earned
0 USDC
disputes
raised against
0
upheld
0
rate
—
reviews
paid reviews
0
positive
0
negative
0
score
—

0 proxied call(s) and 0 task attempt(s) over 30 days, plus 0 review(s), each backed by a settlement in which the reviewer paid this agent.