# USITC HTS Tariff Data Scraper (`automation-lab/usitc-hts-tariff-data-scraper`) Actor

Extract official current U.S. Harmonized Tariff Schedule records by keyword, HTS code, chapter, or range. Get duty rates, units, footnotes, release metadata, and audit-ready raw fields. Export through Apify in JSON, CSV, or Excel.

- **URL**: https://apify.com/automation-lab/usitc-hts-tariff-data-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Business
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 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.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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/docs.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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

## USITC HTS Tariff Data Scraper

Search and export the **current official U.S. Harmonized Tariff Schedule (HTS)** from the United States International Trade Commission.

Use a product keyword, an HTS code or chapter, or an inclusive code range.
Get normalized duty rates, units, hierarchy, structured footnotes, and current release metadata without an API key or browser.

- 🔎 Search descriptions such as `headphones`, `lithium batteries`, or `coffee`
- 🧾 Look up a heading such as `8518` or a full 10-digit HTS number
- 📦 Export a chapter such as `85` or a bounded range such as `8501`–`8502`
- 🏛️ Read data directly from the official public USITC JSON service
- 🔁 Schedule repeat runs to refresh customs and landed-cost datasets

### What does USITC HTS Tariff Data Scraper do?

USITC HTS Tariff Data Scraper turns the official [Harmonized Tariff Schedule](https://hts.usitc.gov/) into clean dataset rows.
It supports three practical workflows: keyword discovery, code/chapter lookup, and range export.

Each record includes the formatted HTS number, description, statistical units, Column 1 General/MFN rate, special-program rate, Column 2 rate, hierarchy indent, footnotes, and release identity.
Rates and descriptions are normalized to plain text while structured footnotes remain available for compliance review.

Unlike browser crawlers, this Actor uses the official anonymous JSON endpoints.
That means fast starts, low memory use, no login, no proxy, and deterministic source URLs.

### Who is this HTS tariff data scraper for?

**Customs brokers and trade-compliance analysts**

- Find candidate headings from product descriptions.
- Export a chapter for classification research.
- Preserve official footnotes and release references in case files.

**Importers and ecommerce operators**

- Add current general and special duty text to product catalogs.
- Refresh landed-cost inputs after a new USITC revision.
- Review Column 2 rates and additional-duty notes before escalation.

**Freight-tech and landed-cost teams**

- Ingest structured HTS rows into internal APIs.
- Schedule range refreshes instead of maintaining manual spreadsheets.
- Keep source URLs and extraction timestamps for lineage.

**Data engineers and researchers**

- Export JSON, CSV, Excel, XML, or RSS through Apify datasets.
- Send tariff rows to a warehouse, Google Sheets, or a webhook.
- Compare release identifiers across scheduled runs.

### Why use this USITC HTS scraper?

- **Official source** — records come from public USITC HTS services.
- **No API key** — the useful v1 workflow requires no login or paid data provider.
- **Three query modes** — keyword, code/chapter, and range.
- **Current release metadata** — every row identifies the schedule revision used.
- **Plain-text rates** — embedded HTML footnote markers are removed from rate strings.
- **Structured notes** — footnote columns, markers, types, and values stay machine-readable.
- **Optional raw fields** — preserve the original official object when auditability matters.
- **Low overhead** — direct HTTP extraction runs with 256 MB of memory.
- **Automation ready** — use schedules, webhooks, API calls, Make, Zapier, or MCP.

### What US tariff data can you extract?

| Category | Output fields | Example |
|---|---|---|
| Identity | `htsno`, `htsCode` | `8501.10.20.00`, `8501102000` |
| Classification | `description`, `indent` | Product text and hierarchy depth |
| Units | `units` | `No.`, `kg`, `m²` |
| Duty rates | `generalRate`, `specialRate`, `column2Rate` | `6.7%`, `Free (...)`, `90%` |
| Notes | `footnotes`, `additionalDuties` | Section 301 references and additional duty text |
| Quotas | `quotaQuantity` | Official quota quantity when supplied |
| Release | `releaseName`, `releaseDescription`, `releaseTitle` | `2026HTSRev12` |
| Provenance | `queryMode`, `queryValue`, `sourceUrl`, `scrapedAt` | Reproducible query lineage |
| Audit data | `raw` | Original USITC object when enabled |

Empty official fields are returned as empty strings or arrays rather than invented values.
The Actor does not calculate a numeric landed cost or decide the legally correct classification for a product.

### How much does it cost to scrape USITC HTS tariff data?

This Actor uses pay-per-event pricing.
It charges **$0.005 per run** plus a tiered price per returned HTS record.
The formula-derived Starter/BRONZE rate is **$0.000022228 per record**; higher Apify plans receive volume discounts.

| Plan tier | Per HTS record | 1,000 records plus start |
|---|---:|---:|
| Free | $0.000025562 | $0.030562 |
| Starter / BRONZE | $0.000022228 | $0.027228 |
| Scale / SILVER | $0.000017338 | $0.022338 |
| Business / GOLD | $0.000013337 | $0.018337 |
| Platinum | $0.000010000 | $0.015000 |
| Diamond | $0.000010000 | $0.015000 |

The default input asks for only 20 records, keeping a first run small.
Final live prices are shown by Apify before a run starts and include platform infrastructure.

### How to search USITC HTS codes by keyword

1. Open [USITC HTS Tariff Data Scraper](https://apify.com/automation-lab/usitc-hts-tariff-data-scraper).
2. Choose **Keyword search**.
3. Enter a product phrase such as `headphones`.
4. Set the maximum number of records.
5. Click **Start**.
6. Open the dataset to inspect or export tariff rows.

Example input:

```json
{
  "mode": "keyword",
  "keyword": "headphones",
  "maxItems": 20,
  "includeRawFields": false
}
````

Keyword search uses the wording in official tariff descriptions.
Try a broader product noun when a commercial brand or internal SKU returns no matches.

### How to look up an HTS code or chapter

Choose code mode to export one code prefix or a complete two-digit chapter.
Dots, spaces, and hyphens are accepted and normalized.

```json
{
  "mode": "code",
  "htsCode": "8518",
  "maxItems": 500,
  "includeRawFields": false
}
```

Accepted code lengths are:

- 2 digits for a chapter, for example `85`
- 4 digits for a heading, for example `8518`
- 6 digits for a subheading
- 8 digits for a tariff line
- 10 digits for a statistical reporting number

Code mode includes descendant rows under the supplied prefix until `maxItems` is reached.
Chapter 99 is supported through the official export service rather than the less reliable chapter-rate endpoint.

### How to export an HTS code range

Range mode is useful for warehouse refreshes, classification catalogs, and bounded compliance datasets.
Both bounds must contain 4, 6, 8, or 10 digits.

```json
{
  "mode": "range",
  "rangeStart": "8501",
  "rangeEnd": "8502",
  "maxItems": 1000,
  "includeRawFields": true
}
```

The end bound includes its descendant tariff lines.
The Actor validates that the start does not sort after the end and fails closed on malformed values.
Use `maxItems` to control output volume during experiments.

### Input parameters

| Parameter | Type | Default | Required | Description |
|---|---|---|---|---|
| `mode` | string | `keyword` | Yes | `keyword`, `code`, or `range` |
| `keyword` | string | — | In keyword mode | Product phrase with at least two characters |
| `htsCode` | string | — | In code mode | 2-, 4-, 6-, 8-, or 10-digit code |
| `rangeStart` | string | — | In range mode | 4-, 6-, 8-, or 10-digit start |
| `rangeEnd` | string | — | In range mode | 4-, 6-, 8-, or 10-digit end |
| `maxItems` | integer | `20` | Yes | Maximum 1–10,000 records |
| `includeRawFields` | boolean | `false` | No | Include the original official object under `raw` |

Only the fields for the selected mode are used.
Invalid mode-specific input stops the run with a clear error instead of silently broadening the request.

### USITC HTS output example

```json
{
  "queryMode": "code",
  "queryValue": "8501",
  "htsno": "8501.10.20.00",
  "htsCode": "8501102000",
  "description": "Synchronous, valued not over $4 each",
  "indent": 3,
  "units": ["No."],
  "generalRate": "6.7% 1/",
  "specialRate": "Free (A,AU,B,BH,CL,CO,D,E,IL,JO,KR,MA,OM,P,PA,PE,S,SG)",
  "column2Rate": "90%",
  "footnotes": [
    {
      "columns": ["general"],
      "marker": "1",
      "value": "See 9903.88.02.",
      "type": "endnote"
    }
  ],
  "quotaQuantity": "",
  "additionalDuties": "",
  "releaseName": "2026HTSRev12",
  "releaseDescription": "2026 HTS Revision 12",
  "releaseTitle": "Revision 12 (2026)",
  "sourceUrl": "https://hts.usitc.gov/reststop/exportList?...",
  "scrapedAt": "2026-07-23T00:00:00.000Z"
}
```

The exact release and tariff text change when USITC publishes revisions.
Always rely on the release metadata included in your run rather than this static example.

### Understanding general, special, and Column 2 rates

`generalRate` represents the official Column 1 General/MFN text for the row.
`specialRate` contains free-trade-program or other special-treatment text when USITC supplies it.
`column2Rate` contains the official Column 2 rate.

These are strings because rates can contain compound wording, cents per unit, links to notes, or formulas rather than one percentage.
Do not parse every value as a simple number.

Footnotes may point to Chapter 99 provisions or other schedule notes.
A rate in a dataset is not a substitute for reviewing all applicable general notes, special programs, quotas, exclusions, and current legal measures.

### Tips for reliable tariff data workflows

- Start with `maxItems: 20` while refining a keyword or code.
- Prefer code or range mode for repeatable database refreshes.
- Store `releaseName` with every imported row.
- Compare release IDs before calculating a revision diff.
- Enable raw fields only when downstream users need source-level audit details.
- Keep rates as strings unless your own reviewed parser supports the exact rate form.
- Schedule runs after expected USITC revisions rather than polling continuously.
- Review Chapter 99 references and footnotes before using a base rate in landed-cost calculations.

### Automate HTS data with Apify integrations

**USITC HTS → Google Sheets**

Schedule a chapter export and append the latest tariff rows to a compliance workbook.
Use `releaseName` to label each refresh.

**USITC HTS → Slack or Microsoft Teams**

Send a webhook when a scheduled run reports a new release identifier.
Link analysts directly to the run dataset and official source URL.

**USITC HTS → Make or Zapier**

Trigger a range export, transform records, and update product master data.
Route rows with footnotes to a human compliance review queue.

**USITC HTS → data warehouse**

Use the API dataset endpoint to load JSON into Snowflake, BigQuery, PostgreSQL, or object storage.
Deduplicate on `releaseName` plus `htsCode`.

**Scheduled monitoring**

Run the same bounded input daily or weekly.
Compare release metadata first, then process changed rows in your own pipeline.

### Use the Apify API from Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/usitc-hts-tariff-data-scraper').call({
  mode: 'code',
  htsCode: '8518',
  maxItems: 100,
  includeRawFields: false,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

The call waits for completion and returns the run object.
For long exports, start the run asynchronously and poll its status.

### Use the Apify API from Python

```python
import os
from apify_client import ApifyClient

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/usitc-hts-tariff-data-scraper').call(run_input={
    'mode': 'keyword',
    'keyword': 'coffee',
    'maxItems': 50,
    'includeRawFields': False,
})

items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

Dataset exports are also available directly in JSON, CSV, Excel, XML, and RSS formats.

### Use the Apify API with cURL

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~usitc-hts-tariff-data-scraper/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "mode": "range",
    "rangeStart": "8501",
    "rangeEnd": "8502",
    "maxItems": 500,
    "includeRawFields": false
  }'
```

Use the returned run ID to check status and retrieve the default dataset.
Never commit your Apify token to source control.

### Use USITC HTS data with AI agents via MCP

USITC HTS Tariff Data Scraper is available to assistants that support the [Model Context Protocol](https://docs.apify.com/platform/integrations/mcp).

For Claude Code:

```bash
claude mcp add --transport http apify "https://mcp.apify.com?tools=automation-lab/usitc-hts-tariff-data-scraper"
```

For Claude Desktop, Cursor, or VS Code, add:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=automation-lab/usitc-hts-tariff-data-scraper"
    }
  }
}
```

Your client will ask you to authenticate with Apify through OAuth.

Example prompts:

- “Use `automation-lab/usitc-hts-tariff-data-scraper` to find current HTS descriptions for lithium batteries.”
- “Export HTS heading 8518 and summarize the General and Column 2 duty text.”
- “Build a structured dataset for HTS 8501 through 8502 and flag records with Chapter 99 footnotes.”

### Data freshness and source behavior

Every run requests `currentRelease` from USITC and attaches it to each row.
The Actor does not cache a historical tariff schedule or claim that an earlier run reflects today’s rules.

Keyword search is limited by the official search service and may return fewer records than range export.
The export endpoint is preferable for complete bounded code coverage.

The Actor retries temporary network, rate-limit, and server failures with bounded backoff.
If the official service returns invalid content after retries, the run fails rather than saving fabricated or stale rows.

### Is it legal to scrape USITC HTS data?

The Actor accesses publicly available U.S. government tariff data without bypassing login controls.
Users remain responsible for complying with applicable laws, source terms, sanctions, privacy obligations, and internal governance.

HTS classification can carry legal and financial consequences.
This Actor is a data extraction tool, not legal, tax, customs-brokerage, or tariff-classification advice.
Consult a qualified customs professional and official current notices before making import decisions.

Do not use the output to misdeclare goods, evade duties, or bypass trade restrictions.

### Limitations

- Keyword results depend on exact official description wording.
- The source may expose compound rate text that cannot be reduced to one percentage.
- Blank fields mean USITC supplied no value for that hierarchy row.
- The Actor does not determine country of origin or program eligibility.
- It does not combine base rates with every Chapter 99, Section 232, Section 301, quota, or antidumping measure.
- It returns the current release, not archived revision diffs.
- A `maxItems` limit intentionally truncates larger exports.
- Official endpoint availability and schema can change.

For legal classification, review the complete HTS, relevant notes, rulings, and current agency notices.

### Troubleshooting

**Why did keyword search return no rows?**

Try a broader generic product noun.
Official descriptions may not include a brand, marketing phrase, model number, or internal SKU.

**Why are some duty fields blank?**

Parent hierarchy rows often contain descriptions but no duty rate.
Inspect descendant tariff lines or use a more specific code.

**Why does my code input fail validation?**

Use 2, 4, 6, 8, or 10 digits in code mode.
Range bounds accept 4, 6, 8, or 10 digits.
Dots, spaces, and hyphens are allowed, but letters are rejected.

**Why did the run stop before the complete range?**

Increase `maxItems` up to 10,000.
The limit protects first-time users from unintentionally large datasets.

**What should I do after a temporary USITC outage?**

Read the run log for the final HTTP or JSON error and retry later.
The Actor already performs bounded automatic retries, so repeated immediate runs are usually unnecessary.

### Frequently asked questions

**How fast is the USITC HTS scraper?**

Small keyword and code runs usually finish in seconds because the Actor calls official JSON services directly and does not launch a browser.
Large ranges take longer to download and save.

**Can I download the results as CSV or Excel?**

Yes.
Open the Apify dataset and choose JSON, CSV, Excel, XML, or RSS.
You can also request an export format through the dataset API.

**Does this replace the official HTS website or a customs broker?**

No.
It makes official public records easier to automate, but classification and duty treatment require professional review and all applicable legal sources.

**Can I monitor tariff schedule revisions?**

Yes.
Schedule the same input and compare `releaseName` or `releaseTitle` between runs.
This Actor does not itself calculate row-by-row historical diffs.

**Does it need a USITC API key or Apify proxy?**

No USITC key, login, browser, or proxy is expected for the supported public endpoints.
An Apify account and token are needed when using the Apify API.

**Are rates numeric?**

No.
Rates remain normalized strings because the official schedule includes percentages, specific rates, compound rates, free-treatment codes, and formulas.

### Related trade and compliance actors

Extend a customs or trade-data workflow with these Automation Labs tools:

- [ImportYeti Trade Intelligence Scraper](https://apify.com/automation-lab/importyeti-trade-intelligence-scraper) — supplier and shipment intelligence.
- [Panjiva Trade Intelligence Scraper](https://apify.com/automation-lab/panjiva-trade-intelligence-scraper) — structured global trade records.
- [UN Comtrade Trade Data Scraper](https://apify.com/automation-lab/un-comtrade-trade-data-scraper) — official international trade statistics.
- [OFAC Sanctions List Export Scraper](https://apify.com/automation-lab/ofac-sanctions-list-export-scraper) — U.S. sanctions-list exports.
- [OpenSanctions Entities Scraper](https://apify.com/automation-lab/opensanctions-entities-scraper) — compliance entity records.
- [EU Sanctions Map Scraper](https://apify.com/automation-lab/eu-sanctions-map-scraper) — European sanctions measures.
- [ExportersIndia Suppliers Scraper](https://apify.com/automation-lab/exportersindia-suppliers-scraper) — supplier discovery.
- [TradeIndia Supplier Product Scraper](https://apify.com/automation-lab/tradeindia-supplier-product-scraper) — supplier and product catalog data.

Use each Actor according to its own source scope and legal guidance.

### Support

For a reproducible support request, include:

- the run URL or run ID;
- the exact input mode and query;
- the expected HTS code or description;
- the `releaseName` shown in output;
- a short explanation of the mismatch.

Do not include confidential product data, credentials, or personal information in a public issue.

# Actor input Schema

## `mode` (type: `string`):

Search descriptions by keyword, export an HTS code/chapter prefix, or export an inclusive HTS range.

## `keyword` (type: `string`):

Enter a product phrase used in the official tariff descriptions. Required in keyword mode.

## `htsCode` (type: `string`):

Enter a 2-digit chapter or a 4-, 6-, 8-, or 10-digit HTS code. Dots and spaces are accepted. Required in code mode.

## `rangeStart` (type: `string`):

Enter the first 4-, 6-, 8-, or 10-digit HTS code. Required in range mode.

## `rangeEnd` (type: `string`):

Enter the last 4-, 6-, 8-, or 10-digit HTS code. Required in range mode.

## `maxItems` (type: `integer`):

Stop after this many official records. Use a small value for a quick first run.

## `includeRawFields` (type: `boolean`):

Add the unmodified official source object under `raw` for audit and debugging workflows.

## Actor input object example

```json
{
  "mode": "keyword",
  "keyword": "headphones",
  "htsCode": "8518",
  "rangeStart": "8501",
  "rangeEnd": "8502",
  "maxItems": 20,
  "includeRawFields": false
}
```

# Actor output Schema

## `overview` (type: `string`):

Open the default dataset view with HTS codes, descriptions, units, duty rates, release metadata, and source links.

# 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 = {
    "mode": "keyword",
    "keyword": "headphones",
    "htsCode": "8518",
    "rangeStart": "8501",
    "rangeEnd": "8502",
    "maxItems": 20,
    "includeRawFields": false
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/usitc-hts-tariff-data-scraper").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 = {
    "mode": "keyword",
    "keyword": "headphones",
    "htsCode": "8518",
    "rangeStart": "8501",
    "rangeEnd": "8502",
    "maxItems": 20,
    "includeRawFields": False,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/usitc-hts-tariff-data-scraper").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 '{
  "mode": "keyword",
  "keyword": "headphones",
  "htsCode": "8518",
  "rangeStart": "8501",
  "rangeEnd": "8502",
  "maxItems": 20,
  "includeRawFields": false
}' |
apify call automation-lab/usitc-hts-tariff-data-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=automation-lab/usitc-hts-tariff-data-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "USITC HTS Tariff Data Scraper",
        "description": "Extract official current U.S. Harmonized Tariff Schedule records by keyword, HTS code, chapter, or range. Get duty rates, units, footnotes, release metadata, and audit-ready raw fields. Export through Apify in JSON, CSV, or Excel.",
        "version": "0.1",
        "x-build-id": "cCm55tmEvcAT9gagg"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~usitc-hts-tariff-data-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-usitc-hts-tariff-data-scraper",
                "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/automation-lab~usitc-hts-tariff-data-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-usitc-hts-tariff-data-scraper",
                "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/automation-lab~usitc-hts-tariff-data-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-usitc-hts-tariff-data-scraper",
                "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": [
                    "mode",
                    "maxItems"
                ],
                "properties": {
                    "mode": {
                        "title": "Query mode",
                        "enum": [
                            "keyword",
                            "code",
                            "range"
                        ],
                        "type": "string",
                        "description": "Search descriptions by keyword, export an HTS code/chapter prefix, or export an inclusive HTS range.",
                        "default": "keyword"
                    },
                    "keyword": {
                        "title": "Product keyword",
                        "type": "string",
                        "description": "Enter a product phrase used in the official tariff descriptions. Required in keyword mode."
                    },
                    "htsCode": {
                        "title": "HTS code or chapter",
                        "type": "string",
                        "description": "Enter a 2-digit chapter or a 4-, 6-, 8-, or 10-digit HTS code. Dots and spaces are accepted. Required in code mode."
                    },
                    "rangeStart": {
                        "title": "Range start",
                        "type": "string",
                        "description": "Enter the first 4-, 6-, 8-, or 10-digit HTS code. Required in range mode."
                    },
                    "rangeEnd": {
                        "title": "Range end",
                        "type": "string",
                        "description": "Enter the last 4-, 6-, 8-, or 10-digit HTS code. Required in range mode."
                    },
                    "maxItems": {
                        "title": "Maximum HTS records",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Stop after this many official records. Use a small value for a quick first run.",
                        "default": 20
                    },
                    "includeRawFields": {
                        "title": "Include raw USITC fields",
                        "type": "boolean",
                        "description": "Add the unmodified official source object under `raw` for audit and debugging workflows.",
                        "default": 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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```