---
title: "Year Make Model"
description: "Look up vehicle data by year, make, and model, with optional OBD-II code decoding."
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"
---

# Year Make Model
URL: /docs/products/year-make-model
LLM index: /llms.txt
Description: Look up vehicle data by year, make, and model, with optional OBD-II code decoding.

Year Make Model includes two lightweight APIs for cases where you do not have a VIN. Use Year Make Model to find the best matching vehicle and trim from basic vehicle identity. Use the OBD-II code decoder to map diagnostic trouble codes to readable diagnosis text.

## Year Make Model

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.

Endpoint: `/v1/ymm`

### 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 |
| `allTrimOptions` | No | Pass `1` to return all trim options for the year, make, and model |

### 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",
    "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,
  "input": {
    "year": "2023",
    "make": "Toyota",
    "model": "Camry",
    "trim": "XLE"
  },
  "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).

All response fields are optional except `success`. 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="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.

#### 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`, and `allTrimOptions`.

<Note>
  If `trim` is omitted, the API returns the best/default trim match for the year, make, and model. If `trim` is provided but not exact, the API attempts a close match. Pass `allTrimOptions=1` when you need the available trims instead of a single best match. Response fields vary by vehicle and source availability.
</Note>

## OBD-II Code Decoder

Decode an OBD-II diagnostic trouble code into a readable diagnosis.

Endpoint: `/obdcodesdecoder`

### Parameters

| Parameter | Required | Description |
|---|---|---|
| `code` | Yes | OBD-II diagnostic trouble code, for example `P0115` |
| `key` | Yes | Your CarsXE API key |
| `format` | No | `json` by default, or `xml` if supported by your endpoint configuration |

### Example

<CodeGroup title="Decode an OBD-II code" tag="GET" label="/obdcodesdecoder">

```bash
curl -G https://api.carsxe.com/obdcodesdecoder \
  -d key=YOUR_API_KEY \
  -d code=P0115
```

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

const carsxe = new CarsXE("YOUR_API_KEY");
const code = "P0115";

try {
  const obd = await carsxe.obdcodesdecoder({ code });
  console.log(obd);
} catch (error) {
  console.error(error);
}
```

```python
import asyncio
from carsxe_api import CarsXE

carsxe = CarsXE("YOUR_API_KEY")
code = "P0115"

try:
    obd = asyncio.run(carsxe.obd_codes_decoder({"code": code}))
    print(obd)
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");
$code = "P0115";

try {
    $obd = $carsxe->obdCodesDecoder(["code" => $code]);
    print_r($obd);
} catch (Exception $error) {
    echo "Error: " . $error->getMessage();
}
```

```ruby
require "carsxe"

carsxe = Carsxe::CarsXE.new(api_key: "YOUR_API_KEY")
code = "P0115"

begin
  obd = carsxe.obd_codes_decoder("code" => code)
  puts obd
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")
	code := "P0115"
	obd := client.ObdCodesDecoder(map[string]string{"code": code})
	fmt.Println(obd)
}
```

```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("code", "P0115");

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

```swift
import carsxe

let carsxe = CarsXE(apiKey: "YOUR_API_KEY")
let code = "P0115"

do {
    let obd = try carsxe.obdCodesDecoder(["code": code])
    print(obd)
} 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 code = "P0115";

        try
        {
            var obd = await carsxe.ObdCodesDecoder(new Dictionary<string, string> { { "code", code } });
            Console.WriteLine(obd);
        }
        catch (Exception ex)
        {
            Console.WriteLine($"Error: {ex.Message}");
        }
    }
}
```

```bash {{ title: "Response" }}
{
  "success": true,
  "diagnosis": "Engine Coolant Temperature Circuit Malfunction",
  "date": "2020-07-04T21:44:39.767Z",
  "code": "P0115"
}
```

</CodeGroup>

For the full interactive reference, try it live in the [API Reference](/api-reference/year-make-model/obd-codes-decoder).

### Response

<Properties>
  <Property name="success" type="boolean">
    Whether the code was decoded.
  </Property>
  <Property name="diagnosis" type="string">
    Diagnostic description for the trouble code.
  </Property>
  <Property name="date" type="string">
    Lookup timestamp or date returned by the API.
  </Property>
  <Property name="code" type="string">
    Normalized OBD code returned by the API.
  </Property>
</Properties>

## Errors

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

Common Year / Make / Model errors:

- **400** - Missing or invalid `year`, `make`, or `model`.
- **404** - No vehicle matched the specified year, make, and model.
- **500** - Could not fetch data.

Common OBD-II code decoder errors:

- **400** - Missing OBD code.
- **500** - Could not find the requested code.

Common errors for both endpoints:

- **401** - API key is missing, invalid, disabled, or unauthorized.
- **429** - Usage limit exceeded.

## 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).