SOStariffe APIsostariffe.it ↗
Look up Italian vehicles by licence plate and browse the SOStariffe.it car-insurance brand, model, and trim catalogue via 4 structured endpoints.
What is the SOStariffe API?
The SOStariffe.it API gives developers structured access to Italian vehicle data across 4 endpoints, returning brand, model, and trim details from the site's car-insurance quote form. The get_vehicle_by_plate endpoint resolves a licence plate to a registration date, vehicle type, brand, model, and a list of matching trim configurations. The catalogue endpoints — list_brands, list_models, and list_setups — let you browse the full hierarchy filtered by first-registration month.
curl -X GET 'https://api.parse.bot/scraper/14e49c2a-4c6f-4e8c-9e68-0a27515e1978/get_vehicle_by_plate?plate=FX123AB' \ -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 sostariffe-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: SOStariffe car-insurance data — plate lookup and catalogue browse."""
from parse_apis.sostariffe_it_api import SoStariffe, InputFormatInvalid
client = SoStariffe()
# Look up a vehicle by Italian licence plate.
try:
vehicle = client.vehicles.get(plate="FX123AB")
except InputFormatInvalid:
print("invalid plate format")
raise
print(vehicle.plate, vehicle.vehicle_type, vehicle.registration_date)
if vehicle.brand is not None:
print("brand:", vehicle.brand.name, "model:", vehicle.model.name)
# Show the trims the site matched for this plate.
for setup in vehicle.setups:
print(" trim:", setup.name, "alarm_code:", setup.alarm_code)
# Browse the catalogue: list brands for a registration month, then drill down.
brand = client.brands.list(registration_date="2022-01", limit=5).first()
if brand is not None:
print("first brand:", brand.name)
# List models for that brand in the same period.
model = client.models.list(
brand_code=brand.code, registration_date="2022-01", limit=5,
).first()
if model is not None:
print("first model:", model.name)
# List trims for that brand + model combination.
for setup in client.setups.list(
brand_code=brand.code,
model_code=model.code,
registration_date="2022-01",
limit=5,
):
print(" setup:", setup.name, "hidden:", setup.alarm_hidden)
print("exercised: vehicles.get / brands.list / models.list / setups.list")
Looks up a vehicle by its Italian licence plate through the quote form's 'Recupera dati veicolo' step and returns what the site knows about it: vehicle type, registration month (YYYY-MM), the registration year label shown in the form, brand and model (code + name) and the list of candidate trims (setups) with their codes. One lookup costs two upstream requests. `found` is false (and brand/model/setups are empty) when the site has no record for the plate; `lookup_status` is the site's own result code (200/205 = record found, 204 = not found). Names are decoded from the label images the site renders; a character the decoder does not recognise is emitted as '?'. The site rate-limits plate lookups per network address: when the quota is exhausted the endpoint returns a blocked result and should be retried later. 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). Case-insensitive. |
{
"type": "object",
"fields": {
"brand": "object {code, name} of the detected brand; null when not found",
"found": "boolean, true when the site returned a vehicle record for the plate",
"model": "object {code, name} of the detected model; null when not found",
"plate": "normalised plate that was looked up",
"setups": "array of candidate trims {code, name, alarm_code, alarm_hidden}; empty when not found",
"vehicle_type": "site vehicle category, e.g. CAR; null when not found",
"lookup_status": "site result code for the lookup (200/205 found, 204 not found)",
"registration_date": "first registration month YYYY-MM; null when not found",
"data_verified_code": "site code describing how the record was verified; null when not found",
"registration_year_label": "registration year as displayed in the form; null when not found"
},
"sample": {
"data": {
"brand": {
"code": "cDJfdmhlczVXMExrQlJ0Q0N6NlFkTHRZUSUzRCUzRA==",
"name": "Toyota"
},
"found": true,
"model": {
"code": "cDJfclJRTVRUNkZkbHpkSTZONWxobUl3dyUzRCUzRA==",
"name": "Corolla (2018-->)"
},
"plate": "FX123AB",
"setups": [
{
"code": "cDJfWlBEa1Q0cTdQdkZKNFY0elpYWDk5USUzRCUzRA==",
"name": "Corolla 1.8 Hybrid Business Tech",
"alarm_code": "30",
"alarm_hidden": false
},
{
"code": "cDJfRUhGbUxRc3BNZ1g1T1UlMkJwYTZENDhBJTNEJTNE",
"name": "Corolla 1.8 Hybrid Active",
"alarm_code": "30",
"alarm_hidden": false
}
],
"vehicle_type": "CAR",
"lookup_status": 205,
"registration_date": "2019-07",
"data_verified_code": "4",
"registration_year_label": "2019"
},
"status": "success"
}
}About the SOStariffe API
Vehicle Lookup by Plate
The get_vehicle_by_plate endpoint accepts an Italian licence plate (letters and digits, case-insensitive) and returns up to ten fields: found boolean, vehicle_type, registration_date (YYYY-MM), registration_year_label, brand and model objects (each carrying a code and name), a setups array of candidate trims, lookup_status, and data_verified_code. When the plate is not recognised, found is false, all object fields are null, and setups is an empty array. The lookup_status field surfaces the site's own result code — 200 or 205 for a found record, 204 for not found.
Catalogue Browsing
list_brands takes a registration_date (YYYY-MM) and returns the roughly 70 brands the form offers for vehicles registered in that month, as {code, name} pairs plus a count. The code values are opaque identifiers used as the brand_code input to downstream endpoints. list_models narrows the catalogue to one brand: pass brand_code and registration_date to get the models available for that period. An unrecognised brand_code returns an empty models array rather than an error.
Trim Details
list_setups accepts brand_code, model_code, and registration_date and returns the trims (allestimenti) for that model, each with code, name, alarm_code, and alarm_hidden. These fields are the same shape as the setups array returned inline by get_vehicle_by_plate, so you can resolve a plate and then verify or expand its trims using the catalogue endpoints with matching codes.
Coverage Notes
All four endpoints are filtered by registration_date (first-registration month). The catalogue reflects what SOStariffe.it's quote form exposes for Italian car insurance, so coverage is limited to vehicle types and brands that form supports. Brand names are decoded from label images; unrecognised characters may be emitted as replacement tokens in the name field.
The SOStariffe API is a managed, monitored endpoint for sostariffe.it — not a raw scraper you maintain. Every endpoint is automatically health-checked on a schedule, and when sostariffe.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 sostariffe.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?+
- Resolve an Italian licence plate to brand, model, and registration month for pre-filling insurance application forms.
- Build a vehicle selector widget that chains list_brands → list_models → list_setups filtered by the car's registration date.
- Validate user-submitted plates before submitting to downstream insurance APIs by checking the
foundfield. - Populate a local vehicle catalogue database with the brands and models available for a given registration period.
- Map opaque trim codes to human-readable names for display in a comparison or quoting interface.
- Cross-reference the
data_verified_codefield to understand the confidence level of a plate-based vehicle lookup. - Detect the vehicle type (
vehicle_type) returned for a plate to route the user to the correct insurance product flow.
| 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 SOStariffe.it offer an official developer API?+
What does get_vehicle_by_plate return when a plate is not in the system?+
found: false, a lookup_status of 204, and null values for brand, model, vehicle_type, registration_date, and data_verified_code. The setups array is empty. No error is thrown; the response shape is the same regardless of whether the plate is found.Do the catalogue endpoints return data for all vehicle types, or only cars?+
Is insurance pricing or quote data returned by any endpoint?+
Why might a brand name appear with replacement characters in list_brands?+
name field instead. The code field is unaffected and remains reliable for passing to list_models and list_setups.