facile APIfacile.it ↗
Resolve any Italian car licence plate to make, model, registration date, and full trim list via the facile.it car-insurance quote form API.
What is the facile API?
The facile.it API exposes 1 endpoint — lookup_vehicle_by_plate — that accepts an Italian licence plate and returns up to 10 structured fields identifying the corresponding vehicle: registration date, make, model, the preselected trim, and the complete list of compatible trims for that model. It is useful wherever downstream logic depends on knowing the exact vehicle specification tied to a plate.
curl -X GET 'https://api.parse.bot/scraper/0eb80601-042e-4dbc-bb22-cf3b02be96a8/lookup_vehicle_by_plate?plate=EX456CD' \ -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 facile-it-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.
"""Walkthrough: look up an Italian plate on facile.it and inspect the vehicle."""
from parse_apis.facile_it_api import FacileIt, InputFormatInvalid
client = FacileIt()
# Look up a plate — the site takes ~35-45 s per call.
try:
result = client.plates.get(plate="EX456CD")
except InputFormatInvalid:
print("Plate format rejected — must be two letters, three digits, two letters.")
raise
print(f"Plate: {result.plate}, Found: {result.found}")
if result.vehicle is not None:
v = result.vehicle
print(f"Make: {v.make}, Model: {v.model}")
print(f"Registered: {v.registration_date}")
print(f"Preselected trim: {v.equipment.name} (code {v.equipment.code})")
print(f"Compatible trim codes: {v.available_equipment_codes}")
# Browse all trims the site lists for this model.
for eq in result.model_equipments:
tag = "✓" if eq.matches_plate else " "
print(f" [{tag}] {eq.name} eco={eq.is_eco} range={eq.value_range}")
print("exercised: plates.get / Vehicle / Equipment fields")
Looks up an Italian car licence plate on the facile.it car-insurance quote form and returns the vehicle the site identifies for it: registration date, make, model, the trim (equipment) the site preselects, and the codes of the trims compatible with that plate. It also returns the full trim list for the identified model (model_equipments), each flagged with matches_plate when the plate's registration record allows it. One result object per call; plates the site does not recognise return found=false with vehicle=null and an empty model_equipments list (a valid, non-error result). The lookup is for cars only (motorbike and commercial-vehicle plates are not supported). Expect a slow call: the site makes every plate lookup wait roughly 30 seconds before answering, so a typical call takes 35-45 seconds. A plate that is not two letters, three digits, two letters (e.g. one shape: AB123CD) is rejected before any request.
| Param | Type | Description |
|---|---|---|
| platerequired | string | Italian car licence plate, two letters + three digits + two letters; spaces are stripped and letters upper-cased before lookup. |
{
"type": "object",
"fields": {
"found": "boolean, false when the site has no vehicle for the plate",
"plate": "normalised plate that was looked up",
"vehicle": "identified vehicle object (null when found=false): plate, registration_date (ISO YYYY-MM-DD), make_code, make, model_code, model, equipment (the preselected trim: code, name, is_eco, supports_additional_fuel, value_range, youngest_driver_restriction), available_equipment_codes (trim codes compatible with the plate)",
"model_equipments": "array of every trim the site lists for the identified model, same trim fields as vehicle.equipment plus matches_plate (true when the code is in available_equipment_codes); empty when found=false"
},
"sample": {
"data": {
"found": true,
"plate": "EX456CD",
"vehicle": {
"make": "TOYOTA",
"model": "RAV4 4ª serie",
"plate": "EX456CD",
"equipment": {
"code": "098639",
"name": "RAV4 2.2 D-4D 4WD Style",
"is_eco": false,
"value_range": "high",
"supports_additional_fuel": false,
"youngest_driver_restriction": "over18"
},
"make_code": "000103",
"model_code": "004182",
"registration_date": "2014-10-03",
"available_equipment_codes": [
"098638",
"098639",
"098640"
]
},
"model_equipments": [
{
"code": "098638",
"name": "RAV4 2.2 D-4D 4WD Active",
"is_eco": false,
"value_range": "high",
"matches_plate": true,
"supports_additional_fuel": false,
"youngest_driver_restriction": "over18"
},
{
"code": "112041",
"name": "RAV4 2.5 Hybrid 2WD Active",
"is_eco": true,
"value_range": "high",
"matches_plate": false,
"supports_additional_fuel": false,
"youngest_driver_restriction": "over18"
}
]
},
"status": "success"
}
}About the facile API
What the API returns
The single endpoint, lookup_vehicle_by_plate, accepts a plate string in standard Italian format (two letters, three digits, two letters — spaces stripped, letters uppercased automatically). The response contains a found boolean and, when true, a vehicle object with plate, registration_date (ISO 8601 YYYY-MM-DD), make_code, make, model_code, model, and the trim the source preselects for that plate.
Trim list
Alongside the identified vehicle, the response includes a model_equipments array covering every trim facile.it lists for that model. Each entry carries the same trim fields as vehicle.equipment, plus a matches_plate boolean that flags which trim(s) are considered compatible with the specific plate being queried. This makes it straightforward to build a picker that highlights the recommended trim while still presenting alternatives.
Failure handling
When facile.it has no record for a submitted plate, the response returns found: false and vehicle: null. No exception is thrown; consumers can branch on the boolean without extra error handling. Plates that cannot be parsed are normalised before the lookup, so minor formatting inconsistencies (lowercase letters, embedded spaces) do not cause spurious failures.
The facile API is a managed, monitored endpoint for facile.it — not a raw scraper you maintain. Every endpoint is automatically health-checked on a schedule, and when facile.it 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 facile.it 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?+
- Pre-fill car insurance quote forms by resolving a customer's plate to make, model, and trim.
- Validate that a licence plate corresponds to a known Italian vehicle before processing an application.
- Build a trim selector UI seeded with the full
model_equipmentslist from the API response. - Enrich fleet-management records with structured vehicle metadata from a plate scan.
- Flag plate-to-trim mismatches using the
matches_plateboolean in the equipment array. - Cross-check vehicle registration dates against warranty or lease expiry calculations.
- Power automotive lead-generation forms that need instant plate-to-vehicle resolution.
| Tier | Price | Credits/month | Rate limit |
|---|---|---|---|
| Free | $0/mo | 200 | 5 req/min |
| Hobby | $30/mo | 1,000 | 20 req/min |
| Developer | $100/mo | 5,000 | 100 req/min |
| Team | $300/mo | 20,000 | 300 req/min |
| Company | $1,000/mo | 100,000 | 500 req/min |
Each endpoint has a fixed posted price per successful call — most fall between 1 and 10 credits — shown on this API's page before you run it. Exceeding the rate limit returns a 429 response. Authenticate with the X-API-Key header.
Does facile.it offer an official developer API?+
What exactly does `lookup_vehicle_by_plate` return for a valid plate?+
vehicle object with registration_date, make_code, make, model_code, model, and the preselected trim, plus a model_equipments array listing every trim available for that model. Each trim entry includes a matches_plate boolean indicating whether it is compatible with the queried plate.Does the API cover motorcycles, vans, or other vehicle categories beyond passenger cars?+
Can I retrieve historical plates or plates from vehicles no longer registered?+
found: false with vehicle: null. Historical plate archives are not covered. You can fork this API on Parse and revise it to incorporate additional vehicle history sources.