# NHTSA Vehicle Recalls Tracker - Free API (`wiry_kingdom/nhtsa-recalls-tracker`) Actor

Pull US vehicle recalls from NHTSA. Filter by make, model, year, component, date. Returns recall components, consequences, remedies, OTA flags, campaign numbers. For class action lawyers, auto journalists, used car dealers, insurance.

- **URL**: https://apify.com/wiry\_kingdom/nhtsa-recalls-tracker.md
- **Developed by:** [Mohieldin Mohamed](https://apify.com/wiry_kingdom) (community)
- **Categories:** Business, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.
Actors are written with capital "A".

## 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.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## NHTSA Vehicle Recalls Tracker

**Pull US vehicle recalls from NHTSA. Filter by make, model, year, component, or date. Free official NHTSA API. No key required.**

This actor uses the official NHTSA `recallsByVehicle` API to extract structured vehicle recall data with full campaign details. Tested on real data: 10 Tesla Model 3 2023 recalls (including the famous FSD Beta unsafe-at-intersections recall and curtain airbag defect), 22 Ford F-150 2022 recalls, 4 Honda Civic 2020 recalls.

### What you actually get

Real recalls returned in test runs:

| Campaign ## | Vehicle | Component | Issue |
|------------|---------|-----------|-------|
| `22V844000` | Tesla Model 3 2023 | Tail lights | Tail lights fail intermittently. OTA fix. |
| `21V834000` | Tesla Model 3 2023 | Side curtain airbag | Curtain airbag improperly secured |
| `23V085000` | Tesla Model 3 2023 | FSD Beta software | "Vehicle to act unsafe around intersections" |
| `23V434000` | Tesla Model 3 2023 | Battery disconnect | Pyrotechnic battery disconnect defect |
| `23V838000` | Tesla Model 3 2023 | Autosteer | Driver misuse risk |
| `24V064000` | Honda Civic 2020 | Occupant classification airbag sensor | Sensor failure |

Each row includes:
- Make, Model, Model Year
- Manufacturer (legal name)
- NHTSA Campaign Number (the unique recall ID)
- Component (which system: airbags, brakes, electrical, powertrain, etc.)
- Summary (full text description of the defect)
- Consequence (what could happen — crash risk, injury risk, fire risk)
- Remedy (how the manufacturer is fixing it — free repair, OTA update, replacement)
- Notes (additional info)
- Report received date
- Over-the-air update flag (Tesla-style fixes vs physical service)
- parkIt flag (severe — don't drive at all)
- parkOutside flag (severe — fire risk, don't park indoors)
- NHTSA Action Number (when there's a separate enforcement action like an investigation)
- Direct link to the NHTSA recall page

### Why use this

**There are over 1.4 billion vehicles registered in the US**, and NHTSA issues 800-1,000 recalls per year covering tens of millions of vehicles. Recall data is essential for:

- **Class-action lawyers** — find new defect campaigns to build cases around. Plaintiffs' firms pay $200-2,000/month for similar tools.
- **Auto journalists** — break stories on safety defects. Hot recalls (Park It! / Park Outside! flags) are page-one content.
- **Used car dealers** — check inventory for unrepaired open recalls before listing cars
- **Insurance companies** — adjust risk models based on vehicle defect history
- **Fleet managers** — proactively schedule recall service for company vehicles
- **Auto parts suppliers** — track which OEMs are recalling which components (= replacement parts demand)
- **Consumers + consumer advocates** — watchdog tools, comparison sites, used car research
- **Investors shorting auto stocks** — bad recalls move stocks (Tesla -7% on FSD recall, GM -5% on Chevy Bolt fire recall)

Commercial alternatives:
- **Carfax / AutoCheck** — $40-100 per individual VIN report, no bulk API for businesses
- **NHTSA's own website** — free but UI-only, no bulk export, no scheduling
- **NHTSA's API** — what we use, but raw API requires custom integration code
- **Federal Recall Database services** — $500-5,000/year for similar bulk access

This actor delivers structured JSON output with pay-per-event pricing — much cheaper than annual subscriptions for moderate-volume use.

### Honest limitations

- **NHTSA only covers recalls, not customer complaints.** For complaint data (which can be a leading indicator of recalls) NHTSA has a separate `complaintsByVehicle` endpoint we don't currently call.
- **NHTSA only covers US recalls.** For Canada (Transport Canada), UK (DVSA), EU (RAPEX), Australia (PSA), and other countries, you need different APIs.
- **Vehicle make/model strings must match NHTSA's spelling exactly.** It's `Tesla` not `tesla` (case-insensitive in practice but spaces and hyphens matter), `Model 3` not `Model3`. We pass them through unchanged.
- **NHTSA returns dates in DD/MM/YYYY format** (despite being a US agency). We parse them and convert to ISO 8601.
- **The "since date" filter is applied client-side after fetching** because NHTSA's API doesn't natively support date filtering. The full recall list for a vehicle is always fetched.
- **Some recalls cover multiple model years** (e.g. 2017-2023 Model 3). We only return them when querying for a year that's in the affected range.

### How to use

1. Click **Try for free** (or **Start**)
2. Add vehicles to **Vehicles** as JSON: `[{"make":"Tesla","model":"Model 3","modelYear":2023}]`
3. Optionally set **Component filter** (e.g. `"AIR BAG"` to only get airbag recalls)
4. Optionally set **Since date** (e.g. `"2024-01-01"` to only get recent recalls)
5. Click **Start**

### Output

```json
{
    "make": "TESLA",
    "model": "MODEL 3",
    "modelYear": 2023,
    "manufacturer": "Tesla, Inc.",
    "nhtsaCampaignNumber": "23V085000",
    "component": "STEERING:AUTOMATED/ADAPTIVE STEERING",
    "summary": "Tesla, Inc. (Tesla) is recalling certain 2016-2023 Model S, Model X, 2017-2023 Model 3, and 2020-2023 Model Y vehicles equipped with Full Self-Driving Beta (FSD Beta) software or pending installation. The FSD Beta system may allow the vehicle to act unsafe around intersections...",
    "consequence": "FSD Beta software that allows a vehicle to exceed speed limits or travel through intersections in an unlawful or unpredictable manner increases the risk of a crash.",
    "remedy": "Tesla will release an over-the-air (OTA) software update, free of charge. Owner notification letters were mailed April 15, 2023.",
    "notes": "Owners may also contact the National Highway Traffic Safety Administration Vehicle Safety Hotline at 1-888-327-4236...",
    "reportReceivedDate": "2023-02-15T00:00:00.000Z",
    "overTheAirUpdate": true,
    "parkIt": false,
    "parkOutside": false,
    "nhtsaActionNumber": "EA22002",
    "recallUrl": "https://www.nhtsa.gov/recalls?nhtsaId=23V085000",
    "extractedAt": "2026-04-15T21:50:00.000Z"
}
````

### Pricing

This actor uses **pay-per-event** pricing — extremely cheap for use cases that need either spot-checks or bulk historical analysis:

- **Actor start**: $0.05 per run
- **Per recall extracted**: $0.01 per recall pushed to dataset

**Example costs:**

- 1 vehicle × ~10 recalls = $0.15 per check
- Bulk audit of 100 used car inventory → ~$10
- Daily snapshot of new recalls for 50 fleet vehicles → ~$15/month
- Full recall history for a class-action prep on one make/model → $1-5

For comparison: Carfax charges ~$40 per single VIN report. NHTSA Commercial API access plans run $500-5,000/year. This actor pays for itself within the first day.

Free Apify tier members get $5/month in platform credits, which covers ~500 recalls per month.

### Tips

- **Schedule weekly runs** to track new recalls on vehicles you care about
- **Use `componentFilter: "AIR BAG"`** to focus on a specific defect type (airbags, brakes, electrical, powertrain, fuel system, steering, structure, tires, exterior lighting)
- **Use `sinceDate`** with weekly runs to only get NEW recalls and avoid duplicate processing
- **Combine multiple makes/models in one run** for portfolio monitoring
- **Watch for `parkIt: true` or `parkOutside: true`** flags — these are severe recalls that can move stock prices
- **Pair with the SEC EDGAR Filing Monitor** to correlate recalls with 8-K material event filings (auto manufacturers often file 8-Ks for major recalls)

### Source

This actor uses the official **NHTSA Vehicle Safety Recall API** at `https://api.nhtsa.gov/recalls/recallsByVehicle`. The API is documented at https://www.nhtsa.gov/nhtsa-datasets-and-apis. It's free, public, requires no authentication, and is maintained by NHTSA itself as a public service.

### License

This actor is MIT licensed. The recall data it returns is from NHTSA and is in the **public domain** (works of the US federal government are not subject to copyright). You may use the extracted data for any purpose, including commercial use, with no restrictions.

# Actor input Schema

## `vehicles` (type: `array`):

List of vehicles as objects: { make, model, modelYear }. Example: \[{"make":"Tesla","model":"Model 3","modelYear":2023}]. Each vehicle gets all matching recalls.

## `componentFilter` (type: `string`):

Optional: only return recalls whose component contains this text. Example: 'AIR BAG' to filter to airbag recalls only.

## `sinceDate` (type: `string`):

Optional: only return recalls reported on or after this date.

## `extractCampaignDetails` (type: `boolean`):

If true, also fetch the full campaign details (consequence, remedy, manufacturer notes) for each recall. Already included by default.

## `proxyConfiguration` (type: `object`):

Optional Apify Proxy. NHTSA's API is friendly to direct access — proxy rarely needed.

## Actor input object example

```json
{
  "vehicles": [
    {
      "make": "Tesla",
      "model": "Model 3",
      "modelYear": 2023
    },
    {
      "make": "Ford",
      "model": "F-150",
      "modelYear": 2022
    }
  ],
  "componentFilter": "",
  "sinceDate": "",
  "extractCampaignDetails": true,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `dataset` (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 = {
    "vehicles": [
        {
            "make": "Tesla",
            "model": "Model 3",
            "modelYear": 2023
        },
        {
            "make": "Ford",
            "model": "F-150",
            "modelYear": 2022
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("wiry_kingdom/nhtsa-recalls-tracker").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 = { "vehicles": [
        {
            "make": "Tesla",
            "model": "Model 3",
            "modelYear": 2023,
        },
        {
            "make": "Ford",
            "model": "F-150",
            "modelYear": 2022,
        },
    ] }

# Run the Actor and wait for it to finish
run = client.actor("wiry_kingdom/nhtsa-recalls-tracker").call(run_input=run_input)

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

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

```

## CLI example

```bash
echo '{
  "vehicles": [
    {
      "make": "Tesla",
      "model": "Model 3",
      "modelYear": 2023
    },
    {
      "make": "Ford",
      "model": "F-150",
      "modelYear": 2022
    }
  ]
}' |
apify call wiry_kingdom/nhtsa-recalls-tracker --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=wiry_kingdom/nhtsa-recalls-tracker",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "NHTSA Vehicle Recalls Tracker - Free API",
        "description": "Pull US vehicle recalls from NHTSA. Filter by make, model, year, component, date. Returns recall components, consequences, remedies, OTA flags, campaign numbers. For class action lawyers, auto journalists, used car dealers, insurance.",
        "version": "0.1",
        "x-build-id": "tcHQvIgHcf6dSLQLn"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/wiry_kingdom~nhtsa-recalls-tracker/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-wiry_kingdom-nhtsa-recalls-tracker",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/wiry_kingdom~nhtsa-recalls-tracker/runs": {
            "post": {
                "operationId": "runs-sync-wiry_kingdom-nhtsa-recalls-tracker",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/wiry_kingdom~nhtsa-recalls-tracker/run-sync": {
            "post": {
                "operationId": "run-sync-wiry_kingdom-nhtsa-recalls-tracker",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "vehicles"
                ],
                "properties": {
                    "vehicles": {
                        "title": "Vehicles to check",
                        "type": "array",
                        "description": "List of vehicles as objects: { make, model, modelYear }. Example: [{\"make\":\"Tesla\",\"model\":\"Model 3\",\"modelYear\":2023}]. Each vehicle gets all matching recalls.",
                        "default": [
                            {
                                "make": "Tesla",
                                "model": "Model 3",
                                "modelYear": 2023
                            },
                            {
                                "make": "Ford",
                                "model": "F-150",
                                "modelYear": 2022
                            }
                        ]
                    },
                    "componentFilter": {
                        "title": "Component filter (substring match)",
                        "type": "string",
                        "description": "Optional: only return recalls whose component contains this text. Example: 'AIR BAG' to filter to airbag recalls only.",
                        "default": ""
                    },
                    "sinceDate": {
                        "title": "Since date (YYYY-MM-DD)",
                        "type": "string",
                        "description": "Optional: only return recalls reported on or after this date.",
                        "default": ""
                    },
                    "extractCampaignDetails": {
                        "title": "Extract campaign details",
                        "type": "boolean",
                        "description": "If true, also fetch the full campaign details (consequence, remedy, manufacturer notes) for each recall. Already included by default.",
                        "default": true
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Optional Apify Proxy. NHTSA's API is friendly to direct access — proxy rarely needed.",
                        "default": {
                            "useApifyProxy": false
                        }
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
