On-device car recognition · v5.13.0
Know every car on the road — from one photo.
AutoVision is a vehicle make and model recognition engine that goes one level deeper: generation. Not just “BMW 3 Series,” but “E90 (2005–2011)” vs “F30 (2012–2018).” Ship it inside your app with the on-device SDK, or run it as a self-hosted car recognition API. No cloud dependency, no per-photo bill shock.
*93.85% top-1 on a clean held-out validation set — real-world street photos score lower.
BMW 3 Series F30
2012–2018 · rarity COMMON
rejection_reason: not_a_car
Candidates still returned for inspection. Reasons: not_a_car · low_confidence · ambiguous
Stylized illustration of the response contract — not a screenshot.
Capabilities
Built for production, not demos
Every design decision assumes your users will point it at things that aren't cars, in bad light, at weird angles — and that your legal team will read the license.
Generation-level identification
Distinguishes facelifts and redesigns across 896 model-generation classes, each with production year ranges and a six-tier rarity tag.
Runs entirely on-device
44 MB FP16 model, <50 ms with the Android GPU delegate, Core ML on iOS. Photos never leave the device — a privacy story you can put in writing.
Rejection is a first-class answer
Non-car photos, low-confidence calls, and known confusion pairs are explicitly rejected with a machine-readable reason — the engine tells you when not to trust it.
Calibrated confidence
ECE 0.049 — confidence scores behave like probabilities, so your thresholds mean what you think they mean.
Versioned inference contract
Every response carries engine, model, and taxonomy versions. Python SDK, Android SDK, and REST API return the same logical shape.
Source-available
SDKs, API server, class list, and model card are public. Evaluate everything — accuracy claims included — before paying anything.
Quickstart
A car identification SDK you can wire up before lunch
Grab the weights from the v5.13.0 release, point the SDK at the folder, classify. Rejection is part of the return type, not an exception you discover in production.
# pip install, point at the release folder, classify
from autovision import AutoVision
engine = AutoVision("models/v5.13.0")
result = engine.classify("photo.jpg", top_k=5)
if result.rejected:
print(result.rejection_reason) # not_a_car | low_confidence | ambiguous
else:
car = result.top1
print(f"{car.make} {car.model} ({car.year_start}–{car.year_end}) {car.confidence:.0%}")On-device SDK
Android (TFLite FP16 + GPU delegate), iOS (Core ML), Python. Offline, <50 ms, images stay on the phone.
Self-hosted API
Docker + FastAPI on your own infrastructure. Same response contract over HTTP, for web apps and batch pipelines.
Read before you buy
The model card documents evaluation, known issues, and limits — the sales pitch and the caveats in one place.
Use cases
Where a car recognition API can be put to work
In production today in Boby's Garage, the car-spotting app this engine was built for. The usecases/ folder illustrates further possible integrations — five example Python scripts plus an Android pattern in Kotlin.
Parking & ANPR/ALPR enrichment
Plate registered to a Golf, camera sees an SUV — catch cloned plates by cross-checking vehicle make and model against the plate read.
Dealer & auction inventory
Batch-tag photo sets with make, model, generation, and year range; route low-confidence shots to human review.
Marketplace listing autofill
Pre-fill listing forms from the seller's photos and flag listings whose photos don't match the claimed vehicle.
Enthusiast & consumer apps
Offline car-spotting with rarity-tier gamification — the engine behind a live car-spotting app on both app stores.
Honest limits
What it won't do
We'd rather you find out here than in production:
- Closed taxonomy — a car outside the 896 covered classes gets mapped to its nearest covered lookalike or rejected; it can't say "unknown model X".
- No trim/engine detection, no color, damage, license plate, or VIN reading.
- Assumes one dominant vehicle per photo — it's a classifier, not a detector or counter.
- Degraded on interiors, heavy occlusion, night shots, renders and toys. No motorcycles, trucks, or buses.
- *93.85% top-1 is on a clean held-out validation set — real-world street photos score lower, and thresholds are tuned to prefer rejection over wrong answers.
Full details, known issues, and responsible-use guidance: the model card.
Model card
The numbers, as measured
Everything below is from the published model card for v5.13.0 — measured, not marketed. Weights, class mapping, and checksums ship in the GitHub release.
| Metric | Value | Notes |
|---|---|---|
| Top-1 accuracy | 93.85%* | Clean held-out validation set — real-world street photos score lower |
| Top-5 accuracy | 97.88% | Same validation set |
| Calibration (ECE) | 0.049 | Confidence scores usable as approximate probabilities |
| Latency | <50 ms | On-device, modern Android phones with GPU delegate |
| Model size | 44 MB | TFLite FP16 (primary); Core ML for iOS, ONNX for server |
| Coverage | 896 / 76 | Model-generation classes / makes, plus a background non-car class |
| Rejection reasons | not_a_car · low_confidence · ambiguous | Machine-readable; top1 is null when rejected |
Pricing
Published pricing — an industry first for generation-level recognition
Free for personal, research, and noncommercial use under the PolyForm Noncommercial License. Commercial use is licensed below — every competitor makes you email sales to learn a number; here it is up front. Annual billing gets 2 months free.
Evaluation
Free · 30 daysFull commercial evaluation, non-production. No registration — just tell us you're evaluating.
Starter
$99/mo
- One production instance of the Docker API
- Up to 100k images/month
- Email support
Business
$299/mo
- Up to 3 instances
- 500k images/month
- Priority support
- Upgrade help on new model releases
Indie
$1,990/yr
- One app (Android and/or iOS)
- Unlimited devices
- For companies under $1M annual revenue
Standard
$4,990/yr
- One app, unlimited devices
- No revenue cap
- Priority support
- Day-one model releases
Enterprise / OEM
CustomAir-gapped deployment, OEM/redistribution rights, custom classes, white-label, SLAs.
FAQ
Questions engineers actually ask
Short answers here; long answers in the model card and commercial terms.
Can I use AutoVision commercially, and what does the dual license mean?
What happens to my license if AutoVision shuts down?
How accurate is it on real-world photos?
What happens with cars outside the 896 covered classes?
class_mapping.json in the release before integrating.Does it run on iOS?
Where do my photos go?
Get started
Evaluate it against your own photos.
The weights, the SDKs, and the model card are all public. If the numbers hold up on your image distribution, the price is already on this page.