Cercassicurazioni APIcercassicurazioni.it ↗
Resolve Italian licence plates to vehicle brand, model, registration date, and trim variants via the cercassicurazioni.it insurance quote system.
What is the Cercassicurazioni API?
The Cercassicurazioni.it API exposes 1 endpoint, get_vehicle_by_plate, returning 10 structured fields per lookup: brand, model, registration date, vehicle type, site identifiers, and the full list of trim/setup variants (allestimenti) the Italian insurance platform associates with a given licence plate. It is useful anywhere an Italian plate needs to be resolved to a verified vehicle record without manual form submission.
curl -X GET 'https://api.parse.bot/scraper/8012334f-db41-4b7b-b574-63bbf4a3c337/get_vehicle_by_plate?plate=FL123AB' \ -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 cercassicurazioni-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 vehicle by licence plate and inspect its trims."""
from parse_apis.cercassicurazioni_it_api import CercAssicurazioni, InvalidPlateFormat
client = CercAssicurazioni()
# Look up a vehicle by its Italian licence plate.
try:
vehicle = client.vehicles.get(plate="FL123AB")
except InvalidPlateFormat as e:
print("Bad plate format:", e.message)
raise
print(vehicle.plate, vehicle.brand, vehicle.model)
print("Registered:", vehicle.registration_date, "| Type:", vehicle.vehicle_type)
# Walk the available trim/setup variants the site offers for this model.
if vehicle.setups:
for setup in vehicle.setups:
print(f" trim: {setup.name} (code {setup.setup_code})")
print("exercised: vehicles.get")
Looks up an Italian licence plate and returns the vehicle the site resolves for it: brand, model, registration month, and the list of trim/setup variants (allestimenti) the site offers for that model, each with its site identifier. Two upstream round trips per call. The site renders brand, model, year and setup names as images; those are decoded into text by the scraper, so an unrecognised character is emitted as '?'. When the plate is unknown to the site, `found` is false and every vehicle field is null with an empty `setups` list (a valid, non-error result). `verification_level` is the site's own raw confidence indicator for the plate data (observed values '1' and '4'); `suggested_purchase_year` and `suggested_registration_month` are the values the site pre-fills in its quote form for this plate and may differ from `registration_date`. A setup `name` is null when the site provides no label for it. A plate that is not 5-8 letters/digits (spaces and dashes are stripped, case-insensitive) is rejected with a 422 stale_input.
| Param | Type | Description |
|---|---|---|
| platerequired | string | Italian vehicle licence plate, letters and digits only (spaces/dashes are ignored, case-insensitive), e.g. AB123CD. |
{
"type": "object",
"fields": {
"brand": "brand name decoded from the site's image; null when not found",
"found": "boolean, true when the site resolved a vehicle for the plate",
"model": "model name decoded from the site's image; null when not found",
"plate": "normalised plate (uppercase, no spaces) that was looked up",
"setups": "array of {setup_code, name}: trim/setup variants the site offers for this model; name is null when the site gives no label; empty when not found",
"brand_code": "site brand identifier for this vehicle; null when not found",
"model_code": "site model identifier for this vehicle; null when not found",
"vehicle_type": "site vehicle category code, e.g. CAR; null when not found",
"registration_date": "first registration month as YYYY-MM; null when not found",
"registration_year": "first registration year as text decoded from the site's image; null when not found",
"verification_level": "site's raw confidence indicator for the plate data; null when not found",
"suggested_purchase_year": "purchase year the site pre-fills for this plate (YYYY); null when not found",
"suggested_registration_month": "registration month the site pre-fills in its form (YYYY-MM); null when not found"
},
"sample": {
"data": {
"brand": "Volkswagen",
"found": true,
"model": "up!",
"plate": "FL123AB",
"setups": [
{
"name": "1.0 3p. eco take up! BlueMotion Technology",
"setup_code": "cDJfUU4xcUxWcHBZdlhMcVhIYWN4OGxCUSUzRCUzRA=="
},
{
"name": "1.0 3p. eco high up! BlueMotion Technology",
"setup_code": "cDJfanFkOTFlMXFFT2pVVUdBTWN6OE9QUSUzRCUzRA=="
}
],
"brand_code": "cDJfaFpvJTJCR0Q0OUczQTBTbXI3dlZ6MGt3JTNEJTNE",
"model_code": "cDJfbXZXWHB1WVkzRkRiMG5seWthRUZsUSUzRCUzRA==",
"vehicle_type": "CAR",
"registration_date": "2017-10",
"registration_year": "2017",
"verification_level": "4",
"suggested_purchase_year": "2017",
"suggested_registration_month": "2017-11"
},
"status": "success"
}
}About the Cercassicurazioni API
What the API Returns
The single endpoint get_vehicle_by_plate accepts an Italian licence plate via the required plate parameter (letters and digits only; spaces, dashes, and case are normalised automatically) and returns a structured record. Core identity fields include brand, model, vehicle_type, and the boolean found which tells you immediately whether the source resolved anything for that plate. When a vehicle is found, registration_date gives the first registration month as YYYY-MM and registration_year gives the year as decoded text.
Trim/Setup Variants
Beyond the vehicle identity, the response includes setups: an array of objects each carrying a setup_code (the site's internal identifier for that variant) and a name label. These correspond to the allestimento options the insurance quote form presents for the resolved model. The array is empty when no variants are offered, and individual name fields may be null when the site provides no label for a code. The brand_code and model_code fields expose the site's own identifiers for the brand and model, which can be useful for cross-referencing across lookups.
Inputs and Edge Cases
The plate input is forgiving: it strips spaces and dashes and normalises to uppercase before lookup, so AB 123 CD, ab-123-cd, and AB123CD all resolve the same way. When the plate is not found or the source cannot resolve it, found is false and identity fields (brand, model, registration_date, etc.) return null. The plate field in the response always echoes back the normalised form.
The Cercassicurazioni API is a managed, monitored endpoint for cercassicurazioni.it — not a raw scraper you maintain. Every endpoint is automatically health-checked on a schedule, and when cercassicurazioni.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 cercassicurazioni.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 insurance quote forms by resolving a plate to brand, model, and registration date automatically.
- Build a vehicle history lookup tool that surfaces the make, model year, and available trims from a plate scan.
- Validate that a user-entered plate corresponds to a known Italian vehicle before proceeding with a transaction.
- Populate dropdown menus for allestimento selection using the
setupsarray returned for a given plate. - Enrich fleet management records with decoded brand and model data keyed to Italian licence plates.
- Cross-check vehicle category (
vehicle_type) against policy eligibility rules in an insurance workflow.
| 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 cercassicurazioni.it offer an official developer API?+
What does `get_vehicle_by_plate` return when a plate is not recognised?+
found field is false, the setups array is empty, and all identity fields — brand, model, registration_date, registration_year, brand_code, model_code, and vehicle_type — are null. The plate field still echoes the normalised input.Does the API return full vehicle specifications such as engine displacement, power output, or fuel type?+
Are motorcycles, vans, or other vehicle categories supported, or only passenger cars?+
vehicle_type field returns the category code the source assigns to the resolved vehicle (for example, CAR), so the response itself distinguishes vehicle categories. Whether non-car categories are resolvable depends on what the source's quote form covers for a given plate. You can fork the API on Parse and revise it to filter or extend behaviour for specific vehicle types.