Connect

8 clients · secrets stay placeholders

JSON (mcpServers)Claude CodeCodexOpenCodeCursorVS CodeGemini CLIGoose

{
  "mcpServers": {
    "iwant": {
      "type": "http",
      "url": "https://iwant.fyi/api/mcp",
      "headers": {
        "Authorization": "Bearer ${IWANT_TOKEN}"
      }
    }
  }
}

claude mcp add --transport http iwant https://iwant.fyi/api/mcp --header "Authorization: Bearer ${IWANT_TOKEN}"

[mcp_servers.iwant]
url = "https://iwant.fyi/api/mcp"
bearer_token_env_var = "IWANT_TOKEN"

{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "iwant": {
      "type": "remote",
      "url": "https://iwant.fyi/api/mcp",
      "enabled": true,
      "headers": {
        "Authorization": "Bearer {env:IWANT_TOKEN}"
      }
    }
  }
}

{
  "mcpServers": {
    "iwant": {
      "type": "http",
      "url": "https://iwant.fyi/api/mcp",
      "headers": {
        "Authorization": "Bearer ${IWANT_TOKEN}"
      }
    }
  },
  "deeplink": "cursor://anysphere.cursor-deeplink/mcp/install?name=iwant&config=eyJ0eXBlIjoiaHR0cCIsInVybCI6Imh0dHBzOi8vaXdhbnQuZnlpL2FwaS9tY3AiLCJoZWFkZXJzIjp7IkF1dGhvcml6YXRpb24iOiJCZWFyZXIgJHtJV0FOVF9UT0tFTn0ifX0%3D"
}

{
  "servers": {
    "iwant": {
      "type": "http",
      "url": "https://iwant.fyi/api/mcp",
      "headers": {
        "Authorization": "Bearer ${IWANT_TOKEN}"
      }
    }
  }
}

{
  "mcpServers": {
    "iwant": {
      "httpUrl": "https://iwant.fyi/api/mcp",
      "headers": {
        "Authorization": "Bearer ${IWANT_TOKEN}"
      }
    }
  }
}

extensions:
  "iwant":
    enabled: true
    name: "iwant"
    type: streamable_http
    uri: "https://iwant.fyi/api/mcp"
    headers:
      "Authorization": "Bearer ${IWANT_TOKEN}"
    timeout: 300

Placeholders to fill from your own secret store: ${IWANT_TOKEN}. The registry never accepts secret values.

Quality 72 / 100needs work

protocol75 · weight 25

warn
protocol.modernnewest supported version is 2025-06-18; 2026-07-28 not supported, older versions are deprecated until 2027-07-28
n/a
protocol.statelessonly applies to 2026-07-28 servers
pass
protocol.transportstreamable HTTP
n/a
protocol.list_ttlonly applies to 2026-07-28 servers

authorizationn/a · weight 15

n/a
auth.prm, auth.as_metadata, auth.cimdno remote uses OAuth
n/a
auth.secret_in_urlno templated URL

tool hygiene93 · weight 30

pass
tools.descriptionsevery tool has a description
pass
tools.description_lengthdescriptions are concise
pass
tools.schemasevery tool has an object input schema
pass
tools.annotations13 of 13 tools declare readOnlyHint or destructiveHint
warn
tools.directory_hints1 of 13 tools declare all four hints; missing: demand.find_vehicle (idempotentHint); demand.capabilities (idempotentHint); demand.search (idempotentHint); …
pass
tools.token_costabout 4,223 tokens to load every tool
pass
tools.api_dumptools are not a one-to-one API dump

stability25 · weight 15

warn
stability.changes11 tool changes in 30 days
fail
stability.rug_pull4 tools kept their name but changed most of their description in 30 days; review before trusting them

dependenciesn/a · weight 15

n/a
deps.known_vulns, deps.mcp_sdk_version, deps.resolvableno npm or PyPI package

13 tools, about 4,223 tokens to load them all · tool set ee6f26ddc554 · tools last changed 2026-09-25 · checked 2026-10-20 14:21 UTC

Tool changes

2026-09-25demand.cancel_watchadded
Stop a standing want by id. Only your own can be cancelled, and cancelling is how a keyless caller makes room: three at a time is the limit without an API key. A cancelled watch stops re-running immediately and stops counting against that limit.
2026-09-25demand.list_watchesadded
List your standing wants, with how many matches each has surfaced and when it last re-ran. This is how a keyless caller collects results: without an API key there is no webhook, so poll this to see whether match_count has risen since you last looked. Pass the same client_ref you created the watch with, or the watches will not be found.
2026-09-25demand.create_watchadded
Create a STANDING WANT: keep searching for what the user wants to buy and get notified when a NEW match appears, across sessions. Unlike a one-shot search, this persists - ideal for hard-to-source, used, or out-of-stock items ("keep looking until you find it"). Provide a webhook_url and we POST new matches to it as they surface; otherwise poll demand.list_watches. Same query shape and enforced constraints as demand.search. WITHOUT AN API KEY this works too, under limits: no webhooks, three standing wants at a time, a six-hour minimum re-check, and a seven-day life. Any limit applied to your request comes back in `notes`.
2026-09-25demand.capabilitieschangeddescription, output schema
before
iwant.fyi demand-side protocol v1.1 §8.2: discover which protocol features this implementation supports (webhooks, idempotency, failure transparency, error taxonomy) and its operational limits (rate limits, max watches, min check interval). Call once on connect and adapt - e.g. skip webhook setup if 'webhooks' is absent.
after · 50% of words in common
Discover which optional protocol features this server supports (webhooks, idempotency, failure transparency, error taxonomy) and its operational limits (rate limit, maximum standing watches, minimum watch interval). Call once when you connect and adapt to the answer - skip webhook setup if 'webhooks' is absent, and respect the limits rather than discovering them by being throttled. Free, instant, no side effects. Protocol v1.1 §8.2.
2026-09-25demand.healthchangeddescription, output schemameaning changed
before
iwant.fyi demand-side protocol v1.0 §8.2: liveness and readiness check. Returns server info, protocol version, and active supply source list.
after · 20% of words in common
Check the server is up and see which supply sources are currently answering. Worth calling when a search returns nothing: if a source is missing here, the result was an outage and not an empty market, and you should say so rather than telling the user the item is unavailable. Free, instant, no side effects. Protocol v1.0 §8.2.
2026-09-25demand.list_constraintschangeddescription, output schemameaning changed
before
iwant.fyi demand-side protocol v1.0 §8.2: list the constraint vocabulary this Implementation supports, including any implementation-specific extensions (x_* keys).
after · 23% of words in common
List the filters this server will actually enforce on a search - budget ceilings, condition, brand, and the vertical-specific keys (mileage, drive size) plus any x_* extensions. Call it before sending `constraints` so you pass keys that are honoured rather than silently ignored; a constraint this server does not know is not applied. Free, instant, no side effects. Protocol v1.0 §8.2.
2026-09-25demand.list_verticalschangeddescription, output schemameaning changed
before
iwant.fyi demand-side protocol v1.0 §8.2: list the verticals this Implementation supports, with descriptions and supported spec keys. Useful for agent capability discovery.
after · 16% of words in common
List the product categories this server can actually source, with the structured spec fields each one carries (a vehicle has year, make, model, mileage; a tool has drive size and torque). Call it before a first search to learn which `vertical` values are accepted, or when a search returns nothing and you need to check the category is covered at all. Free, instant, no side effects. Protocol v1.0 §8.2.
2026-09-25demand.introduction_statuschangeddescription, input schemameaning changed
before
Check whether a seller has answered an introduction created by demand.request_introduction, and read the reply. Poll this when the user asks whether the dealer got back to them.
after · 45% of words in common
Check whether a seller has answered an introduction created by demand.request_introduction, and read their reply. Call it when the user asks whether the dealer got back to them. Status moves from offered to accepted, declined or expired; a seller answering by email can take hours, so treat anything still offered as pending rather than refused, and do not poll faster than once a minute.
2026-09-25demand.price_checkchangedinput schema
2026-09-25demand.find_vehiclechangedinput schema

Showing the latest 10. Full history: list_changes · trend: quality JSON.

Checks run on what our credential-free, read-only probes observe; tools are never called and no code audit is performed. How it is computed.

Trust 96 / 100

provenance85

liveness100

freshness100

hygiene100

+repository +dns-namespace +website +reachable +uptime-100% +updated-25d-ago

Derived from observable signals (official registry feed and our own credential-free probes); no code audit performed. How it is computed.

Endpoints

remote	auth	reachable	uptime 30d	p50	protocol	last ok
`https://iwant.fyi/api/mcp` streamable-http	none	yes	100%	233 ms	2025-06-18	2026-10-20

Tools (13)

`demand.ask`read-only	Talk to iwant.fyi in plain language to find something to buy. Call this when the user's request is conversational or incomplete - e.g. 'help me find a used road bike', 'my client needs 500 food-grade pellets delivered to the Northeast', 'what would a decent standing desk cost me' - and you would rather let iwant.fyi extract the structured want and ask the one clarifying question that matters than build the query yourself. Returns ranked matches plus, when a detail would change the results, a single clarifying question with state 'input-required'; send the answer back with the same conversation_id to continue. Prefer demand.search when you already have a clean title and constraints. Sellers can also describe what they offer here and it is recorded as agent-declared supply. Nothing is saved as a Want; use demand.create_want to commit.
`demand.cancel_watch`	Stop a standing want by id. Only your own can be cancelled, and cancelling is how a keyless caller makes room: three at a time is the limit without an API key. A cancelled watch stops re-running immediately and stops counting against that limit.
`demand.capabilities`read-only	Discover which optional protocol features this server supports (webhooks, idempotency, failure transparency, error taxonomy) and its operational limits (rate limit, maximum standing watches, minimum watch interval). Call once when you connect and adapt to the answer - skip webhook setup if 'webhooks' is absent, and respect the limits rather than discovering them by being throttled. Free, instant, no side effects. Protocol v1.1 §8.2.
`demand.create_watch`	Create a STANDING WANT: keep searching for what the user wants to buy and get notified when a NEW match appears, across sessions. Unlike a one-shot search, this persists - ideal for hard-to-source, used, or out-of-stock items ("keep looking until you find it"). Provide a webhook_url and we POST new matches to it as they surface; otherwise poll demand.list_watches. Same query shape and enforced constraints as demand.search. WITHOUT AN API KEY this works too, under limits: no webhooks, three standing wants at a time, a six-hour minimum re-check, and a seven-day life. Any limit applied to your request comes back in `notes`.
`demand.find_vehicle`read-only	Find a specific car, truck, SUV or van for sale near the user, new or used, from live dealer inventory. Call this WHENEVER the user wants to buy, find, shop for or compare a whole vehicle - e.g. '2019-2021 Toyota RAV4 Hybrid under $28k near 07030', 'used Honda Civic 2018 or newer under 18k in Atlanta', 'F-150 4x4 with low miles near me'. Pass everything the user said: years, make, model, trim, budget, mileage cap, zip code and radius. Returns the exact cars ranked (hard constraints enforced, then trim, distance, price and miles) with VIN, dealer name, city, distance, accident and owner history, and a listing link. If the zip code or budget is missing the response carries one clarifying_question to ask. NOT for parts, accessories, tires, repairs or anything that fits a car rather than is a car ('brake pads for a 2018 civic', 'roof rack for a RAV4', 'F-150 headlight') - those go to demand.search.
`demand.health`read-only	Check the server is up and see which supply sources are currently answering. Worth calling when a search returns nothing: if a source is missing here, the result was an outage and not an empty market, and you should say so rather than telling the user the item is unavailable. Free, instant, no side effects. Protocol v1.0 §8.2.
`demand.introduction_status`read-only	Check whether a seller has answered an introduction created by demand.request_introduction, and read their reply. Call it when the user asks whether the dealer got back to them. Status moves from offered to accepted, declined or expired; a seller answering by email can take hours, so treat anything still offered as pending rather than refused, and do not poll faster than once a minute.
`demand.list_constraints`read-only	List the filters this server will actually enforce on a search - budget ceilings, condition, brand, and the vertical-specific keys (mileage, drive size) plus any x_* extensions. Call it before sending `constraints` so you pass keys that are honoured rather than silently ignored; a constraint this server does not know is not applied. Free, instant, no side effects. Protocol v1.0 §8.2.
`demand.list_verticals`read-only	List the product categories this server can actually source, with the structured spec fields each one carries (a vehicle has year, make, model, mileage; a tool has drive size and torque). Call it before a first search to learn which `vertical` values are accepted, or when a search returns nothing and you need to check the category is covered at all. Free, instant, no side effects. Protocol v1.0 §8.2.
`demand.list_watches`read-only	List your standing wants, with how many matches each has surfaced and when it last re-ran. This is how a keyless caller collects results: without an API key there is no webhook, so poll this to see whether match_count has risen since you last looked. Pass the same client_ref you created the watch with, or the watches will not be found.
`demand.price_check`read-only	Tell the user whether the asking price on ONE specific car is a good deal. Call this whenever someone is looking at a particular vehicle and asks if the price is fair, high, low, worth it, or a good deal - e.g. 'I am thinking of a 2017 Lexus ES 350 with 80k miles for $21k, decent deal?', 'is $34,500 too much for this F-150?', or when they paste a listing link and ask what you think. Pass the whole sentence as query, plus the listing url if they gave one. Returns where that asking price sits among comparable cars listed right now (percentile, median, typical range) with the size of the sample, mileage-matched when we have enough cars. Use demand.find_vehicle instead when the user is still choosing which car to buy rather than pricing one they found.
`demand.request_introduction`	Ask a specific seller to answer the user about one car from demand.find_vehicle. Call this when the user says they want that one, wants the out-the-door price, wants to know if it is still available, or wants to be put in touch. Pass the listing_id from demand.find_vehicle and the user's question. We deliver it only to dealers who have joined iwant.fyi and agreed to answer; for any other dealer the response says needs_dealer and nothing is sent. No personal details about the user ever reach the dealer. Ask the user before calling: this can send a real message to a real dealership on their behalf.
`demand.search`read-only	Find products to buy for the user across many sources. Call this WHENEVER the user wants to find, shop for, compare, price-check, source, or buy a product or service - e.g. 'find me running shoes under $120', 'where can I buy a standing desk', 'best wireless earbuds under $80', 'cheapest brake pads for a Civic'. Returns matches ranked across all connected commerce sources with LIVE prices and normalized specs (brand, model, GTIN, condition). Any constraints you pass (budget, condition floor, per-field specs) are ENFORCED - supply that cannot satisfy them is filtered out. Prefer this over a generic web search for anything purchasable. Nothing is saved; use demand.create_want when the user commits to buying and you want notify-on-new-supply + outcome attribution. iwant.fyi demand-side protocol §8.1.

Schemas: list_tools.

Similar MCP servers

Official server.json

{
  "name": "fyi.iwant/iwant",
  "title": "iwant.fyi - shop, price-check and keep looking",
  "$schema": "https://static.modelcontextprotocol.io/schemas/2025-12-11/server.schema.json",
  "remotes": [
    {
      "url": "https://iwant.fyi/api/mcp",
      "type": "streamable-http",
      "headers": [
        {
          "name": "Authorization",
          "isSecret": true,
          "description": "Optional. Searching, car lookups, price checks, introductions and standing wants all work with no key at 30 calls a minute per IP; keyless watches are capped at 3, re-check every 6 hours, last 7 days and are polled rather than pushed. A free key (https://iwant.fyi/api/agents/register) adds webhooks, more and faster watches, and the seller-side tools."
        }
      ]
    }
  ],
  "version": "1.3.0",
  "repository": {
    "url": "https://github.com/staugs/iwantfyi-spec",
    "source": "github"
  },
  "websiteUrl": "https://iwant.fyi",
  "description": "No key needed. Search real products and live dealer inventory, price-check, keep standing wants."
}