Dealership Inventory Syndication

The Dealership Inventory Syndication API provides access to a dealer's complete active inventory, including duplicate listings across multiple sources. This is specifically designed for inventory syndication workflows where comprehensive data access is required on dealer level inventory.

Overview

• Access to the comprehensive dealer's active inventory, including non-attributed (non-searchable) listings for more than 80 thousand dealers across the US and Canada.
• Enhanced pagination support up to 1,500 listings per request (30x higher than standard API)
• Specialized filtering for dealer-owned inventory versus all syndicated listings
• Optimized for syndication and inventory management workflows
• Returns active listings refreshed daily on or before 11 AM UTC

Units & Conventions:

Base Path

GET https://api.marketcheck.com/v2/dealerships/inventory

The following example demonstrates a basic request to retrieve dealer inventory:

import axios from 'axios';

const options = {
  method: 'GET',
  url: 'https://api.marketcheck.com/v2/dealerships/inventory',
  params: {
    api_key: 'YOUR_API_KEY',
    dealer_id: '1035095',
    start: 0,
    rows: 5,
    facets: 'year,make',
    stats: 'price'
  },
  headers: {Accept: 'application/json'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

Explore the full range of parameters available for filtering, sorting, and configuring search results in the Parameters section below.

Request

The Dealership Inventory Syndication API provides access to dealer-specific inventory with enhanced capabilities for syndication workflows. You can search by specifying the target dealer using at least one of the available dealer identification parameters, and optionally apply additional filtering, sorting, and analysis parameters.

Parameters

Available parameters for filtering, sorting, and configuring search results:

Defaults

• rows: Defaults to 1500 (maximum allowed)
  • Values exceeding 1500 are automatically capped at the maximum limit
• owned: Defaults to false - includes all syndicated listings including non-attributed
  • Set to owned=true to retrieve dealer-owned inventory only i.e Attributed (Searchable) listings

Pagination

API response includes num_found property indicating the total number of listings matching the search criteria. By default, the API returns 1,500 listings per page (significantly higher than standard API limits).

You can use start and rows parameters to iterate through search results efficiently.

Parameters:

• start - Offset from which listings are returned (starts at 0)
• rows - Number of listings per page (maximum 1,500, default 1,500)

Increment start proportionally to rows value for consistent pagination:

• start=0&rows=1500 - fetches listings 1-1,500
• start=1500&rows=1500 - fetches listings 1,501-3,000
• start=3000&rows=1500 - fetches listings 3,001-4,500

Limits:

• The rows parameter accepts a maximum value of 1,500 (default is also 1,500)
  • If you specify rows greater than 1,500, the API will automatically use the maximum value of 1,500
  • If you're on last page of results, the API will return remaining listings, which may be fewer than the requested rows
• Your subscription package limits the total number of results you can paginate through; exceeding this limit returns an error
• If the sum of start and rows exceeds your subscription's pagination limit, or if start is greater than the total number of available results (num_found), the API will respond with a HTTP 422 error status.

Sorting

The Dealership Inventory Syndication API allows sorting results by a single numeric or date field at a time. Sorting by multiple fields simultaneously is not supported.

Sort Parameters:

• sort_by - Field name to sort by
• sort_order - Sort direction (asc or desc)

Default Behavior:

• Sorts by last_seen (desc) and vin (asc)

Common Sort Fields

Below are the most commonly used sort fields. For a complete list, see the next table.

All Available Sort Fields

Facets

The Dealership Inventory Syndication API supports facets for building UI filters and analyzing inventory distribution for dealership inventory. Use facets to get unique value counts for categorical fields and range-based counts for numeric fields.

Field Facets

Field facets return unique terms and their counts for categorical data, useful for building search filters and understanding dealerships active inventory distribution.

Parameters and Syntax

• facets — Comma-separated list of field names to facet on. Supports pagination and minimum count:
  facets=field_name|offset|limit|min_count
  • offset - Starting position (default: 0)
  • limit - Maximum terms returned (default: 20, max: 1000)
  • min_count - Minimum count threshold (default: 1)
  • Example: facets=make|0|60|2 returns top 60 makes with at least 2 listings each
• facet_sort — Controls sort order of facet terms:
  • count (default): Sort by frequency (highest first)
  • index: Sort alphabetically

Example

import axios from 'axios';

const options = {
  method: 'GET',
  url: 'https://api.marketcheck.com/v2/dealerships/inventory',
  params: {
    api_key: 'YOUR_API_KEY',
    source: 'stgautogroup.com',
    start: 0,
    rows: 0,
    facets: 'make|0|100|0,model|0|100|100'
  },
  headers: {Accept: 'application/json'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

Response

• Facets are returned in the facets field of the response, structured as key-value pairs
• Keys are field names and values are arrays of objects with item and count properties
  • item is the unique term
  • count is the number of listings for that term.

{
  "facets": {
      "make": [
      { "item": "Toyota", "count": 219 },
      { "item": "Chevrolet", "count": 118 },
      ...
      ],
      "model": [
      { "item": "RAV4", "count": 44 },
      { "item": "Camry", "count": 35 },
      ...
      ]
  }
}

If requested field is not allowed for faceting, it will be included in the response but with an error message indicating the field is not supported for facets.

{
  "facets": {
    "xyz": [
      {
        "result": "Error",
        "message": "Field xyz is not allowed in facets"
      }
    ]
  }
}

Available Field Facets

Facet Pagination

By default, facets return the top 20 terms for each field. You can control pagination using positional parameters offset, limit:

• offset - Starting position for terms (default: 0)
• limit - Maximum number of terms to return (default: 20, max: 1000)

Example: facets=make|20|20 returns makes 21-40

Facets Sorting

Facet terms can be sorted by count or alphabetically using the facet_sort parameter:

• count (default) - Sort by frequency (highest first)
• index - Sort alphabetically

Example: facets=make|0|20&facet_sort=index returns makes sorted alphabetically

Range Facets

Range facets provide statistical distribution analysis for numeric fields, creating buckets for data visualization and market insights.

Parameters and Syntax

• range_facets — Comma-separated list of field names to facet on, with optional range and interval:
  range_facets=field_name|start|end|interval
  • start (optional): Lower bound of the range (default varies by field)
  • end (optional): Upper bound of the range (default varies by field)
  • interval (optional): Size of each bucket (default: (end - start)/20)
  • Example: range_facets=price|500|20000|1000 returns price ranges with 1000 intervals between 500 and 20000.
• If start is specified but end is not, the API adds the default end value for that field to the start value.
• Value of interval has to be greater than (end - start)/200, otherwise the API will return an error.

Example

import axios from 'axios';

const options = {
  method: 'GET',
  url: 'https://api.marketcheck.com/v2/dealerships/inventory',
  params: {
    api_key: 'YOUR_API_KEY',
    source: 'stgautogroup.com',
    start: 0,
    rows: 0,
    range_facets: 'price|500|100000|10000,miles|5000|50000|5000'
  },
  headers: {Accept: 'application/json'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

Response

• Range facets are returned in the range_facets field of the response, structured as key-value pairs
• Keys are field names and values are objects containing:
  • counts: Array of buckets with lower_bound, upper_bound, and count properties
  • interval: Size of each bucket
  • start: Lower bound of the range
  • end: Upper bound of the range
  • before: Count of listings below the start value
  • between: Count of listings within the range
  • after: Count of listings above the end value
• If requested field is not allowed for range facets, it will be included in the response but with an error message indicating the field is not supported for range facets.

  {
    "range_facets": {
      "xyz": {
        "result": "Error",
        "message": "Field xyz is not allowed in range facets"
      }
    }
  }
  

Available Range Facets

Stats

The Search API calculates comprehensive statistics for numeric fields, providing market analysis and competitive intelligence insights.

Parameters

• stats — Comma-separated list of fields to calculate statistics on
  • Example: stats=price,miles,msrp
• stats can be combined with other parameters like facets, sort_by for detailed analysis

Example

import axios from 'axios';

const options = {
  method: 'GET',
  url: 'https://api.marketcheck.com/v2/dealerships/inventory',
  params: {
    api_key: 'YOUR_API_KEY',
    source: 'stgautogroup.com',
    start: 0,
    rows: 0,
    stats: 'price,miles'
  },
  headers: {Accept: 'application/json'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

Response

• Statistics are returned in the stats field of the response, structured as key-value pairs
• Keys are field names and values are objects containing:
  • min: Minimum value
  • max: Maximum value
  • count: Total number of listings with non-null values
  • missing: Number of listings with missing values
  • sum: Total sum of values
  • mean: Average value
  • stddev: Standard deviation
  • sum_of_squares: Sum of squares for variance calculation
  • median: Median value
  • percentiles: Percentile distribution (5th, 25th, 50th, 75th, 90th, 95th, 99th)
• If requested field is not allowed for stats, it will be included in the response but with an error message indicating the field is not supported for stats

  {
    "stats": {
      "xyz": {
        "result": "Error",
        "message": "Field xyz is not allowed in stats"
      }
    }
  }
  

Available Stats Fields

Below are the available fields for statistics calculations:

Financial Metrics

Performance and Efficiency

Market Timing

Spatial Search

Search for dealerships inventory available near specific locations using zip codes for location-based inventory discovery.

Parameters

• zip - ZIP code reference point for spatial search

Response

The Dealership Inventory API returns JSON data with comprehensive vehicle listing information, including inventory details, dealer information, vehicle specifications, and optional facets and statistics.

Schema

interface DealershipInventoryResponse {
  num_found: number; // Total number of listings matching search criteria
  listings: Listing[]; // Array of vehicle listings
  facets?: Facets; // Categorical facets (when facets parameter is used)
  stats?: Stats; // Statistical data (when stats parameter is used)
  range_facets?: RangeFacets; // Range-based facets (when range_facets parameter is used)
}

interface Listing {
  id: string; // Unique listing identifier
  heading: string; // Listing title
  price: number; // Listing price
  miles: number; // Vehicle mileage
  msrp?: number; // Manufacturer suggested retail price
  inventory_type: 'new' | 'used'; // Vehicle condition
  last_seen_at: number; // Last seen timestamp (Unix epoch)
  last_seen_at_date: string; // Last seen date (ISO-8601)
  first_seen_at: number; // First seen timestamp (Unix epoch)
  first_seen_at_date: string; // First seen date (ISO-8601)
  first_seen_at_mc: number; // First seen at MarketCheck timestamp
  first_seen_at_mc_date: string; // First seen at MarketCheck date
  first_seen_at_source: number; // First seen at source timestamp
  first_seen_at_source_date: string; // First seen at source date
  vdp_url: string; // Vehicle detail page URL
  source: string; // Website domain
  vin: string; // Vehicle identification number
  stock_no?: string; // Dealer stock number
  dom: number; // Days on market (lifetime)
  dom_active: number; // Days on market (active)
  dom_180: number; // Days on market (180-day window)
  dos_active: number; // Days on source active
  price_change?: number; // Price change amount
  price_change_percent?: number; // Price change percentage
  carfax_1_owner?: boolean; // Single owner status
  carfax_clean_title?: boolean; // Clean title status
  is_certified?: number; // Certified pre-owned status
  in_transit?: boolean; // In-transit status
  car_location?: CarLocation; // Vehicle location details
  media?: Media; // Photo and media links
  dealer?: Dealer; // Legacy dealer information
  mc_dealership?: McDealership; // MarketCheck dealer information
  finance?: ListingFinance; // Finance information
  lease?: ListingLease; // Lease information
  build?: Build; // Vehicle specifications
}

interface ListingFinance {
  loan_term?: number; // Loan term in months
  loan_apr?: number; // Annual percentage rate
  down_payment?: number; // Down payment amount
  estimated_monthly_payment?: number; // Monthly payment estimate
}

interface ListingLease {
  lease_term?: number; // Lease term in months
  down_payment?: number; // Down payment amount
  estimated_monthly_payment?: number; // Monthly lease payment estimate
}

interface CarLocation {
  mc_car_location_id?: string; // MarketCheck car location identifier
  seller_name: string; // Dealer or seller name
  street: string; // Street address
  city: string; // City name
  zip: string; // Postal/ZIP code
  state: string; // State name
  latitude: string; // Geographic latitude
  longitude: string; // Geographic longitude
}

interface Media {
  photo_links?: string[]; // Array of photo URLs from dealer website
  photo_links_cached?: string[]; // Array of cached photo URLs from MarketCheck
}

interface Dealer {
  id: number; // Unique dealer identifier
  name: string; // Dealer name
  phone?: string; // Contact phone number
  street?: string; // Street address
  city?: string; // City
  state?: string; // State abbreviation
  zip?: string; // ZIP code
  country?: string; // Country code
  latitude?: number; // Geographic latitude
  longitude?: number; // Geographic longitude
  website?: string; // Dealer website URL
  inventory_count?: number; // Total inventory count
  type?: string; // Dealer type
  msa_code?: string; // Metropolitan Statistical Area code
}

interface McDealership {
  mc_website_id?: number; // MarketCheck website identifier
  mc_dealer_id?: number; // MarketCheck dealer identifier
  mc_location_id?: number; // MarketCheck location identifier
  mc_rooftop_id?: number; // MarketCheck rooftop identifier
  mc_dealership_group_id?: number; // MarketCheck dealership group identifier
  mc_dealership_group_name?: string; // Dealership group name
  mc_sub_dealership_group_id?: number; // Sub-group identifier
  mc_sub_dealership_group_name?: string; // Sub-group name
  name?: string; // Dealership name
  street?: string; // Street address
  city?: string; // City
  state?: string; // State abbreviation
  zip?: string; // ZIP code
  country?: string; // Country code
  latitude?: number; // Geographic latitude
  longitude?: number; // Geographic longitude
  website?: string; // Dealership website URL
  inventory_count?: number; // Total inventory count
  type?: string; // Dealership type
  phone?: string; // Contact phone number
}

interface Build {
  year: number; // Model year
  make: string; // Vehicle manufacturer
  model: string; // Vehicle model
  trim?: string; // Trim level
  body_type?: string; // Body style
  body_subtype?: string; // Body subtype
  vehicle_type?: string; // Vehicle category
  drivetrain?: string; // Drivetrain type
  transmission?: string; // Transmission type
  engine?: string; // Engine specification
  engine_size?: number; // Engine displacement
  engine_block?: string; // Engine block type
  cylinders?: number; // Cylinder count
  fuel_type?: string; // Primary fuel type
  city_mpg?: number; // City fuel economy
  highway_mpg?: number; // Highway fuel economy
  exterior_color?: string; // Exterior color
  interior_color?: string; // Interior color
  doors?: number; // Number of doors
  seating_capacity?: number; // Passenger capacity
  options_packages?: string[]; // Option packages
  high_value_features?: string[]; // Premium features
  powertrain_type?: string; // Powertrain classification
}

interface Facets {
  [key: string]: {
    item: string; // Facet term
    count: number; // Number of listings
  }[];
}

interface Stats {
  [key: string]: {
    min: number;
    max: number;
    count: number;
    sum: number;
    sum_of_squares: number;
    mean: number;
    std_deviation: number;
    variance: number;
    percentiles: {
      [percentile: string]: number;
    };
  };
}

interface RangeFacets {
  [key: string]: {
    counts: {
      lower_bound: number;
      upper_bound: number;
      count: number;
    }[];
    before: number;
    between: number;
    after: number;
  };
}

Success Response

• 200 OK - Returns JSON object with search results
• Always includes num_found field indicating total matching listings
• listings array contains vehicle data (empty if no matches)
• Optional facets, stats, and range_facets based on request parameters
• Missing or null fields are excluded from individual listing objects

Error Response

Error Response Format

Most error responses follow this structure, except for 502 and 503 errors

{
  "code": <HTTP status code>,
  "message": "<Error message describing the issue>"
}

Best Practices

• Always check HTTP status codes
• Implement retry logic for 5xx errors
• Respect rate limits (429 responses)
• Validate parameters before sending requests

Use Cases & Examples

Filtering by Dealer Specific Identifiers

• Retrieve inventory for a specific dealer using their identifiers like dealer_id, source, or other dealer attributes, such as the following:
  • dealership_group_name
  • mc_website_id
  • mc_dealer_id
  • mc_location_id
  • mc_rooftop_id
  • mc_dealership_group_id
  • mc_dealership_group_name
  • mc_sub_dealership_group_id
  • mc_sub_dealership_group_name
• All Dealer attributes support multiple values, by using comma separated values. For example, to retrieve inventory for multiple dealers, you can use mc_dealer_id=10027620,1000030.

Example:

Here we're retriving active inventory for a specific using their website domain stgautogroup.com with the maximum pagination limit to access comprehensive dealer data in a single request.

import axios from 'axios';

const options = {
  method: 'GET',
  url: 'https://api.marketcheck.com/v2/dealerships/inventory',
  params: {api_key: 'YOUR_API_KEY', source: 'stgautogroup.com', start: 0, rows: 2},
  headers: {Accept: 'application/json'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

Filtering by Inventory Types

• Use car_type to filter by new or used vehicles in dealership inventory:
  • car_type=new for new vehicles
  • car_type=used for used vehicles
  • car_type=certified for certified pre-owned vehicles. These are subset of used vehicles.
• If car_type is not specified, the API returns all types by default.
• The API response contains the inventory_type field which shows new or used values. When car_type=certified is used, the inventory_type will be used since certified cars are used vehicles, but they will have an additional is_certified field with value 1 to distinguish them from regular used cars.

Examples:

Here we're retrieving used active inventory actually owned by a specific dealership:

import axios from 'axios';

const options = {
  method: 'GET',
  url: 'https://api.marketcheck.com/v2/dealerships/inventory',
  params: {
    api_key: 'YOUR_API_KEY',
    source: 'autonationusa.com',
    car_type: 'used',
    start: 0,
    rows: 2,
    owned: true
  },
  headers: {Accept: 'application/json'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

Certified Pre-Owned Vehicles:

• Certified vehicles are a subset of used vehicles, so when you filter by car_type=used, you will also get certified vehicles included in the results.
• To filter for certified vehicles specifically, you can use car_type=certified.
  • This will return only certified pre-owned vehicles, excluding other used vehicles.
  • These vehicles will have inventory_type=used and an additional is_certified=1 field.

Examples:

Here we're retrieving certified pre-owned vehicles from a dealership group:

import axios from 'axios';

const options = {
  method: 'GET',
  url: 'https://api.marketcheck.com/v2/dealerships/inventory',
  params: {
    api_key: 'YOUR_API_KEY',
    source: 'autonationusa.com',
    rows: 5,
    car_type: 'certified'
  },
  headers: {Accept: 'application/json'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

Include Non-VIN Listings

• Dealership inventory syndication workflows often require comprehensive coverage of a specific dealership's inventory, including non-VIN listings
• Read here to understand what non-VIN listings are: Understanding VIN v/s Non-VIN Listings
• To include non-VIN listings in dealership inventory results, use include_non_vin_listings=true parameter
• This will return listings that do not have a VIN, but are otherwise valid listings
• This ensures complete inventory coverage for syndication partners and marketing platforms
• Since VIN is missing, the specifications data is not normalized and may vary in completeness

Example:

Here we're including non-VIN listings in dealership inventory for comprehensive syndication:

import axios from 'axios';

const options = {
  method: 'GET',
  url: 'https://api.marketcheck.com/v2/dealerships/inventory',
  params: {
    api_key: 'YOUR_API_KEY',
    mc_website_id: '10000469',
    rows: 1500,
    include_non_vin_listings: true
  },
  headers: {Accept: 'application/json'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

Daily New Arrivals

• Track newly added inventory to dealership's website using first_seen_at_source_range (absolute) or first_seen_at_source_days (relative) parameters
• These would be the vehicles that have been added to the source website for the first time in the last 24 hours
• Ideal for large dealership groups to monitor inventory additions across multiple locations and rooftops
• Helps identify fresh inventory for marketing campaigns, featured listings, and customer notifications
• Useful for inventory managers to track daily stock additions and syndication performance

Examples:

Here we're finding vehicles that were first seen on the source website in the last 24 hours:

import axios from 'axios';

const options = {
  method: 'GET',
  url: 'https://api.marketcheck.com/v2/dealerships/inventory',
  params: {
    api_key: 'YOUR_API_KEY',
    source: 'carmax.com',
    first_seen_at_source_days: '1-*',
    rows: 2
  },
  headers: {Accept: 'application/json'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

Unique Values / Drill-Downs

• Use facets and range_facets parameters to get unique values and distributions for specific fields.
• These values can be used for drill-downs in your application, allowing users to explore inventory based on specific attributes.
• facets provides unique counts for categorical fields, while range_facets provides distribution analysis for numeric fields.
• We recommend using facets to get unique values for filtering, as it provides a more accurate and consistent set of values compared to using the raw data from other input sources

Example:

Here we're getting unique makes and their counts for a large dealership like CarMax to understand their inventory distribution:

import axios from 'axios';

const options = {
  method: 'GET',
  url: 'https://api.marketcheck.com/v2/dealerships/inventory',
  params: {api_key: 'YOUR_API_KEY', source: 'carmax.com', rows: 0, facets: 'make'},
  headers: {Accept: 'application/json'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

Drilling Down with Facets

For large dealership groups with thousands of vehicles, you can use facets to segment inventory and then use pagination to retrieve detailed listings for specific segments. This approach is particularly effective for dealerships like CarMax, AutoNation, or Carvana that maintain extensive inventories across multiple locations.

Example:

Step 1: Get City Distribution for Dealerships

First, get the distribution of inventory across different cities for CarMax to understand where their vehicles are located:

import axios from 'axios';

const options = {
  method: 'GET',
  url: 'https://api.marketcheck.com/v2/search/car/active',
  params: {api_key: 'YOUR_API_KEY', source: 'carmax.com', facets: 'city'},
  headers: {Accept: 'application/json'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

This returns city counts like:

{
  "facets": {
    "city": [
      { "item": "Houston", "count": 1867 },
      { "item": "Raleigh", "count": 983 },
      { "item": "Austin", "count": 960 },
      { "item": "Norcross", "count": 956 },
      ...
    ]
  }
}

Step 2: Paginate Through Specific City Inventory

Now drill down into a specific city (Houston) with high inventory count and paginate through their listings:

import axios from 'axios';

const options = {
  method: 'GET',
  url: 'https://api.marketcheck.com/v2/dealerships/inventory',
  params: {
    api_key: 'YOUR_API_KEY',
    source: 'carmax.com',
    start: 0,
    rows: 1500,
    city: 'Houston'
  },
  headers: {Accept: 'application/json'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

Filter by Ranges

• For numeric fields, use corresponding range parameters to filter dealership inventory based on specific ranges
• Particularly useful for large dealership groups like CarMax, Carvana, or AutoNation for inventory analysis
• Available range parameters include: price_range, miles_range, msrp_range, dom_range, dom_180_range, dom_active_range, dos_active_range, highway_mpg_range, city_mpg_range
• These parameters enable detailed inventory segmentation for business intelligence and customer targeting

Example:

Here we're filtering a large dealership group carmax.com vehicles priced between $10,000 and $20,000 with mileage under 50,000 miles and active days on market less than 30 days:

import axios from 'axios';

const options = {
  method: 'GET',
  url: 'https://api.marketcheck.com/v2/dealerships/inventory',
  params: {
    api_key: 'YOUR_API_KEY',
    source: 'carmax.com',
    price_range: '10000-20000',
    miles_range: '0-50000',
    dos_active_range: '0-30',
    rows: 2
  },
  headers: {Accept: 'application/json'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

Performance Considerations

The Dealership Inventory Syndication API is optimized for syndication workflows but has specific performance characteristics:

• Response Times: These endpoints can be slower than standard APIs due to the large dataset size (up to 1,500 listings per request)
• Large Payloads: Default requests return 1,500 listings, resulting in significantly larger response payloads than standard API calls
• Processing Time: Expect longer processing times when requesting maximum row counts, especially with additional parameters like stats, facets, or complex filtering

Best Practices:

• Use pagination strategically rather than requesting all data at once
• Consider using owned=true to reduce dataset size when appropriate
• Implement appropriate timeout settings in your applications

See Also

• Car Search API
• Dealerships API
• Car Listing Details
• VIN History