Parsing Japanese Car Auction Data: Sheets, Grades and Bids

Japan runs the largest used-car auction network in the world. Hundreds of thousands of vehicles pass through auction houses every week, each one graded by an independent inspector and described on a standardized auction sheet. For exporters, dealers and resale platforms, that data is gold — but it is also notoriously hard to extract.

This guide explains the structure of Japanese auction data and shows how to pull it — grades, inspection sheets and lot details — through one unified API.

Why Japanese auction data is unique

Most marketplaces list cars at an asking price set by a seller. Japanese auctions are different: each car is independently inspected and graded before it goes under the hammer, then sold to the highest bidder. That produces two kinds of structured data you don’t get from ordinary listings:

• Auction grade — an overall condition score (commonly 5, 4.5, 4, 3.5 … down to R for repaired/accident cars)
• Interior grade — a letter (A–D) for interior condition
• The auction sheet — a diagram of the body with coded marks for scratches, dents and repairs, plus inspector notes

Combined with mileage and the standard make/model/year fields, the grade and sheet let a buyer assess a car they will never physically see — which is the entire basis of the Japanese export trade.

The auction-sheet data model

Through Carapis, an auction lot comes back as a normalized record. The auction-specific fields sit alongside the same vehicle fields you’d get from any other source:

import requests
 
API_KEY = "your_carapis_key"
 
resp = requests.get(
    "https://api.carapis.com/v2/listings",
    params={
        "source": "goo-net",   # Japanese used-car & auction data
        "make": "Toyota",
        "model": "Land Cruiser",
        "limit": 50,
    },
    headers={"Authorization": f"Bearer {API_KEY}"},
)
 
for lot in resp.json()["results"]:
    print(
        lot["make"],
        lot["model"],
        lot["year"],
        f"grade={lot.get('auctionGrade')}",
        f"interior={lot.get('interiorGrade')}",
        f"{lot.get('mileage'):,} km" if lot.get("mileage") else "",
    )

The key auction fields:

• auctionGrade — overall condition score (e.g. "4.5", "R")
• interiorGrade — interior letter grade ("A"–"D")
• inspectionSheet — structured marks and inspector notes
• lotNumber / auctionHouse — provenance of the lot

Filtering by grade

The first thing most exporters do is filter out low-grade and accident-history cars. Because the grade is a normalized field, this is a simple comparison — no parsing of free-text sheets required:

def is_export_grade(lot, min_grade=4.0):
    grade = lot.get("auctionGrade")
    if grade is None:
        return False
    # "R" marks repaired / accident vehicles — exclude regardless of number.
    if grade == "R":
        return False
    try:
        return float(grade) >= min_grade
    except ValueError:
        return False
 
 
lots = resp.json()["results"]
clean = [lot for lot in lots if is_export_grade(lot, min_grade=4.0)]
print(f"{len(clean)} of {len(lots)} lots are grade 4.0+ with no accident history")

Reading the inspection sheet

The auction sheet is where the detail lives. Each panel of the car carries coded marks — A for scratches, U for dents, W for wavy repairs, and so on. Carapis returns these as structured entries rather than a scanned image, so you can score condition programmatically:

# Weight a few common sheet codes by how much they matter to a buyer.
CODE_SEVERITY = {
    "A1": 1, "A2": 2, "A3": 3,   # scratches, increasing size
    "U1": 2, "U2": 3, "U3": 4,   # dents
    "W1": 1, "W2": 2,            # wavy / minor repair
    "S": 1,                      # rust
}
 
 
def condition_score(lot):
    """Lower is better — sums the severity of every mark on the sheet."""
    marks = (lot.get("inspectionSheet") or {}).get("marks", [])
    return sum(CODE_SEVERITY.get(m.get("code", ""), 0) for m in marks)
 
 
ranked = sorted(clean, key=condition_score)
for lot in ranked[:10]:
    print(f"{lot['model']} {lot['year']} — grade {lot['auctionGrade']}, "
          f"condition score {condition_score(lot)}")

A high auction grade with a low mark-severity score is the sweet spot: a car the inspector liked and with a clean sheet to back it up.

Estimating landed cost for export

The point of all this data is usually one number — what the car will cost delivered. Auction price is only the start; you layer on auction fees, transport and shipping:

def landed_cost(lot, fx_rate, shipping=1200, auction_fee=0.05):
    """Rough landed cost in your currency."""
    hammer = lot.get("price")  # JPY
    if not hammer:
        return None
    with_fees = hammer * (1 + auction_fee)
    return round(with_fees * fx_rate + shipping)
 
 
for lot in ranked[:5]:
    cost = landed_cost(lot, fx_rate=0.0067)
    print(f"{lot['model']} {lot['year']}: ~{cost:,} landed" if cost else "no price")

Best practices for auction data

1. Treat grade and sheet as separate signals. A high grade with a heavily marked sheet deserves a closer look.
2. Always exclude R-graded lots unless you specifically want repaired cars — the number alone can look fine.
3. Normalize mileage units. Japanese data is in kilometers; convert before comparing with other markets.
4. Pull lot provenance (auctionHouse, lotNumber) so buyers can verify the source.
5. Cache exchange rates, not lots. Auction inventory turns over fast — re-query rather than caching stale lots.

Conclusion

Japanese auction data is among the richest structured used-car data anywhere, but the sheets and grades are locked behind inspection systems that are painful to scrape directly. A unified API hands you the grade, the structured sheet and the standard vehicle fields together — so you can filter, score and price export inventory in code instead of fighting auction-house front-ends.

Get started → • View API reference →

Related resources:

• Choosing car data sources
• Car data parsing guide
• Import / export solution
• Encar data parser & API