You need vehicle valuations you can trust for financing flows right now: compute LTV, price collateral, pre-fill offers, and flag outliers before underwriting. By the end of this guide, you’ll call the Estimated Vehicle Market Value API on Zyla API Hub with a single VIN, parse the statistics you need (average, distribution, mileage adjustments), and plug them into your PHP backend—plus see how to query makers and models and invoke the same API from an AI agent via MCP.
What this API does and why it matters for finance
The Estimated Vehicle Market Value API returns market price estimates for a vehicle identified by VIN, including average price, standard deviation, count of comparable listings, a pricing distribution, and mileage-based adjustments. This is exactly the data you need to power finance workflows such as:
- LTV calculations in loan origination and automated pre-approvals.
- Collateral monitoring and portfolio risk scoring.
- Offer management (e.g., buyout quotes, trade-ins) with guardrails based on distribution bands.
- Fraud/outlier detection by comparing requested amounts against market mean and stdev.
The API also exposes endpoints to discover supported makers and their models, which helps with validation when you only have a partial record.
Getting started on Zyla API Hub
Zyla API Hub is a marketplace with more than 10,000 public APIs and a single subscription + quota model across listings, so you use one account and one API key everywhere. To get access:
- Open the Estimated Vehicle Market Value API page.
- Click Subscribe (or Start Free Trial when available). Check the API page for current access options and pricing. The hub uses a subscription + quota model (not pay-per-call). No Free Plan.
- Copy your API key and call endpoints with Authorization: Bearer YOUR_API_KEY.
If you don’t have an account yet, create one here: Register. You’ll use the same credentials across the marketplace and can manage your quotas from your dashboard.
Endpoint reference you will actually use
All endpoints below require the Authorization header with your key and are standard HTTPS GETs served by Zyla API Hub. Use the exact URLs and parameters as shown.
1) Get Vehicle price data
Method: GET
URL: https://zylalabs.com/api/3623/estimated-vehicle-market-value-api/4058/get-vehicle-price-data
Description: Provide a VIN and receive estimated market value stats and distribution.
Required query parameter:
- vin (string): the vehicle VIN. Example: 3FMTK3SU3NMA08229
Official curl:
curl -s -X GET "https://zylalabs.com/api/3623/estimated-vehicle-market-value-api/4058/get-vehicle-price-data?vin=3FMTK3SU3NMA08229" \
-H "Authorization: Bearer YOUR_API_KEY"Official JSON sample response:
{
"status": true,
"code": 200,
"data": {
"vin": "4T1DAACK7SU510354",
"success": true,
"id": "2025_toyota_camry_",
"vehicle": "2025 Toyota Camry ",
"mean": 34959.82,
"stdev": 3109,
"count": 26,
"mileage": 10166,
"certainty": 95,
"period": [
"2024-05-16",
"2024-07-26"
],
"prices": {
"average": 34959.82,
"below": 31849.83,
"above": 38069.81,
"distribution": [
{
"group": {
"min": 30867,
"max": 31428,
"count": 3
}
},
{
"group": {
"min": 31428,
"max": 32494,
"count": 3
}
},
{
"group": {
"min": 32494,
"max": 32603,
"count": 2
}
},
{
"group": {
"min": 32603,
"max": 32988,
"count": 3
}
},
{
"group": {
"min": 32988,
"max": 34189,
"count": 3
}
},
{
"group": {
"min": 34189,
"max": 34497,
"count": 2
}
},
{
"group": {
"min": 34497,
"max": 36988,
"count": 3
}
},
{
"group": {
"min": 36988,
"max": 38216,
"count": 2
}
},
{
"group": {
"min": 38216,
"max": 39842,
"count": 3
}
},
{
"group": {
"min": 39842,
"max": 41392,
"count": 2
}
}
]
},
"adjustments": {
"mileage": {
"average": 12015.69,
"input": 10166,
"adjustment": 80
}
}
},
"message": "Data Fetched Successfully!"
}What to use in finance flows:
- data.prices.average: baseline for collateral value and LTV.
- data.stdev and data.prices.distribution: set risk buffers and outlier thresholds.
- data.count: confidence proxy (how many comparable listings are behind the estimate).
- data.adjustments.mileage.adjustment: reconcile specific mileage with the market’s average mileage.
- data.period: time window of the market data used. Dates are in ISO format; no timezone is specified in the sample.
Currency is not specified in the sample response. Treat numeric values as unit-less amounts and align currency handling with your product’s locale or the API page notes. Avoid assumptions; when in doubt, log and display units clearly to internal users.
2) Get Makers
Method: GET
URL: https://zylalabs.com/api/3623/estimated-vehicle-market-value-api/4059/get-makers
Description: Retrieve all supported vehicle makers.
No request parameters are documented for this endpoint. Only send the Authorization header.
Official curl:
3) Get Models
Method: GET
URL: https://zylalabs.com/api/3623/estimated-vehicle-market-value-api/4060/get-models
Description: Retrieve all models related to a specific maker.
Required query parameter:
- maker (string): maker name. Example: audi
Official curl:
PHP integration: fetch market value by VIN and compute LTV
The following PHP snippet calls the “Get Vehicle price data” endpoint, handles errors, and uses the mean price to compute a basic Loan-to-Value ratio. You can drop this into a controller or a job step in your financing pipeline.
<?php
$apiKey = 'YOUR_API_KEY';
$vin = '3FMTK3SU3NMA08229'; // Example VIN from docs
$url = 'https://zylalabs.com/api/3623/estimated-vehicle-market-value-api/4058/get-vehicle-price-data?vin=' . urlencode($vin);
$ch = curl_init($url);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
'Authorization: Bearer ' . $apiKey
]);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
$response = curl_exec($ch);
$httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
$curlErr = curl_error($ch);
curl_close($ch);
if ($curlErr) {
throw new RuntimeException('cURL error: ' . $curlErr);
}
if ($httpCode < 200 || $httpCode >= 300) {
throw new RuntimeException('HTTP error code: ' . $httpCode . ' body=' . $response);
}
$payload = json_decode($response, true);
if (!isset($payload['status']) || $payload['status'] !== true) {
throw new RuntimeException('API status not OK: ' . $response);
}
// Extract fields you actually need
$data = $payload['data'] ?? [];
$mean = $data['mean'] ?? null;
$stdev = $data['stdev'] ?? null;
$count = $data['count'] ?? null;
$mileageAdj = $data['adjustments']['mileage']['adjustment'] ?? 0;
// Example: compute a conservative collateral value by applying a buffer (e.g., -0.5 stdev)
$bufferedValue = null;
if (is_numeric($mean) && is_numeric($stdev)) {
$bufferedValue = $mean - 0.5 * $stdev + $mileageAdj;
}
// Example LTV: requested_loan / bufferedValue
$requestedLoan = 25000.00;
$ltv = null;
if ($bufferedValue && $bufferedValue > 0) {
$ltv = $requestedLoan / $bufferedValue;
}
// Output or store results
$result = [
'vin' => $data['vin'] ?? $vin,
'vehicle' => $data['vehicle'] ?? null,
'mean' => $mean,
'stdev' => $stdev,
'count' => $count,
'mileage_adjustment' => $mileageAdj,
'buffered_value' => $bufferedValue,
'requested_loan' => $requestedLoan,
'ltv' => $ltv
];
header('Content-Type: application/json');
echo json_encode($result, JSON_PRETTY_PRINT);
JavaScript example (Node.js or modern runtimes)
This example calls the same endpoint using fetch and logs key fields used in financing logic.
import fetch from 'node-fetch';
const API_KEY = 'YOUR_API_KEY';
const VIN = '3FMTK3SU3NMA08229';
const url = `https://zylalabs.com/api/3623/estimated-vehicle-market-value-api/4058/get-vehicle-price-data?vin=${encodeURIComponent(VIN)}`;
const res = await fetch(url, {
method: 'GET',
headers: {
'Authorization': `Bearer ${API_KEY}`
}
});
if (!res.ok) {
const text = await res.text();
throw new Error(`HTTP ${res.status} - ${text}`);
}
const payload = await res.json();
if (!payload.status) {
throw new Error('API reported non-success status');
}
const data = payload.data || {};
const mean = data.mean;
const stdev = data.stdev;
const count = data.count;
const avgMileage = data.adjustments?.mileage?.average;
const inputMileage = data.adjustments?.mileage?.input;
const mileageAdj = data.adjustments?.mileage?.adjustment;
console.log({
vin: data.vin,
vehicle: data.vehicle,
mean,
stdev,
count,
period: data.period,
averagePrice: data.prices?.average,
lowBand: data.prices?.below,
highBand: data.prices?.above,
distributionBuckets: data.prices?.distribution?.length,
mileage: { avgMileage, inputMileage, mileageAdj }
});
Using makers and models to validate inputs
When you don’t have a VIN but still want to pre-validate a customer submission (e.g., make/model dropdowns in a financing form), use the discovery endpoints.
- Get Makers: returns supported makers. No parameters are documented; call with only the Authorization header.
- Get Models: requires maker. For example: maker=audi.
These lightweight calls help you reduce invalid inputs before you attempt valuation and minimize noisy underwriting logs.
Operational details that save you time
- Authentication: every request uses Authorization: Bearer YOUR_API_KEY.
- HTTP semantics: all documented endpoints are GET. Treat them as idempotent and safe; you can retry on transient failures.
- Quotas and billing: Zyla API Hub uses subscription + quota, not pay-per-call. Check the API page for current access options and pricing. For first-time usage on the hub, you’ll typically see a 7-day trial or 50 requests available to get started; confirm on the listing.
- Caching: VIN valuations are not generally real-time like quotes; consider caching by VIN for a reasonable period. The response includes a period array indicating the market data window that informed the estimate.
- Currency and units: the sample shows numeric price values without an explicit currency; keep your internal representations currency-aware and surface units clearly in any UI. Mileage values are numeric; do not assume a unit unless confirmed in your product specs.
- Error handling: inspect HTTP status codes and the top-level "status" boolean. Log the "message" for observability when present.
- Distribution buckets: these support percentile-based underwriting (e.g., require requested loan not to exceed the high band or the 75th percentile). Buckets are provided as min/max ranges with counts.
Ship a financing workflow with the response fields
Here’s a practical LTV gate you can implement immediately using fields from the valuation endpoint:
- Call Get Vehicle price data with the applicant’s VIN.
- Compute a conservative collateral value using prices.average minus a fraction of stdev, plus mileage adjustment if present.
- Calculate LTV = requested_loan / conservative_value.
- Auto-approve if LTV is below your threshold; otherwise route to manual review and display distribution buckets so an analyst can judge outliers.
The presence of count and certainty helps you decide whether the sample size or confidence warrants further investigation before issuing credit.
Call the API from AI agents via MCP
If you use MCP-compatible tools (Claude Code, Cursor, Windsurf, etc.), you can let an agent access this API without wiring bespoke HTTP code. Point your client to the MCP endpoint at MCP using your Zyla API key (https://mcp.zylalabs.com/mcp?apikey=YOUR_API_KEY). Within an MCP session, use the provided tools to discover the listing (e.g., via a get_api_info tool referencing listing id 3623) and then invoke the target operation (e.g., call_api for the Get Vehicle price data endpoint id 4058 with the vin parameter). This keeps the agent’s runtime stateless and lets you reuse the same Zyla credentials across tasks.
Testing checklist
- Use the official curl once to validate your Authorization header and network path.
- Log the raw JSON during development to verify fields before mapping to domain objects.
- Ensure your financing math handles null or missing fields gracefully (e.g., if adjustments are absent).
- Cache per VIN to reduce repeated calls in the same underwriting session.
- Always record the period array alongside the valuation stored in your decision record.
Useful links
- Estimated Vehicle Market Value API on Zyla API Hub
- Zyla API Hub — explore more than 10,000 public APIs with a single account and key
FAQ
1) What’s the minimum I need to call the valuation endpoint?
Just the VIN as a query parameter and the Authorization: Bearer YOUR_API_KEY header.
2) Can I look up makers and models without a VIN?
Yes. Use Get Makers (no documented parameters) and Get Models with maker query parameter (e.g., maker=audi) to build or validate form inputs.
3) How should I interpret prices.average vs. mean?
In the sample, prices.average and mean share the same numeric value. Use mean for core math and combine with stdev and distribution to implement conservative buffers for financing decisions.
4) Are the price values tied to a currency?
The sample response does not specify currency. Treat them as numeric amounts and align with your system’s currency context. For customer-facing outputs, clearly label currency per your product specs.
5) What are the access and billing basics?
Zyla API Hub uses a subscription + quota model (not pay-per-call). For first-time hub usage, you’ll typically see a 7-day trial or 50 requests to start; always check the API page for current access options and pricing. No Free Plan.
Ready to wire this into your underwriting stack? Create your account, get an API key, and ship the integration: Register. You can explore and subscribe to the Estimated Vehicle Market Value API and keep expanding with other listings on Zyla API Hub using the same key.
