Where can I find a specific car for sale by VIN?

Search Listings by VIN — or by year, make, model, and trim — to find a specific car for sale across dealers, auctions, and private sellers in one place. Each result shows the price, the venue it's listed in, the source that reported it, and the timestamp of the pull, so you're reading the car and not an ad. When you've found it, the deal leaves on rails: buy.vin for a consumer close, ADF export for a dealer, and API or MCP for an agent. Listings finds the car; it doesn't try to close it for you.

The problem it solves is fragmentation. The same car is listed in many places at once — a dealer's site, a syndication feed, an auction lot, a private classified — and each place shows you its own ad unit rather than the car itself. You end up comparing photos and phrasings across a dozen tabs, never certain whether two listings are the same vehicle or two different cars of the same configuration. A VIN ends that. The seventeen-character number names exactly one car, so every venue that has listed that car resolves to a single page, and you see the whole picture of where it's for sale at once.

Two ways in: the VIN and the facets

If you already have the VIN — from a window, a title, a text from a seller, a listing you half-trust — paste it. listings.vin/{VIN} resolves straight to that one car's page: every venue it appears in, each line carrying its own price, source, and timestamp, plus the verification state of each fact. That page is the destination, not a search result.

If you don't have a VIN yet, the facets are the way in. Filter by year, make, model, and trim — and further by the attributes that matter to you — to narrow the corpus down. But the search is not the destination: every result row is a VIN, and opening a row opens that car's page, not another ad. The field takes the same grammar the address bar does; a year make model query narrows to the set, and a single VIN opens the one. You always end at a car, addressed by its number.

What every result carries

The discipline is that every fact on a listing is labeled with where it came from and when. Each row states four things plainly:

• price — the number the venue is asking, as reported
• venue — dealer, auction, or private seller; an auction lot is treated as a listing in an auction venue, one grammar across all three
• source — the feed or site the listing was drawn from
• timestamp — when that fact was last pulled, so a stale price reads as stale

Where a fact hasn't been confirmed against the record, it's labeled — "Reported, not yet verified" — rather than blended silently into the verified facts. A price the record hasn't confirmed looks different from one it has. That labeling is the point: you're never left guessing which numbers you can lean on.

The car, read against its own record

Finding the car is the first move; reading it is the next. Because the listing is keyed to a VIN, the same address opens the rest of that car's record. The listing page carries a delta against the car's market value — a signed number, not an adjective like "great deal" — with the basis stated so you can check it. That basis is values.vin, which posts five value bands (retail, private-party, trade-in, wholesale, and auction) for the exact VIN, each with its source and comps. Set the asking price beside those bands and the listing tells you where it sits in the market instead of asserting it's a bargain.

The configuration is worth confirming too, because ads inflate trims. The decode resolves the VIN to the trim the car actually is — the real build rather than the trim the ad claims. When a listing says "Limited" but the VIN decodes to a lower trim, the record catches it before you drive out to see it.

Then the deal leaves on rails

Listings is a directory, not a closing desk — and it's explicit about where the deal goes next, because each exit is a different door for a different party:

• A consumer hands the listing to buy.vin. The listing identifier rides along, so the close starts from the record you were already reading — the same facts, now carried into a checklist that tracks distance-to-done at each step.
• A dealer takes the lead as an ADF export — Auto-lead Data Format, the file a dealer CRM ingests — straight into their own system. No portal sits between the store and the buyer; the buyer who found the car found that store's car, not a portal's ad unit, and the per-lead fee is shown on the export sheet before anything is sent.
• An agent reads the identical page as typed JSON at the same address and can route the deal on your behalf, appearing to you only where it's load-bearing — choosing the car and authorizing the close. Programmatic access to the corpus runs by API and MCP through apis.vin, metered per call with the rate card published there.

The through-line across all three: the listing a buyer reads is the listing the dealer posted. Same page, both sides of the desk — no laundered lead, no ad that dissolves into "just sold" when you arrive.

What it costs to look

Searching Listings is free, with no account, on every VIN and every visit. That's the base of the ladder: the anonymous search and the resolved car page cost nothing because the corpus is VIN's own to serve. The cost-bearing steps come only when you deepen into licensed data downstream — a full history report, licensed book-value overlays — or when you consume the corpus programmatically. Finding the car is free; the metering starts at the machine boundary and at the licensed faces, never at the front door.

---

Find the car by its number, read it against its value, then start the deal from the record.

• Value: values.vin — five bands for the exact VIN, each with source and comps
• This door: listings.vin — every car for sale, addressable by VIN