VIN Lookup API Documentation

Comprehensive documentation for integrating our vehicle data API with your applications

Einführung

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.

API-Funktionen

✓FIN-basierte Fahrzeugabfragen
✓Unterstützung alter FINs (vor 1981)
✓EU-Typgenehmigungssuche
✓Schweizer Typgenehmigung (TG-Code) Abfragen
✓Detaillierte Fahrzeugspezifikationen
✓Mehrsprachige Unterstützung

Erste Schritte

Authentifizierung

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 uns

Authentifizierungs-Header

X-API-Key: your_api_key_here

Basis-URL

Alle API-Anfragen müssen an die folgende Basis-URL gerichtet werden:

API-Basis-URL

https://api.autoref.eu

Antwortformat

Alle Antworten werden im JSON-Format zurückgegeben. Erfolgreiche Antworten enthalten einen Statuscode 200 OK.

Beispielantwort

{
  "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"
  }]
}

Fehlerbehandlung

Bei Fehlern gibt die API einen entsprechenden HTTP-Statuscode und eine Fehlermeldung zurück.

Beispiel für eine Fehlerantwort

{
  "success": false,
  "error": "not_found",
  "message": "Vehicle not found"
}

Wichtiger Hinweis:

API-Ratenbegrenzungen gelten je nach Ihrem Abonnementplan. Überprüfen Sie den Abschnitt Preise für Details zu den Anfragelimits für Ihre Stufe.

API Endpoints

Our API offers several endpoints to query vehicle information using different identifiers.

FIN-Abfrage

Fahrzeuginformationen anhand der FIN (Fahrzeug-Identifizierungsnummer) abrufen.

GET /vehicles/{vin}

Pfadparameter

Parameter	Typ	Beschreibung
vin	string	Die FIN (Fahrzeug-Identifizierungsnummer) des Fahrzeugs. Mindestens 10 Zeichen.

Abfrageparameter

Parameter	Typ	Standard	Beschreibung
lang	string	en	Sprachcode für lokalisierte Antworten (en, fr, de, es, it)

Beispielanfrage

curl -X GET "https://api.autoref.eu/vehicles/WBA11AL0101234567" \
                -H "X-API-Key: your_api_key_here"

Beispielantwort

[
  {
      "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"
  }
]

Antwortfelder

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)

Hinweise:

FIN-Abfragen sind nicht case-sensitive. "WBA11AL010" und "wba11al010" liefern die gleichen Ergebnisse.
Teilweise FIN-Übereinstimmungen werden unterstützt. Die API gibt alle passenden Fahrzeuge für das angegebene FIN-Präfix zurück.
Für die meisten modernen Fahrzeuge sind mindestens 10 Zeichen für eine zuverlässige Übereinstimmung erforderlich.

Alte FIN-Abfrage

Informationen für Fahrzeuge vor 1981 abrufen, unter Verwendung eines kürzeren FIN/Fahrgestellnummernformats zusammen mit dem Markennamen.

GET /legacy-vehicles/{vin}

Pfadparameter

Parameter	Typ	Beschreibung
vin	string	Die alte FIN oder Fahrgestellnummer des Fahrzeugs.

Abfrageparameter

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)

Beispielanfrage

curl -X GET "https://api.autoref.eu/legacy-vehicles/9119311194?brand=PORSCHE&lang=en" \
              -H "X-API-Key: your_api_key_here"

Beispielantwort

[
  {
      "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"
  }
]

Antwortfelder

Gleiche Felder wie bei der FIN-Abfrageantwort, mit folgenden Unterschieden:

Feld	Beschreibung
RECORD_TYPE	Wird für ältere Fahrzeuge "OLD" sein

Wichtiger Hinweis:

Fahrzeuge vor 1981 hatten keine standardisierten FINs. Für genaue Ergebnisse:

Der Markenparameter ist erforderlich
Die FIN kann kürzer sein als moderne Standards (oft 3-10 Zeichen)
Für dieselbe FIN/Marken-Kombination können mehrere Ergebnisse zurückgegeben werden

Typgenehmigungsabfrage

Fahrzeuge anhand ihrer EU-Typgenehmigungsnummer abrufen.

GET /vehicles-by-approval/{approval}

Pfadparameter

Parameter	Typ	Beschreibung
approval	string	EU-Typgenehmigungsnummer (z.B. e12007/462064*07)

Abfrageparameter

Parameter	Typ	Standard	Beschreibung
lang	string	en	Sprachcode für lokalisierte Antworten (en, fr, de, es, it)

Beispielanfrage

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"

Beispielantwort

[
  {
      "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"
  }
]

Format der Typgenehmigungsnummer

EU-Typgenehmigungsnummern folgen diesem Format: e1*2007/46*2064*07

e1: Ländercode, in dem die Genehmigung erteilt wurde (e1 = Deutschland)
2007/46: Rahmenrichtliniennummer
2064: Basisgenehmigungsnummer
07: Erweiterungsnummer

Antwortfelder

Gleiche Felder wie bei der FIN-Abfrageantwort.

Hinweise:

Typgenehmigungsnummern enthalten Sonderzeichen wie *, /, usw. Stellen Sie sicher, dass Sie diese Zeichen in Ihren Anfragen richtig URL-codieren.
Dieser Endpunkt kann mehrere Fahrzeuge zurückgeben, wenn mehrere Modelle dieselbe Typgenehmigung haben.
Der RECORD_TYPE ist für Typgenehmigungsübereinstimmungen typischerweise "TG".

Schweizer Typgenehmigung (TG-Code) Abfrage

Umfassende Fahrzeugdaten anhand des Schweizer Typgenehmigungscodes (TG-Code) abrufen.

GET /vehicle/tgcode/{tgcode}

Pfadparameter

Parameter	Typ	Beschreibung
tgcode	string	Schweizer Typgenehmigungscode (z.B. 1BC170)

Abfrageparameter

Parameter	Typ	Standard	Beschreibung
lang	string	en	Sprachcode für lokalisierte Antworten (en, fr, de, es, it)

Beispielanfrage

curl -X GET "https://api.autoref.eu/vehicle/tgcode/1BC170?lang=en" \
                        -H "X-API-Key: your_api_key_here"

Beispielantwort

{
  "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
      }
  ],
}

Antwortstruktur

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
PDF	Optionale URL zur PDF-Dokumentation, falls verfügbar

Hinweise:

Schweizer TG-Codes haben drei Formatgenerationen: numerisch (vor 1985), einbuchstabig alphanumerisch (1985-1995) und zweibuchstabig alphanumerisch (nach 1995).
Dieser Endpunkt liefert die umfassendsten Fahrzeugdaten, einschließlich Verbrauchs- und Emissionsdetails.
Die Antwortstruktur unterscheidet sich von anderen Endpunkten und enthält mehrere verschachtelte Abschnitte.

Fahrzeugdetailabfrage

Umfassende Fahrzeugdaten nach Datensatztyp und ID abrufen.

GET /vehicle/{record_type}/{id}

Pfadparameter

Parameter	Typ	Beschreibung
record_type	string	Quelldatenbanktyp (TG, OC, OLD, X)
id	integer	Die eindeutige Kennung des Fahrzeugdatensatzes

Abfrageparameter

Parameter	Typ	Standard	Beschreibung
lang	string	en	Sprachcode für lokalisierte Antworten (en, fr, de, es, it)

Beispielanfrage

curl -X GET "https://api.autoref.eu/vehicle/TG/55424?lang=en" \
                    -H "X-API-Key: your_api_key_here"

Beispielantwort

Das Antwortformat ähnelt dem TG-Code-Endpunkt, mit detaillierten Fahrzeuginformationen, die in Abschnitte gegliedert sind.

Hinweise:

Dieser Endpunkt wird typischerweise nach dem Finden eines Fahrzeugs mit einem der Sucheendpunkte verwendet, unter Verwendung der ID und des RECORD_TYPE aus den ersten Suchergebnissen.
Verschiedene Datensatztypen können unterschiedliche Datenstrukturen zurückgeben, wobei TG-Datensätze (Typgenehmigung) die umfassendsten Informationen enthalten.
Gültige record_type-Werte: TG (Typgenehmigung), OC (Übereinstimmungsbescheinigung), OLD (Alt), X (Importiert)

Fahrzeugmarkenabfrage

Eine Liste aller in der Datenbank verfügbaren Fahrzeugmarken abrufen.

GET /vehicle-brands

Abfrageparameter

Parameter	Typ	Standard	Beschreibung
lang	string	en	Sprachcode für lokalisierte Antworten (en, fr, de, es, it)

Beispielanfrage

curl -X GET "https://api.autoref.eu/vehicle-brands" \
                    -H "X-API-Key: your_api_key_here"

Beispielantwort

[
  ...
  {
    "id": 490,
    "brand": "ALFA ROMEO"
  },
  {
    "id": 551,
    "brand": "AUDI"
  },
  {
    "id": 23,
    "brand": "BMW"
  },
  {
    "id": 279,
    "brand": "CHEVROLET"
  },
  ...
]

Antwortfelder

Feld	Typ	Beschreibung
name	string	Vollständiger Markenname
code	string	Markencode (typischerweise 3 Buchstaben)
country	string	ISO-Ländercode des Herstellerursprungs

Hinweise:

Dieser Endpunkt ist nützlich zum Befüllen von Dropdown-Menüs in Anwendungen, insbesondere bei der Arbeit mit älteren FIN-Abfragen, die einen Markenparameter erfordern.
Die Liste ist umfassend und enthält alle in der Datenbank vorhandenen Hersteller.
Markennamen sollten bei API-Aufrufen genau so verwendet werden, wie sie in dieser Liste erscheinen.

Fehlerantworten

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

Beispiel für eine Fehlerantwort

404 Nicht gefunden

{
  "success": false,
  "error": "not_found",
  "message": "Vehicle not found for VIN: WBA11AL010XXXXXX"
}

Ratenbegrenzung

API-Anfragen unterliegen einer Ratenbegrenzung basierend auf Ihrem Abonnementplan. Wenn Sie Ihr Ratenlimit überschreiten, erhalten Sie eine 429 Too Many Requests-Antwort.

429 Zu viele Anfragen

{
  "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"
}

Ratenlimits & Pläne

Unsere API bietet mehrere Abonnementstufen, um verschiedene Nutzungsanforderungen zu erfüllen. Jeder Plan hat spezifische Ratenlimits und Funktionen.

Kostenlos

0 €/Monat

✓50 Anfragen / Monat
✓Grundlegende Fahrzeugdaten
✓FIN-Abfrage
✗Typgenehmigungsabfrage
✗Detaillierte Fahrzeugspezifikationen

Basis

29 €/Monat

✓5.000 Anfragen / Monat
✓Vollständige Fahrzeugdaten
✓Alle Abfragemethoden
✓Detaillierte Fahrzeugspezifikationen
✓E-Mail-Support

Premium

99 €/Monat

✓25.000 Anfragen / Monat
✓Vollständige Fahrzeugdaten
✓Alle Abfragemethoden
✓Detaillierte Fahrzeugspezifikationen
✓Prioritätssupport

Benötigen Sie höhere Limits?

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 kontaktieren

Support & FAQ

Wie erhalte ich einen API-Schlüssel?

Aktuell 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.

Was ist der Unterschied zwischen den verschiedenen FIN-Abfragemethoden?

Unsere API bietet mehrere Methoden zum Abrufen von Fahrzeuginformationen:

FIN-Abfrage: Verwendet eine standardmäßige 17-stellige FIN (oder mindestens 10 Zeichen) für moderne Fahrzeuge (nach 1981)
Alte FIN-Abfrage: Für ältere Fahrzeuge (vor 1981), die kürzere Fahrgestellnummern zusammen mit dem Markennamen verwenden
Typgenehmigungsabfrage: Sucht nach EU-Typgenehmigungsnummer
TG-Code-Abfrage: Sucht nach Schweizer Typgenehmigungscode

Jede Methode bietet Zugang zu unterschiedlichen Detailebenen. TG-Code- und Typgenehmigungsabfragen liefern in der Regel die umfassendsten technischen Daten.

Wie genau sind die Fahrzeugdaten?

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.

Welche Sprachen unterstützt die API?

Die API unterstützt mehrere Sprachen für lokalisierte Antworten. Derzeit unterstützte Sprachen:

en - Englisch (Standard)
fr - Französisch
de - Deutsch
es - Spanisch
it - Italienisch

Geben Sie Ihre bevorzugte Sprache mit dem lang Abfrageparameter bei jeder API-Anfrage an.

Wie behandle ich Fehler von der API?

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 Fehlerantworten
error: Ein maschinenlesbarer Fehlercode
message: Eine menschenlesbare Beschreibung des Fehlers

Wir 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.

Benötigen Sie weitere Hilfe?

Wenn Sie hier keine Antwort auf Ihre Frage finden, steht unser Support-Team bereit, um Ihnen zu helfen.

Support kontaktieren Vollständige FAQ anzeigen

Codebeispiele

Hier sind einige Codebeispiele, die Ihnen helfen, unsere API in verschiedenen Programmiersprachen in Ihre Anwendung zu integrieren.

JavaScript / Node.js

// 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));

Python

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

<?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";
}
?>

Java

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();
    }
}

Bereit, loszulegen?

Integrieren Sie noch heute unsere leistungsstarke Fahrzeugdaten-API in Ihre Anwendungen und erhalten Sie Zugriff auf umfassende technische Spezifikationen für Millionen von Fahrzeugen.

API-Schlüssel erhalten Vertrieb kontaktieren