:root {
  --story-board-background: #f9f8fc;
  --story-board-border: #e2e2e7;
  --hero-background: #fbfbfc;
}

.dark {
  --story-board-background: #1a1a1a;
  --story-board-border: #333;
  --hero-background: #1a1a1a;
}

.storyBoard {
  padding: 32px 24px;
  background-color: var(--story-board-background);
  font-size: 16px;
  line-height: 36px;
  border-radius: 4px;
}

.heroContent {
  background-color: var(--hero-background);
}


const template = `---
title: '<Title>'
---


 <code class="p-2 flex flex-wrap items-center justify-start">
 GET
 https://listings.vin?<QueryString>
 </code>


<ParamFields>

<ResponseExample>
<ResponseOutput>
</ResponseExample>
`

const parameter = (key, type, description) => {
 return `<ParamField query="${key}" type="${type}">
 ${description}
</ParamField>
`
}

const allFields = [
 {
 name: 'vehicle.year',
 humanName: 'Year',
 type: 'number',
 exampleValue: '2019',
 description:
 'The year of the vehicle. Example: 2019. If you want to search for a range of years, you can use the format 2019-2021.',
 },
 {
 name: 'vehicle.make',
 humanName: 'Make',
 type: 'string',
 exampleValue: 'Toyota',
 description: 'The make of the vehicle. Example: Toyota.',
 },
 {
 name: 'vehicle.model',
 humanName: 'Model',
 type: 'string',
 exampleValue: 'Corolla',
 description: 'The model of the vehicle. Example: Corolla.',
 },
 {
 name: 'vehicle.trim',
 humanName: 'Trim',
 type: 'string',
 exampleValue: 'LE',
 description: 'The trim of the vehicle. Example: LE.',
 },
 {
 name: 'vehicle.bodyStyle',
 humanName: 'Body Style',
 type: 'string',
 exampleValue: 'Truck',
 description: 'The body style of the vehicle. Example: Truck.',
 },
 {
 name: 'vehicle.transmission',
 humanName: 'Transmission',
 type: 'string',
 exampleValue: 'Automatic',
 description: 'The transmission of the vehicle. Example: Automatic.',
 },
 {
 name: 'vehicle.driveTrain',
 humanName: 'Drive Train',
 type: 'string',
 exampleValue: 'FWD',
 description: 'The drive type of the vehicle. Example: FWD.',
 },
 {
 name: 'vehicle.exteriorColor',
 humanName: 'Exterior Color',
 type: 'string',
 exampleValue: 'Black',
 description: 'The exterior color of the vehicle. Example: Black.',
 },
 {
 name: 'vehicle.interiorColor',
 humanName: 'Interior Color',
 type: 'string',
 exampleValue: 'Black',
 description: 'The interior color of the vehicle. Example: Black.',
 },
 {
 name: 'retailListing.miles',
 humanName: 'Mileage',
 type: 'number',
 exampleValue: '50000',
 description:
 'The mileage of the vehicle. Example: 50000. If you want to search for a range of mileage, you can use the format 50000-100000.',
 },
 {
 name: 'retailListing.price',
 humanName: 'Price',
 type: 'number',
 exampleValue: '20000',
 description:
 'The price of the vehicle. Example: 20000. If you want to search for a range of prices, you can use the format 20000-30000.',
 },
]

// For each field, generate a page with the field as a query parameter.
// Then mix and match the fields to generate more examples. e.g. year and make, year, make, model, etc.

const fs = require('fs')
const path = require('path')

const generateExamples = async (fields) => {
 const examples = []
 const fieldNames = fields.map((field) => field.name)

 const generate = async (fieldNames, title) => {
 const fields = allFields.filter(x => fieldNames.includes(x.name))

 const queryString = new URLSearchParams({
 ...Object.fromEntries(fields.map((field) => [field.name, field.exampleValue])),
 }).toString()

 const realData = await fetch(`https://listings.vin?${queryString}`)
 .then((r) => r.json())
 .then((d) => ({
 data: d.data,
 timings: d.timings,
 facets: d.facets,
 }))

 // Remove all but one result in the data array
 realData.data = realData.data.slice(0, 1)

 const responseOutput = '```json\n' + JSON.stringify(realData, null, 2) + '\n```'

 const example = template
 .replace('<Title>', `Search by ${title}`)
 .replace('<QueryString>', queryString)
 .replace('<ParamFields>', fields.map((field) => parameter(field.name, field.type, field.description)).join('\n'))
 .replace('<ResponseOutput>', responseOutput)

 examples.push({
 title: `Search by ${title}`,
 content: example,
 })
 }

 // Generate examples for each field
 await generate(
 [
 'vehicle.year'
 ],
 'Year'
 )

 await generate(
 [
 'vehicle.year',
 'vehicle.make'
 ],
 'Year & Make'
 )

 await generate(
 [
 'vehicle.year',
 'vehicle.make',
 'vehicle.model'
 ],
 'Year, Make, & Model'
 )

 await generate(
 [
 'vehicle.year',
 'vehicle.make',
 'vehicle.model',
 'vehicle.trim'
 ],
 'Year, Make, Model, & Trim'
 )

 await generate(
 [
 'vehicle.bodyStyle'
 ],
 'Body Style'
 )

 await generate(
 [
 'vehicle.transmission'
 ],
 'Transmission'
 )

 await generate(
 [
 'vehicle.exteriorColor'
 ],
 'Exterior Color'
 )

 return examples
}

const main = async () => {
 const examples = await generateExamples(allFields)

 // Write to ./data/listing/reference/examples/search

 const examplesDir = path.join(__dirname, 'data/vehicle/listings/reference/examples/search')

 if (!fs.existsSync(examplesDir)) {
 fs.mkdirSync(examplesDir, { recursive: true })
 }

 const allFiles = []

 examples.forEach((example) => {
 const filename = example.title.toLowerCase().replace(/ /g, '-').replaceAll(',', '') + '.mdx'
 allFiles.push(filename)

 fs.writeFileSync(path.join(examplesDir, filename), example.content)
 })

 // Output a list of all files
 console.log(
 JSON.stringify(
 allFiles.map(
 (x) => `data/vehicle/listings/reference/examples/search/${x.replace('.mdx', '')}`
 ),
 null,
 2
 )
 )
}

main()

const Ajv = require("ajv")
const fs = require("fs")
const path = require("path")

// Initialize AJV
const ajv = new Ajv({ allErrors: true, strict: false })

// Function to load JSON data from file
function loadJsonFile(filePath) {
  return JSON.parse(fs.readFileSync(filePath, 'utf-8'))
}

// Load the schema and compile the validator
const commerceSchema = loadJsonFile('./Commerce.json')

let schemas = Object.keys(commerceSchema.components.schemas).map(k => {
  const schema = JSON.parse(
    JSON.stringify(commerceSchema.components.schemas[k]).replaceAll(
      '#/components/schemas/',
      ''
    )
  )

  // Add the schema to AJV
  return ajv.addSchema(schema, k)
})

// Validate each JSON file in the examples directory
fs.readdir('./examples/', (err, files) => {
  if (err) {
    console.error("Failed to list contents of directory: " + err)
    return
  }

  // Output is a key value map of filename and validation result
  const output = {}

  files.forEach(file => {
    const filePath = path.join('./examples/', file)
    const data = loadJsonFile(filePath)

    // Ignore list
    // These files dont play nice with AJV, and we cant validate them.
    const ignore = [
      'AI.json',           'Account.json',
      'Analytics.json',    'Call.json',
      'Company.json',      'Consumer.json',
      'Contact.json',      'Credit.json',
      'CreditApp.json',    'Deal.json',
      'Dealer.json',       'InsurancePolicy.json',
      'Invoice.json',      'Lead.json',
      'Listing.json',      'Location.json',
      'Message.json',      'Sale.json',
      'SalesRep.json',     'Search.json',
      'Service.json',      'ServiceOrder.json',
      'TaxesAndFees.json', 'Trade.json',
      'Vehicle.json',      'VehicleSpec.json',
      'WebEvent.json'
    ]

    if (ignore.includes(file)) {
      return
    }

    // Compile the validator
    ajv.removeSchema(file.split('.')[0])

    if (!commerceSchema.components.schemas[file.split('.')[0]]) {
      console.error(`Schema for ${file} not found.`)
      return
    }

    const validate = ajv.compile(
      JSON.parse(
        JSON.stringify(commerceSchema.components.schemas[file.split('.')[0]])
        .replaceAll(
          '#/components/schemas/',
          ''
        )
      )
    )

    // Validate the data
    const valid = validate(data)
    if (!valid) {
      output[file] = validate.errors
    } else {
      output[file] = 'valid'
    }
  })

  console.log(
    JSON.stringify(output, null, 2)
  )
})

Retrieve a YearMakeModel

MakeModel is uniquely identified by Model

MakeModel

YearMakeModel is uniquely identified by MakeModel

YearMakeModel is uniquely identified by Year

YearMakeModel

Drivly Docs

Learn how to authenticate your requests with Drivly's APIs

Auth

Authentication

The official Drivly SDK for JavaScript, available for browsers and Node.js backends.

Drivly SDK

Get real-time notifications about events in your Drivly account.

Webhooks

Get Started

Data

Services

Commerce

Join waitlist

Contact

Introduction

Learn about best practices for using the Drivly SDK and APIs.

Best Practices

Everything you need to build modern automotive experiences.

Drivly UI

Understanding the basics of a Vehicle Identification Number (VIN).

What is a VIN?

Understanding the basics of a Squish Vehicle Identification Number (VIN).

What is a Squish VIN?

A suite of AI-powered workflows and tools to help you streamline your automotive business.

Overview

Drivly's framework to build, deploy, and monitor production-ready AI-powered workflows.

AI Functions

The possibilites are unlimited – here are a few examples of what you can build with Drivly AI.

Use Cases

The Future of Workflow Automation

Transforming Automotive Commerce with AI

Integrate Drivly AI Functions with Streaming User Interfaces (UIs)

Streaming User Interfaces

Learn about function composition and how it works to create seamless, multi-step commerce interactions.

Function Composition

Everything you need to build, buy, sell, and move vehicles.

Build

Inventory management, listing, and pricing

Sell

Trade

Vehicle sourcing, selling, and management

Broker

Dropship

Invoices

Collection of APIs that provide access to a wide range of automotive data.

Access auction insights, historical data, current listings, and sales results.

Auction

Auction Data

Access detailed dealership information, inventory, pricing, and contact details.

Dealer

Dealer Data

Learn about F&I Data and how it can be used.

Finance & Insurance Data

Get current interest rates for various automotive financial products.

Current Interest Rates

Current Interest Rates Data

Access loan payoff data for customers, including payoff amount and lenders.

Loan Payoff

Loan Payoff Data

Get information about the incentives offered by various OEMs.

OEM Incentives

OEM Incentives Data

Get estimated monthly payments, taxes, and fees for vehicle financing.

Payments

Payments Data

Get proof of active insurance policy for a vehicle by VIN.

Proof of Insurance

Proof of Insurance Data

Access and manage vehicle data to enhance connectivity and functionality.

IoT Data

Learn how to search for vehicles using the Listings Search API.

Listings

Listings Search

Access detailed vehicle manufacturer data and historical insights.

Manufacturer

Manufacturer Data

Access real-time and historical data related to the automotive market.

Market

Market Data

Access data to help diagnose and repair issues with a vehicle.

Service

Service Data

Learn about the Title & Registration APIs and its purpose.

Title & Registration

Title & Registration Data

Get estimated shipping costs, distances, and ETAs for vehicle transport.

Transport

Transport Data

Learn about Vehicle Data and how it can be used.

Vehicle Data

Access digital brochures, manuals, and other documentation related to a vehicle.

Brochures & Manuals

Brochures & Manuals Data

Access detailed vehicle history reports for a vehicle by VIN.

History Reports

Access vehicle listings currently available for sale, including pricing trends and more.

Listings Data

Access OEM-specific vehicle information by VIN.

OEM Build

OEM Build Data

Get high-quality listing & stock photos by VIN.

Photos

Photo Data

Pricing & Valuations

Access recall data for specific vehicles by VIN.

Recalls

Recall Data

Retrieve vehicle reviews and ratings based on the VIN.

Reviews

Access detailed vehicle specifications by VIN.

Specs

Specs Data

Get the total cost of ownership for a vehicle.

Total Cost of Ownership

Total Cost of Ownership Data

Decode a VIN to find the year, make, model, and more.

VIN Decode

VIN Decode Data

Access the original window sticker information for a vehicle.

Window Sticker

Window Sticker Data

Get Sales Reps

Create a new Sales Rep

Retrieve a Sales Rep

Update an existing Sales Rep

Get Calls

Create a new Call

Retrieve a Call

Update an existing Call

Get Meetings

Create a new Meeting

Retrieve a Meeting

Update an existing Meeting

Get Messages

Create a new Message

Retrieve a Message

Update an existing Message

Get Attachments

Create a new Attachment

Retrieve an Attachment

Update an existing Attachment

Get Templates

Create a new Template

Retrieve a Template

Update an existing Template

Get Holidays

Create a new Holiday

Retrieve a Holiday

Update an existing Holiday

Get Agents

Create a new Agent

Retrieve an Agent

Update an existing Agent

Get started with Taxes & Fees API with our step-by-step guide.

Taxes & Fees

Get started with Total Cost of Ownership API with our step-by-step guide.

Rates

Autocomplete

Autocomplete Search

Models

Search

Search Listings

Listing Details

VIN Decode API for OEM vehicle build data.

Get detailed specifications of a vehicle by VIN.

Get a photo of a vehicle by VIN and photo index.

View Photo

Get Web Events

Create a new Web Event

Retrieve a Web Event

Get Logs

Create a new Log

Retrieve a Log

Workflows to quote and order automotive services.

Learn how to use Back Office & Contracting workflows.

Back Office & Contracting

Body & Paint

Learn how to use Concierge Seach and Buy workflows.

Concierge

APIs for building and managing finance and insurance products.

Learn about how Pre-Approvals work with Drivly APIs.

Pre-Approval

Learn about how Credit Applications work with Drivly's Commerce API.

Credit Application

Learn about F&I products available through Drivly's Commerce API.

F&I Products

Inspections

Learn how to use Mechanical Repair workflows.

Mechanical Repair

Learn how to use Reconditioning workflows.

Reconditioning

Learn how to use Scheduled Maintenance workflows.

Services

Guides

API Reference

Retrieve a YearMakeModel

Path Parameters

Query Parameters

Response