Comprehensive documentation for integrating our vehicle data API with your applications
Die Autoref FIN-Abfrage-API ermöglicht den Zugriff auf umfassende Fahrzeuginformationen durch Abfrage verschiedener Kennungen wie FIN (Fahrzeug-Identifizierungsnummer), EU-Typgenehmigungsnummern und Schweizer Typgenehmigungscodes.
Unsere API ist für die nahtlose Integration in Ihre Anwendungen konzipiert und bietet detaillierte technische Spezifikationen, Umweltdaten und offizielle Fahrzeugdokumentationen.
Zur Nutzung der Autoref-API benötigen Sie einen API-Schlüssel. Alle Anfragen müssen Ihren API-Schlüssel als Header-Parameter enthalten.
Sie haben keinen API-Schlüssel? Fragen Sie unsX-API-Key: your_api_key_hereAlle API-Anfragen müssen an die folgende Basis-URL gerichtet werden:
https://api.autoref.euAlle Antworten werden im JSON-Format zurückgegeben. Erfolgreiche Antworten enthalten einen Statuscode 200 OK.
{
"success": true,
"data": [{
"id": 55411,
"VIN": "WBA11AL010",
"BRAND": "BMW",
"BRAND_MODEL": "BMW M235I XDRIVE",
"MODEL": "M235i",
"MODEL2": "xDrive",
"MODEL3": null,
"POWER_KW": 225.0,
"POWER_DIN": 306.0,
"FUEL": "Gasoline",
"DATE_FIRST_CIRCULATION": 2020,
"RECORD_TYPE": "TG"
}]
}Bei Fehlern gibt die API einen entsprechenden HTTP-Statuscode und eine Fehlermeldung zurück.
{
"success": false,
"error": "not_found",
"message": "Vehicle not found"
}API-Ratenbegrenzungen gelten je nach Ihrem Abonnementplan. Überprüfen Sie den Abschnitt Preise für Details zu den Anfragelimits für Ihre Stufe.
Our API offers several endpoints to query vehicle information using different identifiers.
Fahrzeuginformationen anhand der FIN (Fahrzeug-Identifizierungsnummer) abrufen.
| Parameter | Typ | Beschreibung |
|---|---|---|
| vin | string | Die FIN (Fahrzeug-Identifizierungsnummer) des Fahrzeugs. Mindestens 10 Zeichen. |
| Parameter | Typ | Standard | Beschreibung |
|---|---|---|---|
| lang | string | en | Sprachcode für lokalisierte Antworten (en, fr, de, es, it) |
curl -X GET "https://api.autoref.eu/vehicles/WBA11AL0101234567" \
-H "X-API-Key: your_api_key_here"[
{
"id": 55411,
"VIN": "WBA11AL010",
"BRAND": "BMW",
"BRAND_MODEL": "BMW M235I XDRIVE",
"MODEL_COC": null,
"VARIANT": null,
"VERSION": null,
"MODEL": "M235i",
"MODEL2": "xDrive",
"MODEL3": null,
"POWER_KW": 225.0,
"POWER_DIN": 306.0,
"FUEL": "Essence",
"DATE_FIRST_CIRCULATION": 2020,
"RECORD_TYPE": "TG"
}
]| Feld | Typ | Beschreibung |
|---|---|---|
| id | integer | Eindeutige Kennung für den Fahrzeugdatensatz |
| VIN | string | Fahrzeug-Identifizierungsnummer |
| BRAND | string | Fahrzeughersteller |
| BRAND_MODEL | string | Vollständiger Modellname einschließlich Marke |
| MODEL | string | Primärer Modellname |
| MODEL2 | string | Sekundäre Modellkennung |
| MODEL3 | string | Tertiäre Modellkennung |
| POWER_KW | number | Motorleistung in Kilowatt |
| POWER_DIN | number | Motorleistung in PS |
| FUEL | string | Kraftstoffart (Benzin, Diesel, Elektro, usw.) |
| DATE_FIRST_CIRCULATION | integer | Jahr der Erstzulassung |
| RECORD_TYPE | string | Quelldatenbanktyp (TG, OC, OLD, X) |
Informationen für Fahrzeuge vor 1981 abrufen, unter Verwendung eines kürzeren FIN/Fahrgestellnummernformats zusammen mit dem Markennamen.
| Parameter | Typ | Beschreibung |
|---|---|---|
| vin | string | Die alte FIN oder Fahrgestellnummer des Fahrzeugs. |
| Parameter | Typ | Erforderlich | Beschreibung |
|---|---|---|---|
| brand | string | Yes | Der Fahrzeughersteller (z.B. PORSCHE, BMW, MERCEDES-BENZ) |
| lang | string | No | Sprachcode für lokalisierte Antworten (en, fr, de, es, it) |
curl -X GET "https://api.autoref.eu/legacy-vehicles/9119311194?brand=PORSCHE&lang=en" \
-H "X-API-Key: your_api_key_here"[
{
"id": 11580,
"VIN": "9119311",
"BRAND": "PORSCHE",
"BRAND_MODEL": "PORSCHE 911 SC 3,0 TARGA",
"MODEL_COC": null,
"VARIANT": null,
"VERSION": null,
"MODEL": "911",
"MODEL2": "SC",
"MODEL3": "3,0 Targa",
"POWER_KW": 132.4,
"POWER_DIN": 180.0,
"FUEL": "Gasoline",
"DATE_FIRST_CIRCULATION": 1979,
"RECORD_TYPE": "OLD"
},
{
"id": 11581,
"VIN": "9119311",
"BRAND": "PORSCHE",
"BRAND_MODEL": "PORSCHE 911 SC 3.0",
"MODEL_COC": null,
"VARIANT": null,
"VERSION": null,
"MODEL": "911",
"MODEL2": "SC",
"MODEL3": "3.0",
"POWER_KW": 132.0,
"POWER_DIN": 179.0,
"FUEL": "Gasoline",
"DATE_FIRST_CIRCULATION": 1979,
"RECORD_TYPE": "OLD"
}
]Gleiche Felder wie bei der FIN-Abfrageantwort, mit folgenden Unterschieden:
| Feld | Beschreibung |
|---|---|
| RECORD_TYPE | Wird für ältere Fahrzeuge "OLD" sein |
Fahrzeuge vor 1981 hatten keine standardisierten FINs. Für genaue Ergebnisse:
Fahrzeuge anhand ihrer EU-Typgenehmigungsnummer abrufen.
| Parameter | Typ | Beschreibung |
|---|---|---|
| approval | string | EU-Typgenehmigungsnummer (z.B. e1*2007/46*2064*07) |
| Parameter | Typ | Standard | Beschreibung |
|---|---|---|---|
| lang | string | en | Sprachcode für lokalisierte Antworten (en, fr, de, es, it) |
curl -X GET "https://api.autoref.eu/vehicles-by-approval/e1*2007/46*2064*07?lang=en" \
-H "X-API-Key: your_api_key_here"[
{
"id": 55424,
"VIN": "WBA11AL010",
"BRAND": "BMW",
"BRAND_MODEL": "BMW M235I XDRIVE",
"MODEL_COC": null,
"VARIANT": null,
"VERSION": null,
"MODEL": "M235i",
"MODEL2": "xDrive",
"MODEL3": null,
"POWER_KW": 225.0,
"POWER_DIN": 306.0,
"FUEL": "Gasoline",
"DATE_FIRST_CIRCULATION": 2023,
"RECORD_TYPE": "TG"
}
]EU-Typgenehmigungsnummern folgen diesem Format: e1*2007/46*2064*07
e1: Ländercode, in dem die Genehmigung erteilt wurde (e1 = Deutschland)2007/46: Rahmenrichtliniennummer2064: Basisgenehmigungsnummer07: ErweiterungsnummerGleiche Felder wie bei der FIN-Abfrageantwort.
Umfassende Fahrzeugdaten anhand des Schweizer Typgenehmigungscodes (TG-Code) abrufen.
| Parameter | Typ | Beschreibung |
|---|---|---|
| tgcode | string | Schweizer Typgenehmigungscode (z.B. 1BC170) |
| Parameter | Typ | Standard | Beschreibung |
|---|---|---|---|
| lang | string | en | Sprachcode für lokalisierte Antworten (en, fr, de, es, it) |
curl -X GET "https://api.autoref.eu/vehicle/tgcode/1BC170?lang=en" \
-H "X-API-Key: your_api_key_here"{
"VIN_INFO": {
"id": 55424,
"VIN": "WBA11AL010",
"BRAND": "BMW",
"BRAND_MODEL": "BMW M235I XDRIVE",
"POWER_KW": 225.0,
"POWER_DIN": 306.0,
"GEARBOX": ["Manual"],
"CATEGORY": "M1",
"TYPE_VEHICLE": "Passenger car",
"MODEL_FULL": "M235i xDrive",
"MODEL": "M235i",
"MODEL2": "xDrive",
"BODY": "Coupe",
"COLOR": "Black",
"FUEL": "Gasoline",
"DRIVETRAIN": "All-wheel drive",
"DATE_FIRST_CIRCULATION": "2020-05-12"
},
"SPECS": {
"TGCODE": "1BC170",
"DATE_REGISTRAR_START": "2019-03-15",
"DATE_REGISTRAR_END": "2025-12-31",
"CATEGORY": "M1",
"TVV": ["WBA11AL010"],
"MANUFACTURER": "BMW AG, Munich",
"VIN_LOCATION": "lower right windshield, driver's door pillar",
"AXLES_WHEELS": "2/4",
"SUSPENSION_TYPE": "coil springs, shock absorbers",
"STEERING_TYPE": "rack and pinion, electric assistance",
"BRAKE_TYPE": "discs/discs",
"WEIGHT_EMPTY_MIN_MAX": "1655 - 1740",
"LENGTH_MIN_MAX": "4454 - 4454",
"WIDTH_MIN_MAX": "1774 - 1774",
"HEIGHT_MIN_MAX": "1408 - 1408"
},
"CONSUMPTION": [
{
"COMBINED_CONSUMPTION": 7.8,
"COMBINED_CONSUMPTION_WLTP": 8.2,
"URBAN_CONSUMPTION": 10.4,
"COMBINED_CO2_EMISSIONS": 192,
"COMBINED_CO2_EMISSIONS_WLTP": 188,
"ENERGY_EFFICIENCY_CATEGORY": "G"
}
],
"EMISSION": [
{
"COMBINED_CO2_EMISSIONS": 192,
"COMBINED_CO2_EMISSIONS_WLTP": 188,
"NOISE_DRIVING": 72,
"CODE_SWISS_EMISSION": "A7M",
"CATALIZER": true,
"PARTICLE_FILTER": false
}
],
}Im Gegensatz zu anderen Endpunkten liefert dieser einen viel detaillierteren Fahrzeugdatensatz mit mehreren Abschnitten:
| Abschnitt | Beschreibung |
|---|---|
| VIN_INFO | Grundlegende Fahrzeugidentifikationsinformationen |
| SPECS | Detaillierte technische Spezifikationen aus der Typgenehmigung |
| CONSUMPTION | Kraftstoffverbrauchsdaten in verschiedenen Testzyklen |
| EMISSION | Emissionsdaten für verschiedene Schadstoffe |
| Optionale URL zur PDF-Dokumentation, falls verfügbar |
Umfassende Fahrzeugdaten nach Datensatztyp und ID abrufen.
| Parameter | Typ | Beschreibung |
|---|---|---|
| record_type | string | Quelldatenbanktyp (TG, OC, OLD, X) |
| id | integer | Die eindeutige Kennung des Fahrzeugdatensatzes |
| Parameter | Typ | Standard | Beschreibung |
|---|---|---|---|
| lang | string | en | Sprachcode für lokalisierte Antworten (en, fr, de, es, it) |
curl -X GET "https://api.autoref.eu/vehicle/TG/55424?lang=en" \
-H "X-API-Key: your_api_key_here"Das Antwortformat ähnelt dem TG-Code-Endpunkt, mit detaillierten Fahrzeuginformationen, die in Abschnitte gegliedert sind.
Eine Liste aller in der Datenbank verfügbaren Fahrzeugmarken abrufen.
| Parameter | Typ | Standard | Beschreibung |
|---|---|---|---|
| lang | string | en | Sprachcode für lokalisierte Antworten (en, fr, de, es, it) |
curl -X GET "https://api.autoref.eu/vehicle-brands" \
-H "X-API-Key: your_api_key_here"[
...
{
"id": 490,
"brand": "ALFA ROMEO"
},
{
"id": 551,
"brand": "AUDI"
},
{
"id": 23,
"brand": "BMW"
},
{
"id": 279,
"brand": "CHEVROLET"
},
...
]| Feld | Typ | Beschreibung |
|---|---|---|
| name | string | Vollständiger Markenname |
| code | string | Markencode (typischerweise 3 Buchstaben) |
| country | string | ISO-Ländercode des Herstellerursprungs |
Die API verwendet Standard-HTTP-Statuscodes, um den Erfolg oder Misserfolg von Anfragen anzuzeigen. Hier sind die häufigsten Fehlerantworten, die auftreten können:
| Statuscode | Fehlertyp | Beschreibung |
|---|---|---|
| 400 | Ungültige Anfrage | Die Anfrage war ungültig oder es fehlen erforderliche Parameter |
| 401 | Nicht autorisiert | API-Schlüssel fehlt oder ist ungültig |
| 403 | Verboten | API-Schlüssel ist gültig, verfügt aber nicht über die Berechtigung für die angeforderte Ressource |
| 404 | Nicht gefunden | Das angegebene Fahrzeug oder die Ressource wurde nicht gefunden |
| 429 | Zu viele Anfragen | Ratenlimit für Ihren Plan überschritten |
| 500 | Interner Serverfehler | Auf dem Server ist ein unerwarteter Fehler aufgetreten |
{
"success": false,
"error": "not_found",
"message": "Vehicle not found for VIN: WBA11AL010XXXXXX"
}API-Anfragen unterliegen einer Ratenbegrenzung basierend auf Ihrem Abonnementplan. Wenn Sie Ihr Ratenlimit überschreiten, erhalten Sie eine 429 Too Many Requests-Antwort.
{
"success": false,
"error": "rate_limit_exceeded",
"message": "Rate limit exceeded. Please upgrade your plan or try again later.",
"reset_at": "2025-04-11T12:30:15Z"
}Unsere API bietet mehrere Abonnementstufen, um verschiedene Nutzungsanforderungen zu erfüllen. Jeder Plan hat spezifische Ratenlimits und Funktionen.
0 €/Monat
29 €/Monat
99 €/Monat
Wenn Sie höhere Ratenlimits oder benutzerdefinierte Funktionen benötigen, kontaktieren Sie bitte unser Vertriebsteam für einen auf Ihre Bedürfnisse zugeschnittenen Enterprise-Plan.
Vertrieb kontaktierenAktuell werden API-Schlüssel auf Anfrage über unser Kontaktformular bereitgestellt. Füllen Sie einfach das Kontaktformular mit Ihren Anwendungsfalldetails aus, und unser Team wird per E-Mail mit Ihrem einzigartigen API-Schlüssel und Einrichtungsanweisungen antworten. Dieser manuelle Prozess ermöglicht es uns, persönliche Unterstützung bei der Einrichtung für jede Integration anzubieten.
Unsere API bietet mehrere Methoden zum Abrufen von Fahrzeuginformationen:
Jede Methode bietet Zugang zu unterschiedlichen Detailebenen. TG-Code- und Typgenehmigungsabfragen liefern in der Regel die umfassendsten technischen Daten.
Unsere Fahrzeugdaten stammen direkt aus offiziellen staatlichen Homologationsdatenbanken und Typgenehmigungen der Hersteller, was eine deutlich höhere Genauigkeit bietet als typische FIN-Decoder, die oft Algorithmen zur Interpretation von FIN-Mustern verwenden.
Für europäische und Schweizer Fahrzeuge stellen wir genaue Spezifikationen bereit, wie sie von den Herstellern an die Regulierungsbehörden übermittelt wurden. Bei älteren Fahrzeugen kann die Vollständigkeit der Daten je nach verfügbaren historischen Aufzeichnungen variieren.
Die API unterstützt mehrere Sprachen für lokalisierte Antworten. Derzeit unterstützte Sprachen:
en - Englisch (Standard)fr - Französischde - Deutsches - Spanischit - ItalienischGeben Sie Ihre bevorzugte Sprache mit dem lang Abfrageparameter bei jeder API-Anfrage an.
Alle API-Antworten enthalten HTTP-Statuscodes, die den Erfolg oder Misserfolg der Anfrage anzeigen. Bei Fehlern stellen wir auch eine strukturierte JSON-Antwort bereit mit:
success: Immer false für Fehlerantwortenerror: Ein maschinenlesbarer Fehlercodemessage: Eine menschenlesbare Beschreibung des FehlersWir empfehlen, eine angemessene Fehlerbehandlung in Ihrem Code zu implementieren, um verschiedene Fehlerarten elegant zu behandeln, insbesondere "not_found"-Fehler für FIN-Suchen und Ratenbegrenzungsantworten.
Wenn Sie hier keine Antwort auf Ihre Frage finden, steht unser Support-Team bereit, um Ihnen zu helfen.
Hier sind einige Codebeispiele, die Ihnen helfen, unsere API in verschiedenen Programmiersprachen in Ihre Anwendung zu integrieren.
// Example using fetch in Node.js (with node-fetch package)
const fetch = require('node-fetch');
async function getVehicleByVin(vin) {
try {
const response = await fetch(`https://api.autoref.eu/vehicles/${vin}`, {
headers: {
'X-API-Key': 'your_api_key_here'
}
});
if (!response.ok) {
const errorData = await response.json();
throw new Error(errorData.message || 'Failed to fetch vehicle data');
}
const data = await response.json();
return data;
} catch (error) {
console.error('Error fetching vehicle data:', error);
throw error;
}
}
// Usage
getVehicleByVin('WBA11AL010')
.then(data => console.log(data))
.catch(error => console.error(error));import requests
def get_vehicle_by_vin(vin, api_key, lang='en'):
"""
Fetch vehicle data by VIN
Args:
vin: Vehicle Identification Number
api_key: Your API key
lang: Language code for response (en, fr, de, es, it)
Returns:
Dictionary with vehicle data
"""
url = f"https://api.autoref.eu/vehicles/{vin}"
headers = {
"X-API-Key": api_key
}
params = {
"lang": lang
}
response = requests.get(url, headers=headers, params=params)
# Check for errors
if response.status_code != 200:
try:
error_data = response.json()
error_message = error_data.get('message', 'Unknown error')
except:
error_message = f"HTTP Error: {response.status_code}"
raise Exception(f"API Error: {error_message}")
return response.json()
# Usage
try:
api_key = "your_api_key_here"
vehicle_data = get_vehicle_by_vin("WBA11AL010", api_key)
print(vehicle_data)
except Exception as e:
print(f"Error: {e}")<?php
/**
* Function to fetch vehicle data by VIN
*
* @param string $vin Vehicle Identification Number
* @param string $apiKey Your API key
* @param string $lang Language code for response
*
* @return array|null Vehicle data or null on error
*/
function getVehicleByVin($vin, $apiKey, $lang = 'en') {
$url = "https://api.autoref.eu/vehicles/" . urlencode($vin) . "?lang=" . urlencode($lang);
$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
'X-API-Key: ' . $apiKey
]);
$response = curl_exec($ch);
$statusCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
curl_close($ch);
if ($statusCode !== 200) {
$errorData = json_decode($response, true);
$errorMessage = isset($errorData['message']) ? $errorData['message'] : 'Unknown error';
error_log("API Error ($statusCode): $errorMessage");
return null;
}
return json_decode($response, true);
}
// Usage
$apiKey = 'your_api_key_here';
$vehicleData = getVehicleByVin('WBA11AL010', $apiKey);
if ($vehicleData) {
print_r($vehicleData);
} else {
echo "Failed to retrieve vehicle data";
}
?>import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.net.http.HttpResponse.BodyHandlers;
import java.time.Duration;
public class VinLookupExample {
private static final String API_BASE_URL = "https://api.autoref.eu";
private static final String API_KEY = "your_api_key_here";
public static void main(String[] args) {
try {
String vin = "WBA11AL010";
String vehicleData = getVehicleByVin(vin);
System.out.println(vehicleData);
} catch (Exception e) {
System.err.println("Error: " + e.getMessage());
}
}
public static String getVehicleByVin(String vin) throws Exception {
HttpClient client = HttpClient.newBuilder()
.connectTimeout(Duration.ofSeconds(10))
.build();
HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create(API_BASE_URL + "/vehicles/" + vin))
.header("X-API-Key", API_KEY)
.GET()
.build();
HttpResponse<String> response = client.send(request, BodyHandlers.ofString());
if (response.statusCode() != 200) {
throw new Exception("API Error: HTTP " + response.statusCode() + " - " + response.body());
}
return response.body();
}
}Integrieren Sie noch heute unsere leistungsstarke Fahrzeugdaten-API in Ihre Anwendungen und erhalten Sie Zugriff auf umfassende technische Spezifikationen für Millionen von Fahrzeugen.