---
title: "Year Make Model"
description: "Look up vehicle data by year, make, and model when you do not have a VIN."
canonical_url: "https://docs.carsxe.com/docs/products/year-make-model"
markdown_url: "https://docs.carsxe.com/docs/products/year-make-model.md"
last_updated: "1980-01-01"
x_farming_labs_generated_preamble: true
agent:
  task: "Resolve year/make/model hierarchies and related lookups with CarsXE."
  outcome: "A Year Make Model request returns the documented successful vehicle-data response for the supplied input."
  prerequisites:
    - "A valid CarsXE API key with access to this endpoint."
    - "The vehicle identifier or request inputs required by the Year Make Model example."
  verification:
    - "Run one documented Year Make Model request and confirm the response is successful and contains the fields described on this page."
  failureModes:
    - symptom: "The Year Make Model request is rejected or does not return the expected data."
      resolution: "Check the API key, plan access, supported input format, and the returned status code against the error guide before retrying."
---

# Year Make Model
URL: /docs/products/year-make-model
LLM index: /llms.txt
Description: Look up vehicle data by year, make, and model when you do not have a VIN.
Related: /docs/products, /docs/get-started

<!-- farming-labs:agent-contract:start -->
## Agent Contract

Task: Resolve year/make/model hierarchies and related lookups with CarsXE.
Outcome: A Year Make Model request returns the documented successful vehicle-data response for the supplied input.

### Prerequisites

- A valid CarsXE API key with access to this endpoint.
- The vehicle identifier or request inputs required by the Year Make Model example.

### Verification

- Run one documented Year Make Model request and confirm the response is successful and contains the fields described on this page.

### Failure Modes

- The Year Make Model request is rejected or does not return the expected data. — Recovery: Check the API key, plan access, supported input format, and the returned status code against the error guide before retrying.
<!-- farming-labs:agent-contract:end -->

Task: Resolve year/make/model hierarchies and related lookups with CarsXE.
Related: /docs/products/year-make-model, /docs/products/ymm-options, /docs/products/specifications, /docs/products/recalls

Look up vehicle data by year, make, and model, with an optional trim hint. This is useful when a VIN is unavailable but you still need structured specs, colors, features, pricing, or trim options.

Building cascading dropdown menus instead? See [YMM Options](/docs/products/ymm-options).

Decoding a diagnostic trouble code instead? See [OBD Codes Decoder](/docs/products/obd-codes-decoder).

Endpoint: `/v1/ymm`

## Who uses this API

Configurators, parts catalogs, and listing platforms call this endpoint when they have year, make, and model (and maybe trim) but no VIN — they still need structured specs, colors, features, or pricing.

## Use cases

### B2B

- **Parts and service — catalog match:** Resolve specs and trim options for a YMM so the correct parts and labor times can be suggested.
- **Listings — VIN-less inventory:** Enrich a listing that was entered as year, make, and model instead of a VIN.
- **Configurators — trim and feature data:** Load colors, features, and pricing after the user picks a YMM.

### B2C

- **Trim pickers:** Let a shopper choose year, make, model, and trim, then show specs without asking for a VIN.
- **Comparison tools:** Compare two YMMs on features and pricing in a consumer research app.

## Parameters

| Parameter | Required | Description |
|---|---|---|
| `year` | Yes | Vehicle model year, numeric, between 1900 and the current model year plus one |
| `make` | Yes | Manufacturer, for example `Toyota`, `Ford`, or `BMW` |
| `model` | Yes | Vehicle model, for example `Camry`, `F-150`, or `X5` |
| `trim` | No | Trim hint, for example `XLE` or `Sport`; fuzzy matched when possible |
| `exact_match` | No | Default `false`. Use `true` or `1` for exact make/model and supplied trim matching; `false` or `0` retains fuzzy selection. Values are case-insensitive. |
| `allTrimOptions` | No | Pass `1` to return all trim options for the year, make, and model |

## Strict matching and substitution detection

Use `exact_match=true` to reject sibling trims and models. Exact matching ignores case and leading, trailing, or repeated whitespace, while preserving punctuation. The trim must equal either the complete short trim (for example, `Light Long Range`) or the complete stored style string, including body and engine details. `Light` does not match `Light Long Range`, and `F-150` does not match `F-150 Lightning`.

Without a trim, including a whitespace-only trim, strict mode requires exact make/model and selects the most popular eligible style, or the first style in stable name/ID order. With `allTrimOptions=1`, strict mode returns only eligible styles. If neither data source contains an eligible match, the API returns the existing HTTP 404 response with `success:false`. Invalid `exact_match` values return HTTP 400; arrays and objects are invalid.

Every successful response includes top-level `match_exact`: `true` when make, model, and the requested trim/style all match, `false` when any differs, or `null` when no trim was requested. `input.exact_match` echoes the effective boolean. This flag is also available with default fuzzy matching, so integrations can detect substitutions without parsing `bestMatch.name`.

```bash
curl -G https://api.carsxe.com/v1/ymm \
  -d key=YOUR_API_KEY -d year=2025 -d make=Toyota -d model=Camry \
  -d trim=LE -d exact_match=true
```

For a complete style string, preserve its punctuation and use URL encoding, for example `--data-urlencode 'trim=XL Regular Cab 6.5 ft. SB (2.7L 6cyl Turbo 10A)'` with the corresponding year, make, and model.

A default fuzzy request for `LT` that returns `LTZ Crew Cab ...` reports `"match_exact": false`. The same request with `exact_match=true` returns HTTP 404 unless an exact `LT` style is available. Fuzzy matching searches substring-filtered style candidates and chooses the closest style string; it does not perform an unrestricted fallback to the most popular trim. Without a trim, the existing most-popular/first-result behavior applies.

## Example

<CodeGroup title="Look up by year, make, and model" tag="GET" label="/v1/ymm">

```bash
curl -G https://api.carsxe.com/v1/ymm \
  -d key=YOUR_API_KEY \
  -d year=2023 \
  -d make=Toyota \
  -d model=Camry \
  -d trim=XLE
```

```js
import { CarsXE } from "carsxe-api";

const carsxe = new CarsXE("YOUR_API_KEY");
const year = "2023";
const make = "Toyota";
const model = "Camry";
const trim = "XLE";

try {
  const ymm = await carsxe.yearMakeModel({ year, make, model, trim });
  console.log(ymm);
} catch (error) {
  console.error(error);
}
```

```python
import asyncio
from carsxe_api import CarsXE

carsxe = CarsXE("YOUR_API_KEY")
year = "2023"
make = "Toyota"
model = "Camry"
trim = "XLE"

try:
    ymm = asyncio.run(carsxe.year_make_model({"year": year, "make": make, "model": model, "trim": trim}))
    print(ymm)
except Exception as e:
    print(f"Error: {e}")
```

```php
<?php
require_once __DIR__ . '/vendor/autoload.php';
use CarsxeDeveloper\Carsxe\Carsxe;

$carsxe = new Carsxe("YOUR_API_KEY");
$year = "2023";
$make = "Toyota";
$model = "Camry";
$trim = "XLE";

try {
    $ymm = $carsxe->yearMakeModel(["year" => $year, "make" => $make, "model" => $model, "trim" => $trim]);
    print_r($ymm);
} catch (Exception $error) {
    echo "Error: " . $error->getMessage();
}
```

```ruby
require "carsxe"

carsxe = Carsxe::CarsXE.new(api_key: "YOUR_API_KEY")
year = "2023"
make = "Toyota"
model = "Camry"
trim = "XLE"

begin
  ymm = carsxe.year_make_model("year" => year, "make" => make, "model" => model, "trim" => trim)
  puts ymm
rescue StandardError => error
  puts "Error: #{error.message}"
end
```

```go
package main

import (
	"fmt"
	"github.com/carsxe/carsxe-go-package"
)

func main() {
	client := carsxe.New("YOUR_API_KEY")
	year := "2023"
	make := "Toyota"
	model := "Camry"
	trim := "XLE"
	ymm := client.YearMakeModel(map[string]string{"year": year, "make": make, "model": model, "trim": trim})
	fmt.Println(ymm)
}
```

```java
import io.github.carsxe.CarsXE;
import java.util.Map;
import java.util.HashMap;

public class Main {
    public static void main(String[] args) {
        CarsXE carsxe = new CarsXE("YOUR_API_KEY");
        Map<String, String> params = new HashMap<>();
        params.put("year", "2023");
        params.put("make", "Toyota");
        params.put("model", "Camry");
        params.put("trim", "XLE");

        try {
            Map<String, Object> ymm = carsxe.yearMakeModel(params);
            System.out.println(ymm);
        } catch (Exception e) {
            System.err.println("Error: " + e.getMessage());
        }
    }
}
```

```swift
import carsxe

let carsxe = CarsXE(apiKey: "YOUR_API_KEY")
let year = "2023"
let make = "Toyota"
let model = "Camry"
let trim = "XLE"

do {
    let ymm = try carsxe.yearMakeModel(["year": year, "make": make, "model": model, "trim": trim])
    print(ymm)
} catch {
    print("Error: \(error)")
}
```

```csharp
using carsxe;
using System;
using System.Collections.Generic;
using System.Threading.Tasks;

class Program
{
    static async Task Main(string[] args)
    {
        CarsXE carsxe = new CarsXE("YOUR_API_KEY");
        string year = "2023";
        string make = "Toyota";
        string model = "Camry";
        string trim = "XLE";

        try
        {
            var ymm = await carsxe.YearMakeModel(new Dictionary<string, string> { { "year", year }, { "make", make }, { "model", model }, { "trim", trim } });
            Console.WriteLine(ymm);
        }
        catch (Exception ex)
        {
            Console.WriteLine($"Error: {ex.Message}");
        }
    }
}
```

```bash {{ title: "Response" }}
{
  "bestMatch": {
    "make": "Toyota",
    "model": "Camry",
    "year": "2023",
    "trim_id": "ymm_style_v1_31ec8f9ad439d778b2dcb4dc8c0cfdafdf4ddf869d03d377de63684a02ab2eab",
    "name": "XLE 4dr Sedan (3.5L 6cyl 8A)",
    "base_msrp": 36195,
    "base_invoice": 32938,
    "total_seating": 5,
    "color": {
      "exterior": [
        { "name": "Supersonic Red", "rgb": "226,5,0" }
      ],
      "interior": [
        { "name": "Black, leather", "rgb": "0,0,0" }
      ]
    },
    "features": {
      "standard": [
        {
          "category": "Power Feature",
          "features": [
            { "name": "hands-free entry", "value": null }
          ]
        }
      ]
    }
  },
  "trimOptions": [],
  "success": true,
  "match_exact": true,
  "input": {
    "year": "2023",
    "make": "Toyota",
    "model": "Camry",
    "trim": "XLE",
    "exact_match": false
  },
  "timestamp": "2024-03-19T12:00:00.000Z"
}
```

</CodeGroup>

## Response

### Top-level shape

<LookupTopLevelShape />

Click any object or array to expand it and see sample data. For the full interactive reference, try it live in the [API Reference](/api-reference/year-make-model/year-make-model).

Every successful response includes `success` and `match_exact`. Other fields depend on the response. Availability varies by vehicle, trim, and source coverage.

### bestMatch

The `bestMatch` object contains the matched vehicle and trim data.

<Properties>
  <Property name="make" type="string">
    Vehicle manufacturer. Example: `"Toyota"`.
  </Property>
  <Property name="model" type="string">
    Vehicle model. Example: `"Camry"`.
  </Property>
  <Property name="year" type="string">
    Vehicle model year. Example: `"2023"`.
  </Property>
  <Property name="trim_id" type="string">
    Opaque, stable identifier for the complete vehicle style.
  </Property>
  <Property name="name" type="string">
    Full trim and body description for the matched vehicle. Example: `"XLE 4dr Sedan (3.5L 6cyl 8A)"`.
  </Property>
  <Property name="base_msrp" type="number">
    Original base manufacturer's suggested retail price when available.
  </Property>
  <Property name="base_invoice" type="number">
    Original base dealer invoice price when available.
  </Property>
  <Property name="total_seating" type="number">
    Factory seating capacity for the matched trim.
  </Property>
  <Property name="color" type="object">
    Available exterior and interior color options.
  </Property>
  <Property name="features" type="object">
    Grouped feature and specification data, usually under `standard`.
  </Property>
</Properties>

### trimOptions

When `allTrimOptions=1` is passed, `trimOptions` returns available trims for the requested year, make, and model. Use this when users need to choose a trim before requesting the best match. Each option includes the same `trim_id` field as `bestMatch`.

`trim_id` is an opaque identifier for the complete year/make/model/style combination, returned on `bestMatch` and every `trimOptions` entry. Store and compare it without parsing it. The same normalized values produce the same ID across requests and data sources; changes to pricing or features do not change it. Material changes to year, make, model, or the full style description produce a different ID. Identity guarantees apply to records with all four values present. Styles sharing a short trim name can have different IDs.

`name` remains the full style description. `trim_id` is response-only and is not accepted as a request parameter; existing trim matching behavior is unchanged.

Example option list when `allTrimOptions=1`:

```json
{
  "trimOptions": [
    {
      "trim_id": "ymm_style_v1_31ec8f9ad439d778b2dcb4dc8c0cfdafdf4ddf869d03d377de63684a02ab2eab",
      "make": "Toyota",
      "model": "Camry",
      "year": "2023",
      "name": "XLE 4dr Sedan (3.5L 6cyl 8A)"
    }
  ]
}
```

### color

Color data is grouped by `exterior` and `interior`. Each item uses the same shape:

<Properties>
  <Property name="name" type="string">
    Manufacturer color or upholstery name. Example: `"Supersonic Red"` or `"Black, leather"`.
  </Property>
  <Property name="rgb" type="string">
    Comma-separated RGB value. Example: `"226,5,0"`.
  </Property>
</Properties>

### features

Features are grouped into categories under `features.standard`.

<Properties>
  <Property name="category" type="string">
    Feature category name. Example: `"Power Feature"`, `"Warranty"`, or `"Measurements"`.
  </Property>
  <Property name="features" type="array">
    List of feature items in this category.
  </Property>
</Properties>

Each feature item has:

<Properties>
  <Property name="name" type="string">
    Feature or measurement name. Example: `"hands-free entry"` or `"Rear leg room"`.
  </Property>
  <Property name="value" type="string | null">
    Value for the feature when the source provides one. Feature flags often return `null`; measurements usually return a string such as `"38.0 in."`.
  </Property>
</Properties>

### input

The `input` object echoes the request values used for the lookup. It can include `year`, `make`, `model`, `trim`, `allTrimOptions`, and the effective boolean `exact_match`.

<Note>
  If `trim` is omitted, the API returns the best/default trim match for the year, make, and model. With default fuzzy matching, a non-exact trim attempts a close match within substring-filtered candidates. With `exact_match=true`, an unavailable exact trim returns HTTP 404. Pass `allTrimOptions=1` when you need the available trims instead of a single best match. Response fields vary by vehicle and source availability.
</Note>

## Errors

See the [Errors guide](/docs/guides/errors) for the full list.

- **400** - Missing or invalid `year`, `make`, `model`, or `exact_match`.
- **401** - API key is missing, invalid, disabled, or unauthorized.
- **404** - No vehicle matched the year, make, and model, or the exact trim/style in strict mode.
- **429** - Usage limit exceeded.
- **500** - Could not fetch data.

## Sitemap

See the full [sitemap](/sitemap.md) for all pages.
Docs-scoped sitemap: [/docs/sitemap.md](/docs/sitemap.md).
Well-known sitemap: [/.well-known/sitemap.md](/.well-known/sitemap.md).
