auto-data APIauto-data.net ↗
Access specs for 53,500+ cars via the auto-data.net API. Browse brands, models, generations, and variants to retrieve engine, performance, and dimension data.
What is the auto-data API?
The auto-data.net API provides structured access to technical specifications for over 53,500 automobiles across 376+ brands through 6 endpoints. Starting with list_brands, you can traverse the full hierarchy — brands to models to generations to variants — and retrieve detailed spec sheets covering engine output, dimensions, drivetrain configuration, and performance figures for any specific car variant.
No input parameters required.
curl -X GET 'https://api.parse.bot/scraper/a203509b-10c5-4784-8bd6-00bd8f4608db/list_brands' \ -H 'X-API-Key: $PARSE_API_KEY'
Typed, relational, agent-ready
A generated client with real types, enums, and the links between objects — the structure a flat JSON response can't carry. Autocompletes in your editor and reads cleanly to coding agents.
- Fully typed · autocompletes
- Objects link to objects
- Typed errors & pagination
Typed Python client. Set up the SDK in your uv project, then pull this API’s typed client:
uv add parse-sdk uv run parse init uv run parse add --marketplace auto-data-net-api
uv run parse add --marketplace pulls a pinned snapshot of this canonical API — it won’t change underneath you. To customize it, subscribe and swap to your own copy.
"""Auto-Data.net: browse car hierarchy and fetch specifications."""
from parse_apis.auto_data.net_car_specifications_api import (
AutoData, ResultType, BrandNotFound
)
client = AutoData()
# Search for a car by keyword — capped at 5 results.
for result in client.searchresults.search(query="Toyota Corolla", limit=5):
print(result.name, result.type, result.slug)
# Navigate the hierarchy: list brands, pick one, drill into models.
brand = client.brands.list(limit=1).first()
if brand:
print(brand.name, brand.slug)
for model in brand.models.list(limit=3):
print(model.name, model.years, model.slug)
# Construct a known brand and walk generations → variants → specs.
bmw = client.brand(slug="bmw-brand-86")
model = bmw.models.list(limit=1).first()
if model:
gen = model.generations.list(limit=1).first()
if gen:
print(gen.name, gen.image_url)
variant = gen.variants.list(limit=1).first()
if variant:
spec = variant.specifications()
print(spec.title, spec.image_url)
for section, entries in spec.specifications.items():
print(section, len(entries), "specs")
# Typed error handling: catch a bad brand lookup.
try:
bad = client.brand(slug="nonexistent-brand-0")
for m in bad.models.list(limit=1):
print(m.name)
except BrandNotFound as exc:
print(f"Brand not found: {exc.brand_slug}")
print("exercised: search / brands.list / models.list / generations.list / variants.list / specifications")
List all car brands available in the database (376+ brands). Returns brand names, slugs, and URL paths. Each brand slug can be passed to get_models to retrieve that brand's model lineup.
No input parameters required.
{
"type": "object",
"fields": {
"total": "integer count of brands returned",
"brands": "array of brand objects with name, slug, url_path"
},
"sample": {
"data": {
"total": 384,
"brands": [
{
"name": "BMW",
"slug": "bmw-brand-86",
"url_path": "/en/bmw-brand-86"
},
{
"name": "Toyota",
"slug": "toyota-brand-40",
"url_path": "/en/toyota-brand-40"
}
]
},
"status": "success"
}
}About the auto-data API
Navigating the Hierarchy
The API is organized as a four-level hierarchy. list_brands returns every brand in the database with its name, slug, and URL path — the slug feeds directly into get_models. get_models accepts a brand_slug (e.g., toyota-brand-40) and returns model names, production year ranges, and per-model slugs. get_generations takes a model_slug and returns each generation with its name, slug, and a thumbnail image URL. get_variants accepts a generation_slug and returns every trim and engine configuration available for that generation, including production year spans.
Specification Detail
get_specifications is where the technical data lives. Pass a variant_slug (e.g., mini-electric-cooper-se-f56-facelift-2021-32.6-kwh-184hp-44617) and the response includes a title, an image_url, a key_specs object mapping FAQ-style questions to concise answers, and a specifications object whose keys are section names (such as performance, engine, dimensions, drivetrain, weight) mapping to name/value pairs. Spec sections vary by vehicle type, so an EV and an ICE car will expose different fields. Note that some spec values are gated behind a logged-in account on the source site and may be absent in the response.
Search and Discovery
search accepts a free-text query (e.g., BMW 3, Toyota Corolla) and returns up to 30 results. Each result includes a name, a type field classifying it as a brand, model, generation, or variant, a slug, a url_path, and an image_url. The type field tells you which downstream endpoint to call with the returned slug — making it straightforward to jump directly to a known car without walking the full hierarchy.
The auto-data API is a managed, monitored endpoint for auto-data.net — not a raw scraper you maintain. Every endpoint is automatically health-checked on a schedule, and when auto-data.net changes and a check fails, the API is automatically queued for repair and re-verified. It is built to keep working as the site underneath it changes.
This isn't an official auto-data.net API — it's an independent, maintained REST wrapper over public data. Where the source has no official API (or only a limited one), Parse gives you a stable contract over a source that never promised one, and keeps it current. Need a new endpoint or field? You can revise it yourself in plain English and the agent rebuilds it against the live site in minutes — contributing the change back to the shared API is free.
Will this API break when the source site changes?+
Is this an official API from the source site?+
Can I fix or extend this API myself if I need a new endpoint or field?+
What happens if I call an endpoint that has an issue?+
- Build a car comparison tool that pulls
specificationssections for two variants side by side using their slugs. - Populate a vehicle database by iterating
list_brands→get_models→get_generations→get_variantsto catalog the full inventory. - Auto-fill a configurator form by resolving a user's text query through
searchand fetching matching variant specs. - Generate spec sheets for a dealership CMS by calling
get_specificationsfor each stocked model's variant slug. - Feed an automotive research tool with engine displacement, horsepower, and torque values from the
specificationsresponse. - Display thumbnail images and generation timelines on a model history page using
get_generationsresponse fields. - Validate user-submitted vehicle data against canonical specs retrieved from
get_specificationsfor a given variant.
| Tier | Price | Credits/month | Rate limit |
|---|---|---|---|
| Free | $0/mo | 100 | 5 req/min |
| Hobby | $30/mo | 1,000 | 20 req/min |
| Developer | $100/mo | 5,000 | 100 req/min |
One credit = one API call regardless of which marketplace API you call. Exceeding the rate limit returns a 429 response. Authenticate with the X-API-Key header.
Does auto-data.net have an official developer API?+
What does get_specifications actually return, and are all fields always present?+
title, an image_url (or null), a key_specs object with short answers to common questions about the variant, and a specifications object broken into named sections such as performance, engine, dimensions, and drivetrain. The exact sections and fields vary by vehicle type. Some spec values that require a logged-in session on the source site may be missing from the response.Does the search endpoint return full specifications directly?+
search returns up to 30 matching results with name, type, slug, url_path, and image_url fields. The type field (brand, model, generation, or variant) tells you which endpoint to call next with the slug to retrieve further data. Full specs require a separate call to get_specifications with a variant slug.Does the API expose historical pricing, owner reviews, or recall data for vehicles?+
Does the API support filtering variants by fuel type, transmission, or body style directly?+
get_variants returns all variants for a given generation, and filtering by attributes like fuel type or transmission requires inspecting the returned variant names or fetching individual specs. The API covers the full variant list per generation. You can fork it on Parse and revise to add server-side filtering logic over the returned variant data.