EPC API

export EPC_API_KEY="epc_..."   # yönetimden aldığınız anahtar

curl https://api.epc.vin/v1/usage \
  -H "Authorization: Bearer $EPC_API_KEY"

// .NET 8+. Tek bir HttpClient uygulama boyunca kullanılır.
using System.Net;
using System.Net.Http.Headers;
using System.Net.Http.Json;
using System.Text.Json;

var http = new HttpClient(new HttpClientHandler { AutomaticDecompression = DecompressionMethods.All })
{
    BaseAddress = new Uri("https://api.epc.vin/v1/"),
    Timeout = TimeSpan.FromSeconds(60),
};
http.DefaultRequestHeaders.Authorization =
    new AuthenticationHeaderValue("Bearer", Environment.GetEnvironmentVariable("EPC_API_KEY"));

// Alan adları snake_case: part_numbers ↔ PartNumbers
var json = new JsonSerializerOptions(JsonSerializerDefaults.Web)
{
    PropertyNamingPolicy = JsonNamingPolicy.SnakeCaseLower,
};

// Hata yanıtı: { "error": { "code": "...", "message": "..." } }
async Task<T> Read<T>(HttpResponseMessage res)
{
    if (res.IsSuccessStatusCode) return (await res.Content.ReadFromJsonAsync<T>(json))!;
    var err = await res.Content.ReadFromJsonAsync<ErrorAnswer>(json);
    var wait = res.Headers.RetryAfter?.Delta;   // 429'da kaç saniye beklenmeli
    throw new HttpRequestException($"{(int)res.StatusCode} {err?.Error.Code}: {err?.Error.Message}", null, res.StatusCode);
}

var usage = await Read<JsonElement>(await http.GetAsync("usage"));
Console.WriteLine(usage);

record ErrorAnswer(ErrorBody Error);
record ErrorBody(string Code, string Message);

// Node.js 18+ (fetch yerleşik, sıkıştırmayı kendisi açar).
const API = 'https://api.epc.vin/v1';
const KEY = process.env.EPC_API_KEY;

async function epc(path, body) {
  const res = await fetch(API + path, {
    method: body ? 'POST' : 'GET',
    headers: {
      Authorization: `Bearer ${KEY}`,
      ...(body ? { 'Content-Type': 'application/json' } : {}),
    },
    body: body ? JSON.stringify(body) : undefined,
  });
  const data = await res.json();
  if (!res.ok) {
    // { "error": { "code": "...", "message": "..." } }
    const err = new Error(`${res.status} ${data.error.code}: ${data.error.message}`);
    err.code = data.error.code;
    err.retryAfter = Number(res.headers.get('retry-after')) || undefined;   // 429'da saniye
    throw err;
  }
  return data;
}

console.log(await epc('/usage'));

# Python 3.9+, requests
import os
import requests

API = "https://api.epc.vin/v1"
session = requests.Session()
session.headers["Authorization"] = f"Bearer {os.environ['EPC_API_KEY']}"

def epc(path, body=None):
    if body is None:
        res = session.get(API + path, timeout=60)
    else:
        res = session.post(API + path, json=body, timeout=60)
    if not res.ok:
        # { "error": { "code": "...", "message": "..." } }
        error = res.json()["error"]
        raise RuntimeError(f"{res.status_code} {error['code']}: {error['message']} "
                           f"(Retry-After: {res.headers.get('Retry-After')})")
    return res.json()

print(epc("/usage"))

curl https://api.epc.vin/v1/vehicles/KL1SF48W9BB261734 \
  -H "Authorization: Bearer $EPC_API_KEY"

var answer = await Read<VehicleAnswer>(await http.GetAsync("vehicles/KL1SF48W9BB261734"));
foreach (var v in answer.Vehicles)
    Console.WriteLine($"{v.EquipmentId}: {v.Make} {v.Model} ({v.Source})");

record VehicleAnswer(string Vin, List<Vehicle> Vehicles);
record Vehicle(int EquipmentId, string? Make, string? Model, string? CatalogCode, string? CatalogName,
               string? EquipmentName, string? ProductionDate, string Source);

const { vehicles } = await epc('/vehicles/KL1SF48W9BB261734');
for (const v of vehicles) console.log(`${v.equipment_id}: ${v.make} ${v.model} (${v.source})`);

for v in epc("/vehicles/KL1SF48W9BB261734")["vehicles"]:
    print(v["equipment_id"], v["make"], v["model"], v["source"])

curl https://api.epc.vin/v1/parts/check \
  -H "Authorization: Bearer $EPC_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "vin": "KL1SF48W9BB261734",
    "part_numbers": ["96829637", "95955933", "13300900", "abc;"]
  }'

var check = await Read<CheckAnswer>(await http.PostAsJsonAsync("parts/check", new
{
    vin = "KL1SF48W9BB261734",
    part_numbers = new[] { "96829637", "95955933", "13300900", "abc;" },
}, json));

foreach (var r in check.Results)
{
    if (r.Fits)
        Console.WriteLine($"{r.PartNumber}: uyar ({r.Match}) → {string.Join(" › ", r.Places![0].Group)}");
    else
        Console.WriteLine($"{r.PartNumber}: uymaz ({r.Reason})");
}

record CheckAnswer(string Vin, Vehicle Vehicle, CheckSummary Summary, List<CheckResult> Results);
record CheckSummary(int Asked, int Fits);
record CheckResult(string PartNumber, bool Fits, string? Match, List<string>? CatalogPartNumbers,
                   List<Place>? Places, List<string>? Markets, string? Reason);
record Place(List<string> Group, string? PageCode, string? PageTitle, string? Callout, string? Description,
             string? Usage, string? Quantity, List<string> Notes, bool NotServiced, string? CatalogPartNumber);

const { results } = await epc('/parts/check', {
  vin: 'KL1SF48W9BB261734',
  part_numbers: ['96829637', '95955933', '13300900', 'abc;'],
});

for (const r of results) {
  if (r.fits) console.log(`${r.part_number}: uyar (${r.match}) → ${r.places[0].group.join(' › ')}`);
  else console.log(`${r.part_number}: uymaz (${r.reason})`);
}

answer = epc("/parts/check", {
    "vin": "KL1SF48W9BB261734",
    "part_numbers": ["96829637", "95955933", "13300900", "abc;"],
})
for r in answer["results"]:
    if r["fits"]:
        print(r["part_number"], "uyar", r["match"], " › ".join(r["places"][0]["group"]))
    else:
        print(r["part_number"], "uymaz", r["reason"])

curl --compressed https://api.epc.vin/v1/vehicles/KL1SF48W9BB261734/parts \
  -H "Authorization: Bearer $EPC_API_KEY"

var list = await Read<PartsList>(await http.GetAsync("vehicles/KL1SF48W9BB261734/parts"));
Console.WriteLine($"{list.Vehicle.Model}: {list.Count} parça");

record PartsList(string Vin, Vehicle Vehicle, int Count, List<Part> Parts);
record Part(string PartNumber, string? Description, List<string> ReplacedBy,
            List<Alternative> Alternatives, List<Place> Places);
record Alternative(string PartNumber, string Relation, bool Interchangeable, List<string> Markets);

const list = await epc('/vehicles/KL1SF48W9BB261734/parts');
console.log(`${list.vehicle.model}: ${list.count} parça`);

parts = epc("/vehicles/KL1SF48W9BB261734/parts")
print(parts["vehicle"]["model"], parts["count"], "parça")

curl https://api.epc.vin/v1/parts/96829637 \
  -H "Authorization: Bearer $EPC_API_KEY"

var history = await Read<PartHistory>(await http.GetAsync("parts/96829637"));
var current = history.ReplacedBy.LastOrDefault() ?? history.PartNumber;   // bugünkü numara

record PartHistory(string PartNumber, List<string> ReplacedBy, List<string> Replaces,
                   List<Alternative> Alternatives);

const history = await epc('/parts/96829637');
const current = history.replaced_by.at(-1) ?? history.part_number;   // bugünkü numara

history = epc("/parts/96829637")
current = (history["replaced_by"] or [history["part_number"]])[-1]   # bugünkü numara

curl https://api.epc.vin/v1/usage \
  -H "Authorization: Bearer $EPC_API_KEY"

var usage = await Read<UsageAnswer>(await http.GetAsync("usage"));
Console.WriteLine($"Bugün {usage.Today.Vins}/{usage.Limits.VinsPerDay} VIN");

record UsageAnswer(string Account, Limits Limits, Today Today);
record Limits(int RequestsPerMinute, int VinsPerDay, int PartNumbersPerCheck);
record Today(int Vins, int Requests);

const { limits, today } = await epc('/usage');
console.log(`Bugün ${today.vins}/${limits.vins_per_day} VIN`);

usage = epc("/usage")
print(f"Bugün {usage['today']['vins']}/{usage['limits']['vins_per_day']} VIN")

async Task<List<CheckResult>> Fitting(string vin, IEnumerable<string> stock)
{
    var fitting = new List<CheckResult>();
    foreach (var chunk in stock.Chunk(500))
    {
        var answer = await Read<CheckAnswer>(await http.PostAsJsonAsync("parts/check",
            new { vin, part_numbers = chunk }, json));
        fitting.AddRange(answer.Results.Where(r => r.Fits));
    }
    return fitting;
}

foreach (var r in await Fitting("KL1SF48W9BB261734", new[] { "96829637", "95955933", "13300900" }))
    Console.WriteLine($"{r.PartNumber} {r.Match} {r.Places![0].Description}");

async function fitting(vin, stock) {
  const out = [];
  for (let i = 0; i < stock.length; i += 500) {
    const { results } = await epc('/parts/check', { vin, part_numbers: stock.slice(i, i + 500) });
    out.push(...results.filter((r) => r.fits));
  }
  return out;
}

for (const r of await fitting('KL1SF48W9BB261734', ['96829637', '95955933', '13300900'])) {
  console.log(r.part_number, r.match, r.places[0].description);
}

def fitting(vin, stock):
    out = []
    for i in range(0, len(stock), 500):
        answer = epc("/parts/check", {"vin": vin, "part_numbers": stock[i:i + 500]})
        out += [r for r in answer["results"] if r["fits"]]
    return out

for r in fitting("KL1SF48W9BB261734", ["96829637", "95955933", "13300900"]):
    print(r["part_number"], r["match"], r["places"][0]["description"])

static string Compact(string n) => new string(n.Where(char.IsLetterOrDigit).ToArray()).ToUpperInvariant();

// stock: numara → adet
async Task<List<(string Number, string? Description, int Count)>> InStock(string vin, Dictionary<string, int> stock)
{
    var have = stock.ToDictionary(s => Compact(s.Key), s => s.Value);
    var list = await Read<PartsList>(await http.GetAsync($"vehicles/{vin}/parts"));
    var found = new List<(string, string?, int)>();
    foreach (var p in list.Parts)
    {
        // Katalogdaki numara, sonra alternatifleri (önce bizim pazarımızınkiler).
        var candidates = new[] { p.PartNumber }.Concat(p.Alternatives.Select(a => a.PartNumber));
        var hit = candidates.FirstOrDefault(n => have.GetValueOrDefault(Compact(n)) > 0);
        if (hit != null) found.Add((hit, p.Description, have[Compact(hit)]));
    }
    return found;
}

const compact = (n) => n.replace(/[^0-9a-z]/gi, '').toUpperCase();

// stock: { "96829637": 3, ... } (numara → adet)
async function inStock(vin, stock) {
  const have = new Map(Object.entries(stock).map(([n, count]) => [compact(n), count]));
  const { parts } = await epc(`/vehicles/${vin}/parts`);
  const found = [];
  for (const p of parts) {
    // Katalogdaki numara, sonra alternatifleri (önce bizim pazarımızınkiler).
    const hit = [p.part_number, ...p.alternatives.map((a) => a.part_number)].find((n) => have.get(compact(n)) > 0);
    if (hit) found.push({ number: hit, description: p.description, count: have.get(compact(hit)) });
  }
  return found;
}

def compact(n):
    return "".join(ch for ch in n if ch.isalnum()).upper()

def in_stock(vin, stock):  # stock: {"96829637": 3, ...} (numara → adet)
    have = {compact(n): count for n, count in stock.items()}
    for p in epc(f"/vehicles/{vin}/parts")["parts"]:
        # Katalogdaki numara, sonra alternatifleri (önce bizim pazarımızınkiler).
        for n in [p["part_number"], *(a["part_number"] for a in p["alternatives"])]:
            if have.get(compact(n)):
                yield n, p["description"], have[compact(n)]
                break