# VIN Decoder API – Specs, Recalls & Safety (`sfoln/vin-decoder`) Actor

Decode VINs in bulk: make, model, year, trim, body, engine, fuel, drive, transmission and plant from official NHTSA data. Optional safety report per vehicle: recalls for its model year, complaint statistics, NCAP crash-test stars. $1 per 1,000 decoded VINs; safety report $2 per 1,000.

- **URL**: https://apify.com/sfoln/vin-decoder.md
- **Developed by:** [SFOLN LLC](https://apify.com/sfoln) (community)
- **Categories:** Developer tools, Automation, E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.90 / 1,000 decoded vins

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

Decode one VIN or tens of thousands in a single run and get a **clean, normalized vehicle record per VIN**: make, model, model year, trim, body class, vehicle type, engine (cylinders, displacement, HP), fuel type, drive type, transmission and assembly plant. Data comes from the official **NHTSA vPIC** database (US government public data), queried in batches of 50 VINs. Turn on the optional **vehicle safety report** to add, per vehicle, the NHTSA **recalls** issued for its model year, **complaint statistics** by component, **NCAP crash-test stars** and the number of defect investigations. Built for dealer and fleet tools, insurance and lending workflows, marketplaces and AI agents that need a quick, structured answer.

- Pay **only per decoded VIN** ($0.001) – mistyped VINs are caught locally (ISO 3779 check digit) and never charged; VINs NHTSA cannot decode are not charged either. The safety report adds $0.002 per vehicle NHTSA has safety data for.
- Partial decodes are kept and explained in `warnings` (e.g. "Incomplete VIN", "check digit does not calculate properly").
- Same JSON for the sync API, async runs and the Console; per-run spend cap honoured (`Maximum cost per run`).

### Input

| Field | Type | Default | Description |
| --- | --- | --- | --- |
| `vins` | string\[] | – | 17-character VINs (1981+), one per line; several VINs on one line can be separated by spaces, commas or semicolons. Spaces/dashes inside a VIN are removed, duplicates dropped. Objects with a `vin` key work too. |
| `maxVins` | integer | 10000 | Safety cap for this run; VINs beyond it are ignored and counted as `inputItemsDropped` in the `OUTPUT` record. |
| `includeSafetyReport` | boolean | false | Add `safetyReport` to each decoded VIN: NHTSA recalls for its make, model and model year, complaint statistics, NCAP crash-test stars and investigations. Charged as `vehicle-safety-report`; paid Apify plans only. |
| `concurrency` | integer | 5 | Parallel workers (VINs are still sent to NHTSA 50 per request). |
| `includeRaw` | boolean | false | Attach all ~150 raw vPIC fields to each record. |

```json
{
  "vins": ["1HGCM82633A004352", "JH4KA7561PC008269"],
  "includeSafetyReport": true
}
```

### Output

One dataset record per input VIN:

```json
{
  "input": "1HGCM82633A004352",
  "vin": "1HGCM82633A004352",
  "decoded": true,
  "make": "HONDA",
  "manufacturer": "AMERICAN HONDA MOTOR CO., INC.",
  "model": "Accord",
  "modelYear": 2003,
  "trim": "EX-V6",
  "series": null,
  "bodyClass": "Coupe",
  "vehicleType": "PASSENGER CAR",
  "doors": 2,
  "engineCylinders": 6,
  "displacementL": 3,
  "engineHp": 240,
  "engineModel": "J30A4",
  "fuelTypePrimary": "Gasoline",
  "fuelTypeSecondary": null,
  "electrificationLevel": null,
  "driveType": null,
  "transmissionStyle": "Automatic",
  "transmissionSpeeds": 5,
  "gvwr": "Class 1C: 4,001 - 5,000 lb (1,814 - 2,268 kg)",
  "plantCity": "MARYSVILLE",
  "plantState": "OHIO",
  "plantCountry": "UNITED STATES (USA)",
  "checkDigitOk": true,
  "errorCodes": ["0"],
  "errorText": "0 - VIN decoded clean. Check Digit (9th position) is correct",
  "suggestedVin": null,
  "status": "ok",
  "charged": true,
  "chargedEvent": "vin-decoded",
  "source": "nhtsa-vpic",
  "fetchedAt": "2026-10-14T10:00:00.000Z"
}
```

| Field | Description |
| --- | --- |
| `make`, `manufacturer`, `model`, `modelYear`, `trim`, `series` | Vehicle identity. |
| `bodyClass`, `vehicleType`, `doors`, `gvwr` | Body and weight class. |
| `engineCylinders`, `displacementL`, `engineHp`, `engineModel` | Engine. |
| `fuelTypePrimary`, `fuelTypeSecondary`, `electrificationLevel` | Fuel / EV information. |
| `driveType`, `transmissionStyle`, `transmissionSpeeds` | Drivetrain. |
| `plantCity`, `plantState`, `plantCountry` | Assembly plant. |
| `checkDigitOk` | Position 9 matches the computed ISO 3779 check digit. |
| `errorCodes`, `errorText`, `suggestedVin` | NHTSA decode diagnostics (`"0"` = clean). |
| `warnings` | Human-readable notes for partial decodes and skipped safety reports. |

Fields NHTSA has no data for are `null` (that does not mean the feature is absent on the vehicle).

With `includeSafetyReport`, each decoded VIN also gets a `safetyReport` (the same record, decoding fields left out here; one of 24 recalls and two of four rated variants shown):

```json
{
  "input": "1HGCM82633A004352",
  "vin": "1HGCM82633A004352",
  "decoded": true,
  "make": "HONDA",
  "model": "Accord",
  "modelYear": 2003,
  "safetyReport": {
    "make": "HONDA",
    "model": "Accord",
    "modelYear": 2003,
    "recallScope": "make-model-year",
    "recallCount": 24,
    "complaintCount": 2013,
    "overallRating": null,
    "investigationCount": 5,
    "recalls": [
      {
        "campaignNumber": "19V499000",
        "reportReceivedDate": "2019-06-27",
        "component": "AIR BAGS:FRONTAL:DRIVER SIDE:INFLATOR MODULE",
        "summary": "Honda (American Honda Motor Co.) is recalling certain 2003 Acura 3.2CL, … 2001-2007 Honda Accord, … These vehicles are equipped with driver frontal air bag inflators assembled as a recall remedy part or replacement service part, that may explode due to propellant degradation …",
        "consequence": "An inflator explosion may result in sharp metal fragments striking the driver or other occupants resulting in serious injury or death.",
        "remedy": "Honda will notify owners, and dealers will replace the driver frontal air bag inflator, free of charge. …",
        "manufacturer": "Honda (American Honda Motor Co.)",
        "parkIt": false,
        "parkOutside": false,
        "overTheAirUpdate": false,
        "nhtsaActionNumber": "EA15001",
        "url": "https://www.nhtsa.gov/recalls?nhtsaId=19V499000"
      }
    ],
    "complaints": {
      "total": 2013,
      "crashes": 158,
      "fires": 19,
      "injuries": 157,
      "deaths": 1,
      "firstFiled": "2002-07-15",
      "lastFiled": "2026-06-27",
      "topComponents": [
        { "component": "POWER TRAIN", "count": 926 },
        { "component": "AIR BAGS", "count": 324 },
        { "component": "SERVICE BRAKES", "count": 174 }
      ]
    },
    "safetyRatings": [
      { "vehicleId": 4739, "description": "2003 Honda Accord 2-DR. w/SAB", "overallRating": null, "frontCrashRating": null, "frontCrashDriverRating": 5, "frontCrashPassengerRating": 5, "sideCrashRating": null, "sideCrashDriverRating": null, "sideCrashPassengerRating": null, "sidePoleRating": null, "rolloverRating": 4, "rolloverRisk": null, "electronicStabilityControl": "No", "forwardCollisionWarning": "No", "laneDepartureWarning": "No", "matchesVehicle": true },
      { "vehicleId": 4737, "description": "2003 Honda Accord 4-DR.", "overallRating": null, "frontCrashRating": null, "frontCrashDriverRating": 5, "frontCrashPassengerRating": 5, "sideCrashRating": null, "sideCrashDriverRating": 4, "sideCrashPassengerRating": 5, "sidePoleRating": null, "rolloverRating": 4, "rolloverRisk": null, "electronicStabilityControl": "No", "forwardCollisionWarning": "No", "laneDepartureWarning": "No", "matchesVehicle": false }
    ],
    "modelAliases": []
  },
  "status": "ok",
  "charged": true,
  "chargedEvent": "vin-decoded",
  "source": "nhtsa-vpic",
  "fetchedAt": "2026-10-14T10:00:00.000Z"
}
```

| Field | Description |
| --- | --- |
| `safetyReport.recallCount`, `recalls` | Recalls issued for the vehicle's make, model and model year, newest first: campaign number, date, component, summary, consequence, remedy, `parkIt` / `parkOutside` warnings, related investigation, NHTSA link. Whether a recall was already repaired on this exact VIN is not public data. |
| `safetyReport.complaintCount`, `complaints` | Owner complaints to NHTSA for the model year: total, crashes, fires, injuries, deaths, first and last filing date and the ten components named most often (complaint texts are not included). |
| `safetyReport.overallRating`, `safetyRatings` | NCAP crash-test stars (1–5) of each tested variant (at most 6); `matchesVehicle` marks the variants that fit the decoded doors, drive and cab type, and `overallRating` is theirs. `null` = not rated. |
| `safetyReport.investigationCount` | NHTSA defect investigations opened for the model (from NCAP data). |
| `safetyReport.modelAliases` | NHTSA's own model names the data was found under when they differ from the decoded one (e.g. `F-150 SUPER CREW`). |

`safetyReport` is `null`, with the reason in `warnings`, when it was skipped: free plan, maximum cost per run reached, make, model or model year not decoded, or NHTSA unavailable. None of these is charged.

**`status`**: `ok` – vehicle data decoded (possibly partial, see `warnings`), charged. `not_found` – NHTSA could not decode anything (e.g. unregistered manufacturer) or returned no result for the VIN, **not charged**. `skipped_invalid` – wrong length, illegal characters (I, O, Q) or a wrong check digit on a North-American VIN; rejected locally, never sent upstream, not charged. `error` – NHTSA unavailable, not charged. `skipped_budget` / `skipped_free_plan` – not processed because of your cost cap or the free-plan limit. The key-value store record `OUTPUT` holds run totals.

### Pricing

Store discounts: the FREE and BRONZE tiers use the list prices below. SILVER receives 5% off; GOLD, PLATINUM and DIAMOND receive 10% off billable result events. The platform start fee is unchanged. Check the Actor's Store pricing table for the prices currently in effect.

Pay-per-event, no subscription:

| Event | Price | When charged |
| --- | --- | --- |
| `vin-decoded` | **$0.001** per VIN ($1 / 1,000) | once per VIN with `status: "ok"` |
| `vehicle-safety-report` | **$0.002** per VIN ($2 / 1,000) | with `includeSafetyReport`, once per decoded VIN NHTSA has recalls, complaints or ratings for (an empty report is free) |

Set **Maximum cost per run** to cap spend; when the cap is reached the remaining VINs are returned with `status: "skipped_budget"` and are not charged, and a safety report is only fetched when the budget also covers the VIN itself. Accounts on the Apify free plan can process up to 10 items per run, without the safety report; upgrade to any paid plan for full batches and safety reports.

### Use with AI agents (MCP)

Use this Actor from Claude, ChatGPT, Cursor, VS Code or any other MCP client through the [Apify MCP server](https://mcp.apify.com). Add this server URL to your client and sign in with your Apify account when asked:

```text
https://mcp.apify.com?tools=sfoln/vin-decoder
```

To run the MCP server locally instead, start `npx -y @apify/actors-mcp-server --tools sfoln/vin-decoder` with your `APIFY_TOKEN` in the environment.

Example prompt:

> Decode the VIN 1HGCM82633A004352 and list the recalls issued for that model year with their remedies.

Runs started by an agent are billed like any other run (see Pricing). Agents can cap what a run may spend with `maxTotalChargeUsd`.

### API usage

Run the Actor and get its dataset items in one call (the call waits up to 5 minutes for the run to finish):

```bash
curl -X POST "https://api.apify.com/v2/acts/sfoln~vin-decoder/run-sync-get-dataset-items" \
  -H "Authorization: Bearer <APIFY_TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{"vins": ["1HGCM82633A004352", "JH4KA7561PC008269"]}'
```

For large inputs, start the run asynchronously and download the dataset when it has finished:

```bash
## 1. Start a run: the response holds the run ID (data.id) and its dataset ID (data.defaultDatasetId)
curl -X POST "https://api.apify.com/v2/acts/sfoln~vin-decoder/runs" \
  -H "Authorization: Bearer <APIFY_TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{"vins": ["1HGCM82633A004352", "JH4KA7561PC008269"]}'
## 2. Repeat until data.status is SUCCEEDED (each call waits up to 60 s)
curl "https://api.apify.com/v2/actor-runs/<runId>?waitForFinish=60" -H "Authorization: Bearer <APIFY_TOKEN>"
## 3. Download the results (format=json, csv or xlsx)
curl "https://api.apify.com/v2/datasets/<defaultDatasetId>/items?format=json" -H "Authorization: Bearer <APIFY_TOKEN>"
```

Python ([apify-client](https://pypi.org/project/apify-client/)):

```python
from apify_client import ApifyClient

client = ApifyClient("<APIFY_TOKEN>")
run = client.actor("sfoln/vin-decoder").call(run_input={"vins": ["1HGCM82633A004352", "JH4KA7561PC008269"]})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)
```

Instead of polling, you can attach a webhook to the run (see Integrations). The API tab of this page shows the same calls for JavaScript and the Apify CLI.

#### More API examples

Synchronous (small batches):

```bash
curl -X POST "https://api.apify.com/v2/acts/sfoln~vin-decoder/run-sync-get-dataset-items?token=<APIFY_TOKEN>&timeout=120" \
  -H "Content-Type: application/json" \
  -d '{"vins": ["1HGCM82633A004352", "JH4KA7561PC008269"]}'
```

Asynchronous (large lists):

```bash
curl -X POST "https://api.apify.com/v2/acts/sfoln~vin-decoder/runs?token=<APIFY_TOKEN>" \
  -H "Content-Type: application/json" -d @vins.json
## → poll /v2/actor-runs/<runId>, then GET /v2/datasets/<defaultDatasetId>/items?format=csv
```

Python:

```python
from apify_client import ApifyClient
client = ApifyClient("<APIFY_TOKEN>")
run = client.actor("sfoln/vin-decoder").call(run_input={"vins": ["1HGCM82633A004352"]})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["vin"], item["make"], item["model"], item["modelYear"])
```

### Integrations

- **Make, Zapier and n8n:** run `sfoln/vin-decoder` with the Apify app (in n8n, the Apify node) and pass the dataset items to the next step of your workflow.
- **Google Sheets:** add the items to a sheet with the Google Sheets step of Make, Zapier or n8n, or download them as CSV or Excel from the run's Storage tab or the API (`format=csv` or `format=xlsx`).
- **Webhooks:** get a POST request when a run succeeds or fails: add a webhook in the Actor's Integrations tab, or pass `webhooks` when you start a run through the API.
- **Schedules:** run it hourly, daily or weekly with the same input from Apify Schedules; every run keeps its results in its own dataset.
- **More:** Slack, Google Drive, GitHub, LangChain, LlamaIndex and other [Apify integrations](https://docs.apify.com/platform/integrations).

### Related Actors

- [Currency Exchange Rates API](https://apify.com/sfoln/fx-rates)
- [Geocoding API – Address to Coordinates](https://apify.com/sfoln/geocode-address)
- [Phone Number Validator](https://apify.com/sfoln/phone-validator)

See [all our Actors](https://apify.com/sfoln) on Apify Store.

### FAQ

#### How much does it cost, and am I charged for failed items?

You pay per event at the prices under Pricing above, plus a run start fee of $0.00005 per GB of memory, with no subscription; platform usage is included. Errors and skipped items (`skipped_…` statuses) are never charged; a lookup that finds nothing is charged only where Pricing says so, and every record's `charged` field shows whether it was billed. Set **Maximum cost per run** to cap what a single run can spend.

#### How fresh is the data?

Each run queries its source while it runs, so you get what the source returns at that moment. Source-specific details, such as how often a provider refreshes its own database, are under Limits & notes.

#### What are the limits?

Per-run caps (for example the maximum number of items) are listed under Input, source limits under Limits & notes, and the free-plan limit under Pricing. For big batches, start the run asynchronously (see API usage) and read the dataset when it has finished.

#### Can I schedule runs or get results by webhook?

Yes. Create a schedule in Apify Console to run it hourly, daily or weekly with the same input, and add a webhook to get a POST request when a run finishes (see Integrations).

#### What does this Actor record about my runs?

This Actor records operational metrics about each run (item counts, duration, charges, error codes and a pseudonymous hash of your Apify user ID) to monitor reliability and costs. It never stores your input or results.

#### Does the safety report tell me whether this exact car still has an open recall?

No. NHTSA publishes recalls per make, model and model year, so the report lists every recall issued for the vehicle's model year (recallScope "make-model-year"). Whether a recall was already repaired on one specific VIN is only available from the manufacturer or NHTSA's VIN lookup page, not from a public API. Each recall has a link to its NHTSA page.

#### What is in the vehicle safety report?

Recalls (campaign number, date, component, summary, consequence, remedy, park-it and park-outside flags), complaint statistics (total, crashes, fires, injuries, deaths, first and last filing date, the ten components named most often), NCAP crash-test stars of each tested variant with the best match to the decoded VIN marked, and the number of NHTSA defect investigations. Complaint texts are not included.

#### Which VINs can be decoded?

17-character VINs from model year 1981 on. Coverage is best for vehicles sold in the United States; vehicles built for other markets may decode partially or not at all, and NHTSA has no safety data for models not sold in the US.

#### How do I get help?

Open an issue in the Actor's Issues tab and include the link to the run, so we can reproduce the problem. Feature requests are welcome there too.

### Limits & notes

- Data source: NHTSA Product Information Catalog and Vehicle Listing (vPIC), US government public data. Coverage is best for vehicles sold in the United States; vehicles built for other markets may decode partially or not at all.
- 17-character VINs only (model year 1981 and later). The check digit is enforced for North-American VINs (first character 1–5) and reported as a warning for others.
- Safety reports come from api.nhtsa.gov (recalls, complaints, NCAP ratings). They are looked up once per make, model and model year of the run, so a fleet of one model costs one set of lookups; the first report of a popular model takes a few seconds (its complaint list runs to a few MB).
- Recalls are listed for the model year, not the VIN: NHTSA does not publish VIN-level recall completion. Recalls of replacement equipment (e.g. aftermarket pedals) filed against the model are included as NHTSA lists them.
- Not included: vehicle history, ownership, accidents, market value or license-plate lookup.
- NHTSA applies automated traffic control; very large runs may slow down but are retried automatically.

# Actor input Schema

## `vins` (type: `array`):

Vehicle Identification Numbers (17 characters, 1981+), one per line; several VINs on one line can be separated by spaces, commas or semicolons. Spaces and dashes inside a VIN are removed, duplicates dropped. Objects with a `vin` field are accepted too. Accounts on the Apify free plan can process up to 10 VINs per run.

## `maxVins` (type: `integer`):

Safety cap on the number of VINs processed in this run.

## `includeSafetyReport` (type: `boolean`):

Add NHTSA safety data for each decoded vehicle: recalls issued for its make, model and model year, complaint statistics by component, NCAP crash-test star ratings and the number of NHTSA investigations. Charged as `vehicle-safety-report` ($0.002) per VIN with safety data, on paid Apify plans only.

## `concurrency` (type: `integer`):

Parallel workers. VINs are sent to NHTSA in batches of 50 regardless of this value.

## `includeRaw` (type: `boolean`):

Attach all ~150 raw NHTSA vPIC fields to each record (larger output).

## Actor input object example

```json
{
  "vins": [
    "1HGCM82633A004352",
    "JH4KA7561PC008269"
  ],
  "maxVins": 10000,
  "includeSafetyReport": false,
  "concurrency": 5,
  "includeRaw": false
}
```

# Actor output Schema

## `results` (type: `string`):

No description

## `safetyReports` (type: `string`):

No description

## `summary` (type: `string`):

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "vins": [
        "1HGCM82633A004352",
        "JH4KA7561PC008269"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("sfoln/vin-decoder").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = { "vins": [
        "1HGCM82633A004352",
        "JH4KA7561PC008269",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("sfoln/vin-decoder").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "vins": [
    "1HGCM82633A004352",
    "JH4KA7561PC008269"
  ]
}' |
apify call sfoln/vin-decoder --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,sfoln/vin-decoder"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/5bgJ1s8qGh2KQpItl/builds/9Dy6Qm0Rlu1KF5kKw/openapi.json