Segugio APIassicurazioni.segugio.it ↗
Look up Italian licence plates via the Segugio.it car-insurance form. Returns brand, model, registration date, and available trims in one API call.
What is the Segugio API?
The Segugio.it Vehicle Registry API exposes one endpoint — get_vehicle_by_plate — that returns 7 structured fields for any Italian licence plate: make, model, first registration date, registration year, vehicle class, normalised plate, and the list of available trim versions (allestimenti) drawn from the Segugio.it car-insurance quote registry. It is a direct way to resolve a raw plate string into decoded vehicle identity data without building or maintaining a local registry lookup.
curl -X GET 'https://api.parse.bot/scraper/f5dbdb83-9dcd-4139-b6dd-a9a4711315f9/get_vehicle_by_plate?plate=GA000AA' \ -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 assicurazioni-segugio-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 licence plate on Segugio.it."""
from parse_apis.assicurazioni_segugio_it_api import Segugio, PlateNotFound
client = Segugio()
# Look up a vehicle by its Italian licence plate.
try:
vehicle = client.vehicles.get(plate="GA000AA")
except PlateNotFound:
print("Plate not found in the vehicle registry.")
else:
print(vehicle.brand, vehicle.model)
print("Registered:", vehicle.registration_date, f"({vehicle.registration_year})")
print("Type:", vehicle.vehicle_type)
# Walk available trim versions (may be empty).
if vehicle.trims:
for trim in vehicle.trims:
print(" -", trim.name)
else:
print("No trim variants listed for this vehicle.")
print("exercised: vehicles.get")
Looks up an Italian licence plate in the vehicle registry used by Segugio.it's car-insurance quote form and returns one vehicle record: plate, vehicle type, registration date (YYYY-MM), registration year, brand, model and the list of trim versions (allestimenti) the site offers for that record. The site renders brand, model and trim labels as images; this endpoint decodes them to text, and a character the decoder does not know is returned as '?'. trims can be an empty list when the registry record already pins the exact version. One lookup costs two upstream requests. A plate that is not in the registry returns a stale_input (input_not_found) error; a plate that is not 5-8 letters/digits is rejected before any request.
| Param | Type | Description |
|---|---|---|
| platerequired | string | Italian licence plate, letters and digits without spaces (e.g. AB123CD). Spaces and dashes are stripped and letters upper-cased. |
{
"type": "object",
"fields": {
"brand": "make name decoded from the site's label image",
"model": "model name decoded from the site's label image",
"plate": "normalised plate as echoed by the registry",
"trims": "array of trim versions offered for this record, each {name}; may be empty",
"vehicle_type": "registry vehicle class code (CAR observed)",
"registration_date": "first registration month, YYYY-MM",
"registration_year": "first registration year as shown on the form",
"data_verification_code": "site's internal verification flag for the registry record (string)"
},
"sample": {
"data": {
"brand": "Bmw",
"model": "X3 (G01/F97)",
"plate": "GA000AA",
"trims": [
{
"name": "X3 xDrive30e Luxury"
},
{
"name": "X3 xDrive30e Msport"
},
{
"name": "X3 xDrive30e"
},
{
"name": "X3 xDrive30e Business Advantage"
},
{
"name": "X3 xDrive30e xLine"
}
],
"vehicle_type": "CAR",
"registration_date": "2020-05",
"registration_year": "2020",
"data_verification_code": "4"
},
"status": "success"
}
}About the Segugio API
What the API Returns
The single get_vehicle_by_plate endpoint accepts one required parameter — plate — an Italian licence plate passed as a string of letters and digits (spaces and dashes are stripped automatically). The response is a single vehicle record containing brand (make name), model, plate (normalised), vehicle_type (registry class code; CAR is the observed value), registration_date (first registration month in YYYY-MM format), registration_year, and data_verification_code (the registry's internal verification flag for the record).
Trim Versions
The trims field returns an array of objects, each with a name property, representing the allestimenti (trim levels) the Segugio.it registry associates with the vehicle. This is useful when a model has multiple configurations that affect insurance quotes. The array may be empty if the registry holds no trim data for that specific record.
Plate Format and Coverage
The API targets Italian plates in the current alphanumeric format (e.g. AB123CD) as well as older formats handled by the registry. The endpoint normalises input before the lookup, so minor formatting variations in the caller's input do not cause failures. Coverage is limited to vehicles registered in the Italian registry and recognised by the Segugio.it quote form; foreign or unrecognised plates will not return a record.
The Segugio API is a managed, monitored endpoint for assicurazioni.segugio.it — not a raw scraper you maintain. Every endpoint is automatically health-checked on a schedule, and when assicurazioni.segugio.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 assicurazioni.segugio.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 plate to brand, model, and registration year.
- Validate that a used-car listing's stated make and model match the plate's registered vehicle data.
- Build a telematics or fleet-management intake flow that decodes Italian plates into structured vehicle records.
- Populate vehicle selector dropdowns with accurate trim options from the
trimsarray without manual catalogue maintenance. - Cross-check registration dates against odometer readings for Italian vehicle valuation tools.
- Automate vehicle identity verification steps in Italian fintech or leasing onboarding workflows.
| 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 Segugio.it offer an official developer API for its vehicle registry or insurance quote data?+
What does `data_verification_code` represent in the response?+
Can the API return insurance quotes or premium estimates for the looked-up vehicle?+
Does the API handle plates for motorcycles, vans, or other vehicle classes?+
vehicle_type field reflects the registry class code returned for the plate; CAR is the observed value in tested records. Whether other vehicle classes such as motorcycles or commercial vehicles return distinct type codes depends on what the Segugio.it registry holds for that plate. The API surfaces whatever class code the registry provides. You can fork this API on Parse and revise it to filter or map additional vehicle class codes as needed.