Inventory Search

The RV Inventory Search API provides access to active recreational vehicle listings from dealers across the US markets. This comprehensive search tool enables RV dealers, marketplaces, and consumers to discover, filter, and analyze recreational vehicles with sophisticated filtering capabilities designed specifically for the RV industry.

Whether you're building RV marketplace applications, dealer inventory systems, or consumer search tools, this API delivers the specialized functionality needed for recreational vehicle applications with extensive parameter options covering RV-specific features like class types, slideouts, sleeping capacity, GVWR, and fresh water capacity.

Overview

• Access active dealer RV inventory across US markets with thousands of listings
• Data updates published regularly for current market conditions
• Comprehensive filtering with 50+ parameters specific to recreational vehicles

Units & Conventions:

Base Path

GET https://api.marketcheck.com/v2/search/rv/active

The following example demonstrates a basic search request with common parameters:

import axios from 'axios';

const options = {
  method: 'GET',
  url: 'https://api.marketcheck.com/v2/search/rv/active',
  params: {
    api_key: 'YOUR_API_KEY',
    rows: 2,
    make: 'Forest River',
    year: '2023',
    start: '0',
    facets: 'class',
    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 RV Inventory Search API provides extensive filtering and search capabilities for recreational vehicle listings. You can search by RV specifications, geographic location, pricing ranges, dealer types, and numerous other criteria to find the exact RVs you need.

Parameters

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

Defaults

• inventory_type: Returns all types (new, used) by default if not specified

Pagination

API response includes num_found property indicating the total number of RV listings matching the search criteria. By default, the API returns the first page of results with 10 listings per page.

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 50, default 10)

Increment start proportionally to rows value for consistent pagination:

• start=0&rows=50 - fetches listings 1-50
• start=50&rows=50 - fetches listings 51-100
• start=100&rows=50 - fetches listings 101-150

Limits:

• The rows parameter accepts a maximum value of 50 (default is 10)
  • If you specify rows greater than 50, the API will automatically use the default value of 10
  • 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.

Sorting

The Search 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:

• With location: sorts by distance (nearest first)
• Without location: sorts by last_seen (desc) and vin (asc)

Common Sort Fields

Below are the most commonly used sort fields for RV searches:

Facets

The Search API supports facets for building UI filters and analyzing RV inventory distribution. 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 RV 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
  • 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/search/rv/active',
  params: {
    api_key: 'YOUR_API_KEY',
    rows: 0,
    make: 'Forest River',
    year: 2024,
    facets: 'model%7C0%7C100%7C0%2Ccity%7C0%7C100%7C100'
  },
  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": "Forest River", "count": 58673 },
    { "item": "Jayco", "count": 19809 },
    ...
    ],
    "city": [
    { "item": "Los Angeles", "count": 1000 },
    { "item": "New York", "count": 800 },
    ...
    ]
}
}

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/search/rv/active',
  params: {
    api_key: 'YOUR_API_KEY',
    rows: 0,
    make: 'Forest River',
    year: 2024,
    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 for RV inventory.

Parameters

• stats — Comma-separated list of fields to calculate statistics on
  • Example: stats=price,miles

Example

import axios from 'axios';

const options = {
  method: 'GET',
  url: 'https://api.marketcheck.com/v2/search/rv/active',
  params: {
    api_key: 'YOUR_API_KEY',
    rows: 0,
    year: '2024',
    make: 'Forest River',
    model: 'Salem',
    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:

Spatial Search

Search for RVs available near specific locations using geographic coordinates, zip codes, or radius parameters for location-based inventory discovery.

Parameters

• latitude and longitude - Exact coordinates
• zip - ZIP code reference point
• radius - Search radius in miles

You can combine location parameters with any other search filters for precise geographic targeting.

Example

import axios from 'axios';

const options = {
  method: 'GET',
  url: 'https://api.marketcheck.com/v2/search/rv/active',
  params: {
    api_key: 'YOUR_API_KEY',
    rows: 2,
    make: 'Forest River',
    year: '2024',
    model: 'Salem',
    zip: '60069',
    radius: 100
  },
  headers: {Accept: 'application/json'}
};

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

Response

• Each listing includes a dist field with distance from the specified coordinates or ZIP code
• Distance is calculated in miles and returned as a numeric value
• Results are sorted by distance by default, with nearest listings appearing first

Response

Schema

The response includes comprehensive RV listing information with nested objects for media, dealer, and RV-specific build specifications.

interface RVSearchResponse {
  num_found: number; // Total number of listings matching search criteria
  listings: RVListing[]; // Array of vehicle listings
  facets?: Facets; // Field 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 RVListing {
  id: string; // Unique listing identifier
  vin?: string; // Vehicle Identification Number
  heading?: string; // Formatted listing title
  price?: number; // Current listing price
  miles?: number; // Vehicle mileage
  msrp?: number; // Manufacturer's Suggested Retail Price (as per dealer website)
  data_source: string; // Original data source identifier. Mostly `mc` for MarketCheck
  vdp_url?: string; // Vehicle detail page URL
  exterior_color?: string; // Exterior color description
  interior_color?: string; // Interior color description
  base_int_color?: string; // Standardized interior color
  base_ext_color?: string; // Standardized exterior color
  seller_type: string; // Type of seller (dealer, fsbo, auction)
  inventory_type: string; // Inventory classification (new, used)
  stock_no?: string; // Dealer stock number
  last_seen_at: number; // Last seen timestamp (Unix Seconds), when the listing was last updated
  last_seen_at_date: string; // Last seen date (ISO format)
  scraped_at: number; // First seen timestamp (Unix Seconds), when the listing was first scraped
  scraped_at_date: string; // First seen date (ISO format)
  first_seen_at: number; // First seen timestamp (Unix Seconds), when the listing was first seen. Copy of `scraped_at` field
  first_seen_at_date: string; // First seen date (ISO format)
  first_seen_at_source: number; // First seen at source website timestamp (Unix Seconds)
  first_seen_at_source_date: string; // First seen at source website date (ISO format)
  first_seen_at_mc: number; // First seen at MarketCheck timestamp (Unix Seconds)
  first_seen_at_mc_date: string; // First seen at MarketCheck date (ISO format)
  source: string; // Data source website domain
  media?: RVMedia; // Photos and media content links
  dealer?: RVDealer; // Dealer information
  build?: RVBuild; // Vehicle specifications
  extra?: RVExtra; // Additional features and options
  dist?: number; // Distance in miles from provided coords (when location filter is used)
}

interface RVMedia {
  photo_links?: string[]; // Array of photo URLs from dealer website
  floorplan_image_link?: string; // Floorplan image URL, when available
}

interface RVDealer {
  id: number; // The unique id associated with the dealer in the Marketcheck database
  name?: string; // Name of the dealer
  website?: string; // Website of the dealer
  dealer_type?: string; // Type of dealer (franchise/independent)
  dealership_group_name?: string; // Dealership group name of dealer
  street?: string; // Street of the dealer
  city?: string; // City of the dealer
  state?: string; // State of the dealer
  country?: string; // Country of the dealer
  zip?: string; // Zip of the dealer
  msa_code?: string; // MSA code of the dealer
  latitude?: string; // Latitude for the dealer location
  longitude?: string; // Longitude for the dealer location
  phone?: string; // Contact no of the dealer
  seller_email?: string; // Contact email of the dealer
}

interface RVBuild {
  year?: number; // Year of the RV
  make?: string; // RV Make
  model?: string; // RV model
  model_o?: string; // Manufacturer model code
  trim?: string; // Trim level
  class?: string; // RV class (Class A, Class B, Class C, Travel Trailer, etc.)
  slideouts?: string; // Number of slideouts
  sleeps?: string; // Sleeping capacity
  body_type?: string; // Body type of the RV
  body_subtype?: string; // Body subtype of the RV
  vehicle_type?: string; // Vehicle type of the RV
  condition?: string; // Condition of the RV (new/used)
  category?: string; // Category of the RV
  sub_category?: string; // Sub category of the RV
  drivetrain?: string; // Drivetrain of the RV
  engine_size?: string; // Engine size of the RV
  engine_block?: string; // Engine block type of the RV
  doors?: string; // Number of doors
  cylinders?: string; // Number of cylinders
  transmission?: string; // Transmission type
  height?: string; // Height of the RV
  fuel_type?: string; // Fuel type (gasoline, electric, hybrid, etc.)
  engine?: string; // Engine description
  area?: string; // Area of the RV
  length?: string; // Overall length (e.g., "37'8\"")
  made_in?: string; // Made in of the RV
  gvwr?: string; // Gross Vehicle Weight Rating
  overall_height?: string; // Overall height of the RV
  overall_width?: string; // Overall width of the RV
  std_seating?: string; // Standard seating capacity of the RV
  curb_weight?: string; // Curb weight of the RV
  highway_mpg?: number; // Highway miles per gallon
  city_mpg?: number; // City miles per gallon
  payload_capacity?: string; // Payload capacity of the RV
  hitch_weight?: string; // Hitch weight of the RV
  dry_weight?: string; // Dry weight of the RV
  interior_height?: string; // Interior height of the RV
  exterior_height?: string; // Exterior height of the RV
  fresh_water_capacity?: string; // Fresh water tank capacity
  black_water_capacity?: string; // Black water tank capacity
  grey_water_capacity?: string; // Grey water tank capacity
  seating_capacity?: string; // Seating capacity of the RV
  number_of_air_conditioners?: string; // Number of air conditioners
  air_conditioners_size?: string; // Size of air conditioners
  number_of_awnings?: string; // Number of awnings
  awnings_size?: string; // Size of awnings
  sleeping_capacity?: string; // Sleeping capacity of the RV
  slideout_type?: string; // Type of slideouts
  leveling_jacks_type?: string; // Type of leveling jacks
  wheelbase?: string; // Wheelbase of the RV
  number_of_bunk_beds?: string; // Number of bunk beds
  bunkhouse_type?: string; // Type of bunkhouse
  number_of_full_baths?: string; // Number of full bathrooms
  bed_type?: string; // Type of bed
  refrigerator_type?: string; // Type of refrigerator
  refrigerator_dimensions?: string; // Dimensions of refrigerator
  living_area?: string; // Living area of the RV
  outdoor_kitchen?: string; // Outdoor kitchen features
  dining_type?: string; // Type of dining area
  kitchen?: string; // Kitchen features
  outdoor_entertainment?: string; // Outdoor entertainment features
  engine_configuration?: string; // Engine configuration
  furnace_volume?: string; // Volume of furnace
  convertor_size?: string; // Size of convertor
  furnace_type?: string; // Type of furnace
  engine_make?: string; // Engine manufacturer
  engine_model?: string; // Engine model
  generator?: string; // Generator specifications
  cooling?: string; // Cooling system
  fuel_capacity?: string; // Fuel tank capacity
  number_of_speeds?: string; // Number of speeds
  storage_capacity?: string; // Storage capacity
  fuel_requirements?: string; // Fuel requirements
  engine_stroke?: string; // Engine stroke
  drive_type?: string; // Drive type
  horsepower?: string; // Horsepower
  starter?: string; // Starter type
  torque?: string; // Torque
  speeds?: string; // Transmission speeds
  towing_capacity?: string; // Towing capacity
  chassis?: string; // Chassis type (Ford F53, Freightliner, etc.)
  axle?: string; // Axle specifications
  number_of_oven_burners?: string; // Number of oven burners
  engine_displacement?: string; // Engine displacement
  lp_tank_capacity?: string; // LP tank capacity
  exterior_width?: string; // Exterior width
  cargo_capacity?: string; // Cargo capacity
  engine_torque?: string; // Engine torque
  water_heater?: string; // Water heater specifications
  width?: string; // Width of the RV
  floorplan_layout?: string; // Floorplan layout
  engine_type?: string; // Engine type
  floorplan?: string; // Floorplan
  weight?: string; // Weight of the RV
}
interface RVExtra {
  options?: string[]; // Installed Options of the RV
  features?: string[]; // List of Features available with the RV
  seller_comments?: string; // Seller comments for the RV
}

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

interface Stats {
  [key: string]: {
    min: number; // Minimum value
    max: number; // Maximum value
    count: number; // Number of values
    missing: number; // Count of missing values
    sum: number; // Sum of all values
    mean: number; // Arithmetic mean
    stddev: number; // Standard deviation
    sum_of_squares: number; // Sum of squared values
    median: number; // Median value
    percentiles: {
      [key: string]: number; // Percentile values
    };
  };
}

interface RangeFacets {
  [key: string]: {
    counts: {
      lower_bound: number; // Range lower bound
      upper_bound: number; // Range upper bound
      count: number; // Number of listings in range
    }[];
    interval: number; // Interval size
    start: number; // Starting value
    end: number; // Ending value
    before: number; // Count below start
    between: number; // Count within range
    after: number; // Count above end
  };
}

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>"
}

Use Cases & Examples

Filtering by RV Specifications

Filter listings based on specific RV attributes like make, model, year, class, and RV-specific features. This allows users to find RVs that match their exact preferences.

Example:

Here we're filtering for Class A motorhomes from 2020 to 2025 from Forest River, Winnebago.

import axios from 'axios';

const options = {
  method: 'GET',
  url: 'https://api.marketcheck.com/v2/search/rv/active',
  params: {
    api_key: 'YOUR_API_KEY',
    rows: 2,
    make: 'Forest River,Winnebago',
    year_range: '2020-2025',
    class: 'class A'
  },
  headers: {Accept: 'application/json'}
};

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

RV Types and Classes

• Use class to filter by RV class types:
  • class=Class A for large motorhomes
  • class=Class B for van-style RVs
  • class=Class C for cab-over motorhomes
  • class=Travel Trailer for towable RVs
  • class=Fifth Wheel for large towable RVs

Example:

Here we're filtering for Class C motorhomes.

import axios from 'axios';

const options = {
  method: 'GET',
  url: 'https://api.marketcheck.com/v2/search/rv/active',
  params: {api_key: 'YOUR_API_KEY', class: 'class C', rows: 2},
  headers: {Accept: 'application/json'}
};

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

Find RV by VIN

• Use vin parameter to search for a specific RV by its VIN (Vehicle Identification Number)
• This returns single listing (if exists) of that VIN

Example:

Here we're searching for an RV by its VIN.

import axios from 'axios';

const options = {
  method: 'GET',
  url: 'https://api.marketcheck.com/v2/search/rv/active',
  params: {api_key: 'YOUR_API_KEY', vin: '5ZT2ALTB1S9011042'},
  headers: {Accept: 'application/json'}
};

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

RV-Specific Features

Search by RV-specific attributes like sleeping capacity, slideouts, and length specifications.

Parameters:

• sleeps - Sleeping capacity (e.g., "6", "8")
• slideouts - Number of slideouts (e.g., "2", "3", "4")
• length_range - Length range filtering
• gvwr - Gross Vehicle Weight Rating
• fresh_water_capacity - Fresh water tank capacity

Example:

Here we're searching for RVs with at least 2 slideouts.

import axios from 'axios';

const options = {
  method: 'GET',
  url: 'https://api.marketcheck.com/v2/search/rv/active',
  params: {api_key: 'YOUR_API_KEY', slideouts: '2', sleeps: '5'},
  headers: {Accept: 'application/json'}
};

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

Range Filtering

Filter RV listings within numeric ranges using the following parameters. Range values must be integers in min-max format.

Example:

Here we're filtering for RVs in a specific price range.

import axios from 'axios';

const options = {
  method: 'GET',
  url: 'https://api.marketcheck.com/v2/search/rv/active',
  params: {api_key: 'YOUR_API_KEY', price_range: '5000-10000', rows: 2},
  headers: {Accept: 'application/json'}
};

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

Full Text Search

Search for specific terms across all RV listing fields using the search_text parameter.

Example:

Here we're searching for RVs with "Feather" mentioned anywhere in the listing.

import axios from 'axios';

const options = {
  method: 'GET',
  url: 'https://api.marketcheck.com/v2/search/rv/active',
  params: {api_key: 'YOUR_API_KEY', search_text: 'Feather', rows: 1},
  headers: {Accept: 'application/json'}
};

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

RV-Specific Considerations

RV Classes and Types

The API supports filtering by various RV classes:

• Class A: Large motorhomes built on heavy-duty truck chassis
• Class B: Van-style motorhomes, compact and maneuverable
• Class C: Motorhomes with distinctive cab-over design
• Travel Trailers: Towable RVs of various sizes
• Fifth Wheels: Large towable RVs that connect to pickup truck beds
• Pop-up Campers: Lightweight, collapsible camping trailers

Technical Specifications

RV searches support specialized filtering:

• Slideouts: Expandable room sections for additional living space
• Sleeping Capacity: Total number of people the RV can accommodate
• Length Classifications: From compact units to luxury coaches
• Weight Classes: GVWR for towing and licensing requirements
• Tank Capacities: Fresh water, gray water, black water storage

See Also

• RV Auto Complete - Auto-complete functionality for RV search inputs
• RV Listing Details - Individual RV listing information
• RV Dealers Search - Find RV dealers and inventory