vehicle.vin-decode

Decode a 17-character VIN to manufacturer-supplied vehicle metadata via NHTSA's vPIC database. Returns identity (year, make, model, trim, series, body class, manufacturer), assembly plant (city, state, country), engine (cylinders, displacement, HP, fuel type, configuration, engine model), transmission (style, speeds), and body/weight specs. Curated to the ~30 fields agents actually use from vPIC's ~140-field response. Backed by NHTSA.gov; data is public-domain US government records.

Overview

The VIN decode API turns a 17-character VIN into manufacturer-supplied vehicle specs using NHTSA's vPIC database — curated down to the ~30 fields agents actually use from vPIC's ~140-field response.

Get back vehicle identity (year, make, model, trim, series, body class, manufacturer), assembly plant (city, state, country), engine details (cylinders, displacement, horsepower, fuel type, configuration, engine model), transmission (style, speeds), and body and weight specs. The data is public-domain US government records, and there is no API key — pay per decode with x402.

Use cases

• Let a marketplace or insurance agent decode a VIN to auto-fill vehicle details instead of asking the user to type them.
• Validate and enrich VINs in a fleet or inventory database with canonical NHTSA specs.
• Power a buying or appraisal assistant that needs accurate make/model/engine data from just the VIN.
• Ground an automotive chatbot in real vPIC records rather than guessed specs.

Parameters

Code samples

# 1. Probe with no auth → 402 envelope with PaymentRequirements
curl -sS 'https://2s.io/api/vehicle/vin-decode?vin=xxxxxxxxxxxxxxxxx&modelYear=1949'

# 2. Sign + retry with PAYMENT-SIGNATURE:
curl -sS 'https://2s.io/api/vehicle/vin-decode?vin=xxxxxxxxxxxxxxxxx&modelYear=1949' \
  -H 'PAYMENT-SIGNATURE: <base64-json-payload>'

# Or use the canonical runner (handles probe → sign → retry):
#   EVM_PRIVATE_KEY=0x... node --env-file=.env.local \
#     --experimental-strip-types scripts/x402-pay.ts \
#     'https://2s.io/api/vehicle/vin-decode?vin=xxxxxxxxxxxxxxxxx&modelYear=1949'

import { TwoS } from '@2sio/sdk'

const client = new TwoS({
  privateKey: process.env.EVM_PRIVATE_KEY as `0x${string}`,
})

const result = await client.vehicle.vinDecode({
  "vin": "xxxxxxxxxxxxxxxxx",
  "modelYear": 1949
})

console.log('endpoint:', result.endpoint)
console.log('cost:', result.costUsd, 'USDC')
console.log('tx:', result.settlement?.txHash)
console.log('data:', result.data)

import os
from twosio import TwoS

client = TwoS(private_key=os.environ["EVM_PRIVATE_KEY"])

result = client.vehicle.vin_decode(vin="xxxxxxxxxxxxxxxxx", modelYear=1949)

print("endpoint:", result.endpoint)
print("cost:", result.cost_usd, "USDC")
print("tx:", (result.settlement or {}).get("tx_hash"))
print("data:", result.data)

// 1. Add @2sio/mcp to your MCP host config (Claude Desktop example below).
//    EVM_PRIVATE_KEY funds x402 payments per call.

// claude_desktop_config.json
{
  "mcpServers": {
    "2sio": {
      "command": "npx",
      "args": ["-y", "@2sio/mcp"],
      "env": { "EVM_PRIVATE_KEY": "0x..." }
    }
  }
}

// 2. Once the server is running, agents call this tool via standard MCP:

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "tools/call",
  "params": {
    "name": "vehicle.vin-decode",
    "arguments": {
      "vin": "xxxxxxxxxxxxxxxxx",
      "modelYear": 1949
    }
  }
}

Response

{
  "ok": true,
  "items": [
    {
      "vin": "example",
      "modelYear": "example",
      "make": "example",
      "model": "example",
      "trim": "example",
      "series": "example",
      "bodyClass": "example",
      "manufacturer": "example",
      "plant": {
        "city": "example",
        "state": "example",
        "country": "example"
      },
      "engine": {
        "cylinders": "example",
        "displacementL": "example",
        "hp": "example",
        "fuelTypePrimary": "example",
        "configuration": "example",
        "model": "example"
      },
      "transmission": {
        "style": "example",
        "speeds": "example"
      },
      "doors": "example",
      "driveType": "example",
      "vehicleType": "example",
      "gvwrClass": "example"
    }
  ],
  "total": 1,
  "source": {
    "provider": "example",
    "url": "example",
    "license": "example"
  }
}

FAQ

Where does the VIN data come from?

NHTSA's vPIC (Vehicle Product Information Catalog) database. The data is public-domain US government records.

Why fewer fields than NHTSA returns?

vPIC returns ~140 fields, many empty or rarely used. This endpoint curates the ~30 fields agents actually need (identity, engine, transmission, plant, body/weight) for a clean, predictable response.

Do I need an API key to use the vin decode API?

No. vehicle.vin-decode is x402-native — there is no signup and no API key. Your client makes the call, receives a 402 with payment requirements, signs a USDC payment, and retries. Funds come from a wallet you control.

How much does the vin decode API cost?

$0.0024 USDC per call, charged per request. There are no monthly fees, seats, or minimums — you pay only for the calls you make.

Can I try the vin decode API for free first?

Yes. Add ?trial=1 (or the header X-2s-Trial: 1) to get a free real call per endpoint per hour, so you can verify the response shape before wiring payment.

Which networks and tokens are supported?

USDC on Base (via EIP-3009 transferWithAuthorization) or Solana (SPL transfer), using the open x402 payment protocol.

How do I call vehicle.vin-decode from an AI agent or MCP host?

Use @2sio/sdk (TypeScript), 2sio (Python), or the @2sio/mcp server for any MCP host — each handles the probe → sign → retry loop for you. See the code samples on this page.

Discovery

• /api/directory — full catalog of every endpoint
• /openapi.json — OpenAPI 3.1 spec (per-op x-payment-info, x402Payment security)
• /.well-known/x402 — machine-readable service descriptor for x402-aware crawlers
• /.well-known/mcp/server-card.json — MCP SEP-1649 server card
• /llms.txt — plain-text manifest for LLM ingestion