CarsXE for Parking Applications

Learn how parking companies and applications can leverage CarsXE APIs to provide smart parking solutions based on vehicle dimensions, EV capabilities, and other key specifications.

Parking applications face a unique challenge: matching vehicles with suitable parking spaces. Whether it's ensuring a large truck can fit in a garage, directing EV owners to charging-enabled spots, or filtering results based on vehicle height restrictions, having accurate vehicle data is essential.

CarsXE provides two powerful APIs that parking companies can use to deliver intelligent, personalized parking experiences:

Vehicle Plate Decoder API - Get vehicle information from license plates
Vehicle Specifications API - Get detailed specifications from VINs

Common Use Cases

1. Size-Based Parking Recommendations

Challenge: A truck owner in NYC needs to find parking spots that can accommodate their vehicle's dimensions.

Solution: Use CarsXE to automatically determine vehicle dimensions and filter parking options accordingly.

Example Flow

// User enters license plate: "ABC1234"
const plateData = await carsxe.platedecoder({
  plate: "ABC1234",
  state: "NY",
  country: "US"
});
 
// Get detailed specs from VIN
const specs = await carsxe.specs({
  vin: plateData.vin
});
 
// Extract dimensions
const dimensions = {
  length: specs.attributes.overall_length,    // e.g., "231.80 in."
  width: specs.attributes.overall_width,      // e.g., "80.00 in."
  height: specs.attributes.overall_height,    // e.g., "76.60 in."
};
 
// Filter parking spots
const suitableSpots = parkingLocations.filter(spot => {
  return spot.maxLength >= parseDimension(dimensions.length) &&
         spot.maxWidth >= parseDimension(dimensions.width) &&
         spot.maxHeight >= parseDimension(dimensions.height);
});

Key Vehicle Attributes:

overall_length - Total vehicle length
overall_width - Total vehicle width
overall_height - Total vehicle height
wheelbase_length - Distance between front and rear axles
turning_diameter - Turning radius for tight spaces

2. EV Charging Station Prioritization

Challenge: Show EV charging availability prominently to electric vehicle owners.

Solution: Detect if a vehicle is electric and highlight charging-enabled parking locations.

Example Flow

// Decode license plate
const plateData = await carsxe.platedecoder({
  plate: "TESLA99",
  state: "CA",
  country: "US"
});
 
// Get detailed specs
const specs = await carsxe.specs({
  vin: plateData.vin
});
 
// Check if vehicle is electric
const isEV = specs.attributes.fuel_type === "Electric" ||
             specs.attributes.fuel_type === "Plug-in Hybrid";
 
// Customize UI for EV owners
if (isEV) {
  // Show EV charging icon
  // Filter/sort by charging availability
  // Display charging rates and connector types
  // Show estimated charging time
}

Fuel Types to Check:

Electric - Fully electric vehicles
Plug-in Hybrid - PHEVs requiring charging
Gasoline - Traditional gas vehicles
Diesel - Diesel vehicles
Hybrid - Non-plug-in hybrids

3. Vehicle Type Classification

Challenge: Different parking rates and restrictions for motorcycles, compact cars, SUVs, and commercial vehicles.

Solution: Automatically classify vehicles and apply appropriate pricing/restrictions.

Example Flow

const specs = await carsxe.specs({ vin: userVIN });
 
// Extract vehicle classification
const vehicleType = specs.attributes.type;        // e.g., "Sedan/Saloon", "SUV", "Pickup"
const bodyStyle = specs.attributes.style;         // e.g., "SEDAN 4-DR"
const vehicleClass = specs.attributes.vehicle_class; // "1" (Light), "2" (Medium), etc.
 
// Apply parking rules
let parkingRate;
let restrictions = [];
 
if (vehicleType.includes("Pickup") || vehicleType.includes("SUV")) {
  parkingRate = rates.oversized;
  restrictions.push("Not suitable for compact spaces");
} else if (vehicleType.includes("Sedan") || vehicleType.includes("Hatchback")) {
  parkingRate = rates.standard;
} else if (vehicleType.includes("Motorcycle")) {
  parkingRate = rates.motorcycle;
  restrictions.push("Motorcycle parking only");
}

Vehicle Classification Attributes:

type - General vehicle type (Sedan, SUV, Pickup, Motorcycle, etc.)
style - Body style (SEDAN 4-DR, COUPE 2-DR, etc.)
category - Vehicle category
vehicle_class - Weight class (1=Light, 2=Medium, 3=Heavy)
size - Size classification

4. Weight Restrictions

Challenge: Parking garages often have weight limits for structural safety.

Solution: Check vehicle weight against garage capacity.

Example Flow

const specs = await carsxe.specs({ vin: userVIN });
 
// Extract weight information
const curbWeight = parseDimension(specs.attributes.curb_weight); // "4090 lbs"
const gvwr = specs.attributes.gross_vehicle_weight_rating;
const vehicleRating = specs.attributes.vehicle_rating; // "Light", "Medium", "Heavy"
 
// Check against garage limits
const garageMaxWeight = 6000; // lbs
 
if (curbWeight > garageMaxWeight) {
  // Show warning or exclude location
  return {
    suitable: false,
    reason: `Vehicle weight (${curbWeight} lbs) exceeds garage limit (${garageMaxWeight} lbs)`
  };
}

Implementation Guide

Step 1: Capture Vehicle Information

Parking apps can capture vehicle data in several ways:

Option A: License Plate Entry

javascript

// User manually enters their plate
const plateData = await carsxe.platedecoder({
  plate: "7XER187",
  state: "CA",
  country: "US"
});

// Extract VIN for detailed specs
const vin = plateData.vin;

Option B: VIN Entry

javascript

// User enters VIN directly (e.g., from registration)
const specs = await carsxe.specs({
  vin: "WBAFR7C57CC811956"
});

Option C: User Profile

javascript

// Store vehicle info in user profile on signup
// Retrieve for all future parking searches
const userVehicle = getUserProfile().vehicle;

Step 2: Extract Key Data Points

Based on your parking application's needs, extract relevant attributes:

javascript

const parkingRelevantData = {
  // Dimensions
  length: specs.attributes.overall_length,
  width: specs.attributes.overall_width,
  height: specs.attributes.overall_height,

  // Weight
  weight: specs.attributes.curb_weight,

  // Type
  vehicleType: specs.attributes.type,
  bodyStyle: specs.attributes.style,

  // Fuel
  fuelType: specs.attributes.fuel_type,
  isEV: specs.attributes.fuel_type === "Electric",

  // Capacity
  seating: specs.attributes.standard_seating,

  // Identity
  make: specs.attributes.make,
  model: specs.attributes.model,
  year: specs.attributes.year,

  // Additional
  turningDiameter: specs.attributes.turning_diameter
};

Step 3: Filter & Personalize Results

Use the extracted data to customize the parking experience:

javascript

function filterParkingLocations(spots, vehicleData) {
  return spots.filter(spot => {
    // Check dimensions
    if (spot.maxHeight &&
        parseDimension(vehicleData.height) > spot.maxHeight) {
      return false;
    }

    if (spot.maxLength &&
        parseDimension(vehicleData.length) > spot.maxLength) {
      return false;
    }

    // Check weight
    if (spot.maxWeight &&
        parseDimension(vehicleData.weight) > spot.maxWeight) {
      return false;
    }

    return true;
  }).map(spot => {
    // Add relevance score
    spot.relevanceScore = 0;

    // Boost EV charging spots for EV owners
    if (vehicleData.isEV && spot.hasEVCharging) {
      spot.relevanceScore += 10;
      spot.badges = spot.badges || [];
      spot.badges.push("EV Charging Available");
    }

    // Boost oversized spots for large vehicles
    if (parseDimension(vehicleData.length) > 200 && spot.oversized) {
      spot.relevanceScore += 5;
    }

    return spot;
  }).sort((a, b) => b.relevanceScore - a.relevanceScore);
}

API Reference Quick Guide

Vehicle Plate Decoder API

Endpoint: GET https://api.carsxe.com/platedecoderr

Required Parameters:

key - Your CarsXE API key
plate - License plate number
state - Two-letter state code (for US, CA, AU)
country - Two-letter country code (optional for US)

Example Request:

bash

curl -G https://api.carsxe.com/platedecoderr -d key=YOUR_API_KEY -d plate=7XER187 -d state=CA

Key Response Fields:

vin - Vehicle Identification Number (use for detailed specs)
make - Vehicle manufacturer
model - Vehicle model
year / registration_year - Model/registration year
description - Full vehicle description

Vehicle Specifications API

Endpoint: GET https://api.carsxe.com/specs

Required Parameters:

key - Your CarsXE API key
vin - 17-character Vehicle Identification Number

Optional Parameters:

format - Response format (json or xml)
deepdata - Set to 1 for additional data (slower response)

Example Request:

bash

curl -G https://api.carsxe.com/specs -d key=YOUR_API_KEY -d vin=WBAFR7C57CC811956

Key Response Fields for Parking Apps:

Attribute	Description	Example
`overall_length`	Total vehicle length	"193.10 in."
`overall_width`	Total vehicle width	"73.20 in."
`overall_height`	Total vehicle height	"57.60 in."
`curb_weight`	Vehicle weight without cargo	"4090 lbs"
`fuel_type`	Type of fuel/power	"Electric", "Gasoline"
`type`	Vehicle type	"Sedan/Saloon", "SUV"
`style`	Body style	"SEDAN 4-DR"
`turning_diameter`	Turning circle	"37.50 in."
`wheelbase_length`	Wheelbase length	"116.90 in."

Best Practices

1. Cache Vehicle Data

Store vehicle information in user profiles to avoid repeated API calls:

javascript

// On first lookup
const specs = await carsxe.specs({ vin: userVIN });

// Save to user profile
await saveUserVehicle(userId, {
  vin: userVIN,
  specs: specs.attributes,
  lastUpdated: new Date(),
  cachedUntil: new Date(Date.now() + 90 * 24 * 60 * 60 * 1000) // 90 days
});

// On subsequent searches
const cachedVehicle = await getUserVehicle(userId);
if (cachedVehicle && cachedVehicle.cachedUntil > new Date()) {
  // Use cached data
  return cachedVehicle.specs;
} else {
  // Refresh from API
  return await carsxe.specs({ vin: userVIN });
}

2. Handle Missing Data Gracefully

Not all vehicles will have complete specification data:

javascript

function parseDimension(value) {
  if (!value || value === "") return null;

  // Parse "193.10 in." to 193.10
  const parsed = parseFloat(value);
  return isNaN(parsed) ? null : parsed;
}

function checkDimensions(specs, spot) {
  const height = parseDimension(specs.attributes.overall_height);

  // If we don't have height data, show the spot with a warning
  if (!height && spot.maxHeight) {
    return {
      suitable: "unknown",
      warning: "Unable to verify vehicle height. Please check clearance manually."
    };
  }

  if (height && spot.maxHeight && height > spot.maxHeight) {
    return { suitable: false };
  }

  return { suitable: true };
}

3. Provide Visual Indicators

Help users understand why certain spots are recommended:

javascript

function addParkingBadges(spot, vehicleData) {
  const badges = [];

  if (vehicleData.isEV && spot.hasEVCharging) {
    badges.push({
      icon: "⚡",
      text: "EV Charging",
      type: "success"
    });
  }

  if (vehicleData.length > 200 && spot.oversized) {
    badges.push({
      icon: "🚛",
      text: "Oversized Friendly",
      type: "info"
    });
  }

  if (spot.maxHeight > parseDimension(vehicleData.height) + 12) {
    badges.push({
      icon: "📏",
      text: "Plenty of Clearance",
      type: "success"
    });
  }

  return badges;
}

4. Error Handling

javascript

async function getVehicleSpecs(plateOrVIN, isPlate = true) {
  try {
    if (isPlate) {
      const plateData = await carsxe.platedecoder({
        plate: plateOrVIN.plate,
        state: plateOrVIN.state,
        country: plateOrVIN.country
      });

      if (!plateData.success) {
        throw new Error("Unable to decode license plate");
      }

      if (!plateData.vin) {
        return {
          success: false,
          error: "VIN not available for this plate",
          basicInfo: plateData // Still return basic info
        };
      }

      const specs = await carsxe.specs({ vin: plateData.vin });
      return { success: true, data: specs };
    } else {
      const specs = await carsxe.specs({ vin: plateOrVIN });
      return { success: true, data: specs };
    }
  } catch (error) {
    console.error("Vehicle lookup error:", error);
    return {
      success: false,
      error: error.message,
      // Fallback: proceed with manual vehicle entry
      requiresManualEntry: true
    };
  }
}

International Support

The Plate Decoder API supports license plates from 50+ countries across 6 continents. This enables global parking applications to serve diverse markets:

North America: US, Canada, Mexico, Costa Rica

Europe: UK, Germany, France, Spain, Italy, Netherlands, and 25+ more

Asia: India, China, Singapore, Malaysia, UAE, and more

Oceania: Australia, New Zealand

South America: Brazil, Argentina, Chile, Colombia, and more

Africa: South Africa, Nigeria, Tunisia

See the full country list in the Plate Decoder API documentation.

Pricing & Trial

Free Trial: The Vehicle Specifications API is included in the 7-day free trial, allowing you to test integration before committing.

Plate Decoder API: Not included in the free trial. Visit our pricing page for details.

Production Use: Contact sales for volume pricing and enterprise plans tailored to parking applications.

Next Steps

Sign up for a free API key
Review the Plate Decoder API documentation
Review the Specifications API documentation
Test the integration in your development environment
Contact support@carsxe.com for integration assistance

Example: Complete Parking Search Flow

Here's a complete example showing how a parking app might implement vehicle-aware search:

javascript

import { CarsXE } from "carsxe-api";

const carsxe = new CarsXE("YOUR_API_KEY");

async function searchParking(userInput, parkingLocations) {
  // Step 1: Get vehicle data
  let vehicleData;

  if (userInput.plate) {
    const plateData = await carsxe.platedecoder({
      plate: userInput.plate,
      state: userInput.state,
      country: userInput.country || "US"
    });

    if (plateData.vin) {
      const specs = await carsxe.specs({ vin: plateData.vin });
      vehicleData = extractParkingData(specs.attributes);
    }
  } else if (userInput.vin) {
    const specs = await carsxe.specs({ vin: userInput.vin });
    vehicleData = extractParkingData(specs.attributes);
  }

  // Step 2: Filter locations
  const filteredSpots = parkingLocations.filter(spot => {
    return isVehicleSuitable(vehicleData, spot);
  });

  // Step 3: Rank by relevance
  const rankedSpots = filteredSpots.map(spot => ({
    ...spot,
    relevance: calculateRelevance(vehicleData, spot),
    badges: generateBadges(vehicleData, spot)
  })).sort((a, b) => b.relevance - a.relevance);

  return {
    vehicleData,
    results: rankedSpots,
    filteredCount: parkingLocations.length - filteredSpots.length
  };
}

function extractParkingData(attributes) {
  return {
    length: parseFloat(attributes.overall_length) || null,
    width: parseFloat(attributes.overall_width) || null,
    height: parseFloat(attributes.overall_height) || null,
    weight: parseFloat(attributes.curb_weight) || null,
    isEV: attributes.fuel_type === "Electric",
    isPHEV: attributes.fuel_type === "Plug-in Hybrid",
    type: attributes.type,
    make: attributes.make,
    model: attributes.model,
    year: attributes.year
  };
}

function isVehicleSuitable(vehicle, spot) {
  if (!vehicle) return true; // No vehicle data, show all

  if (spot.maxHeight && vehicle.height && vehicle.height > spot.maxHeight) {
    return false;
  }

  if (spot.maxLength && vehicle.length && vehicle.length > spot.maxLength) {
    return false;
  }

  if (spot.maxWeight && vehicle.weight && vehicle.weight > spot.maxWeight) {
    return false;
  }

  return true;
}

function calculateRelevance(vehicle, spot) {
  let score = 0;

  // EV charging match
  if ((vehicle.isEV || vehicle.isPHEV) && spot.hasEVCharging) {
    score += 20;
  }

  // Comfortable fit (not too tight)
  if (vehicle.height && spot.maxHeight) {
    const clearance = spot.maxHeight - vehicle.height;
    if (clearance > 12) score += 10; // 1 foot+ clearance
  }

  // Covered parking bonus for all
  if (spot.covered) score += 5;

  // Security features
  if (spot.security24_7) score += 5;

  return score;
}

function generateBadges(vehicle, spot) {
  const badges = [];

  if ((vehicle.isEV || vehicle.isPHEV) && spot.hasEVCharging) {
    badges.push({ text: "EV Charging", icon: "⚡", variant: "success" });
  }

  if (vehicle.length > 200 && spot.oversized) {
    badges.push({ text: "Large Vehicle OK", icon: "🚛", variant: "info" });
  }

  return badges;
}

// Usage
const results = await searchParking(
  {
    plate: "7XER187",
    state: "CA"
  },
  allParkingLocations
);

Support

Have questions about integrating CarsXE into your parking application?

Documentation: docs.carsxe.com
Email: support@carsxe.com
API Status: status.carsxe.com

We're here to help you build better parking experiences!

Errors Go Quickstart

CarsXE Developer

CarsXE for Parking Applications

Common Use Cases

1. Size-Based Parking Recommendations

Example Flow

2. EV Charging Station Prioritization

Example Flow

3. Vehicle Type Classification

Example Flow

4. Weight Restrictions

Example Flow

Implementation Guide

Step 1: Capture Vehicle Information

Step 2: Extract Key Data Points

Step 3: Filter & Personalize Results

API Reference Quick Guide

Vehicle Plate Decoder API

Vehicle Specifications API

Best Practices

1. Cache Vehicle Data

2. Handle Missing Data Gracefully

3. Provide Visual Indicators

4. Error Handling

International Support

Pricing & Trial

Next Steps

Example: Complete Parking Search Flow

Support