# UK Import Duty & Landed Cost Calculator (`kestraz/uk-import-duty-landed-cost`) Actor

Duty, VAT, excise and control flags for UK imports, straight from the HMRC Trade Tariff. Returns every underlying measure with its regulation ID, and tells you when the answer is ambiguous instead of guessing.

- **URL**: https://apify.com/kestraz/uk-import-duty-landed-cost.md
- **Developed by:** [Kestraz Support](https://apify.com/kestraz) (community)
- **Categories:** E-commerce, Integrations
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $120.00 / 1,000 landed cost calculations

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 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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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

## UK Import Duty & Landed Cost Calculator

**Know what a shipment actually costs to land in the UK — before you quote it.**

Give it a commodity code, a country of origin and a CIF value. Get back the
customs duty, the import VAT, the excise flag, every control and restriction, and
a full landed-cost breakdown — live from HMRC's UK Integrated Online Tariff.

Built for one destination and complete on it: every charge that lands on a UK
import declaration, resolved from the official tariff and traceable back to it.

And when the honest answer is *"it depends"*, this Actor says so — in a
structured, machine-readable way — instead of quietly returning a number that's
wrong.

***

### Why this exists

Most landed-cost tools return a single confident number. The tariff data
underneath frequently does not support one.

Three examples, all real, all reproducible here today:

- **Cotton t-shirts** carry **two** UK VAT rates — 0% and 20%. Which applies
  depends on whether the garments are child-sized. The commodity code doesn't say.
- **Ceramic tiles from China** carry **107 anti-dumping measures**, one per
  exporter, from 0% to a 69.70% residual. Which applies depends on *which company*
  made the goods.
- **Wine** is charged at **£12.00 per hectolitre** — not a percentage. A tool that
  only takes a value is structurally incapable of getting this right.

A tool that picks one and moves on is guessing with your client's money. This one
hands you the candidates, tells you exactly what's missing, and cites the
regulation behind every figure it does calculate.

### What you pay for

The rule is **"did you get usable tariff data?"** — not "did we produce a single
number". Published in full, because you should never be surprised by an invoice.

| What you asked for | What you got back | Charged |
|---|---|---|
| Commodity code → full determination | `RESOLVED` — duty, VAT, total | **Full determination** |
| Commodity code → consignment £135 or less | `RESOLVED_LOW_VALUE_REGIME` | **Full determination** |
| Commodity code → several measures compete | `AMBIGUOUS_MULTIPLE_MEASURES` + every candidate | **Full determination** |
| Commodity code → specific duty, no quantity given | `REQUIRES_QUANTITY` + the unit needed | **Full determination** |
| Commodity code → question can't be answered | `NOT_COMPUTABLE` | **Nothing** |
| Bad input, unknown code, no search hits | `NOT_COMPUTABLE` | **Nothing** |
| Plain-text description → candidate codes | ranked candidates | **Code lookup** (cheaper) |
| Any row inside a bulk run | as above | **At that row's bulk tier** |

**Ambiguous answers are charged in full, and that's deliberate.** When t-shirts
come back with two VAT rates, or ceramic tiles with 107 exporter-specific
anti-dumping rates, you've received the complete measure set and the reason no
single number exists. That took the same work as a clean answer — and it *is* the
answer. It's what stops you filing a declaration on a rate that was never going
to apply.

**"I don't know" is free.** If we return `NOT_COMPUTABLE` you are not charged,
even when we hand you the full measure set alongside it. Some commodities —
collectors' items, banknotes — come back with measures but no unconditional duty
measure, so the question can't be answered. You keep the data; you don't pay.

### What you get back

Every response carries a top-level **`status`**, so your system always knows how
much to trust the number:

| Status | Meaning |
|---|---|
| `RESOLVED` | One applicable measure. Duty, VAT and total landed cost computed. |
| `RESOLVED_LOW_VALUE_REGIME` | Consignment £135 or less. Fully computed — but the VAT shown is **not collected at the border**; the seller charges UK VAT at the point of sale. |
| `AMBIGUOUS_MULTIPLE_MEASURES` | More than one measure could apply. All candidates returned, nothing computed. |
| `REQUIRES_QUANTITY` | Specific or compound duty (per litre, per kg, per 1,000 items). Give us the quantity and we'll compute it. |
| `NOT_COMPUTABLE` | Out of scope or unresolvable — with a plain-English reason. Never charged. |

Plus, on every response regardless of status:

- **Every underlying measure** — type, geographic area, validity dates, rate,
  footnotes and **regulation ID**. Audit anything.
- **Itemised charge lines**, each traceable: a regulation ID where the tariff
  publishes one, and a measure reference plus a `verifyUrl` you can open and check
  on gov.uk in every case. Each line carries `collectedAtBorder`, so you know
  what's actually payable on import.
- **Preferential rates with their conditions** — not just "0% available", but the
  document code you must declare and the certification of origin required.
- **Excise** flagged on alcohol, tobacco and energy products.
- **Prohibitions, restrictions, quotas and conditional reliefs.**
- **Export controls kept in a separate block**, because export licensing has
  nothing to do with what you'll pay to import.
- **Attribution and disclaimer** on every record.

### Who it's for

- **Customs brokers and freight forwarders** — quote landed cost in seconds, with
  an audit trail your client can check line by line.
- **Ecommerce and DTC brands** — price UK-bound SKUs correctly, and see the £135
  low-value rule flagged before the border, not after.
- **Procurement and sourcing teams** — compare true landed cost across origins
  before committing to a supplier.
- **ERP, TMS and customs-software teams** — a clean JSON contract with explicit
  ambiguity states, so your UI can ask the right follow-up question instead of
  displaying false precision.

### Try it

```json
{
  "commodityCode": "6109100010",
  "originCountry": "CN",
  "cifValue": 10000
}
```

Returns `AMBIGUOUS_MULTIPLE_MEASURES` — duty resolves to 12.00% (£1,200), but VAT
could be 0% or 20%. Both candidates returned. You decide, or ask your client
whether the garments are child-sized.

```json
{
  "commodityCode": "2204211790",
  "originCountry": "CL",
  "cifValue": 20000,
  "quantityValue": 50,
  "quantityUnit": "hl"
}
```

Returns `RESOLVED` — £600 duty (£12.00/hl × 50 hl), £4,120 VAT, **£24,720**
total. Excise is flagged. And because Chile is a CPTPP member, you also get a
second scenario at 0% duty (**£24,000**) — labelled conditional, with the exact
precondition spelled out: declare document code `9081` plus a CPTPP Certification
of Origin (`9U01` exporter / `9U02` producer / `9U03` importer).

Leave the quantity fields blank and you get `REQUIRES_QUANTITY`, naming the unit
required — never a silently wrong total.

```json
{ "commodityCode": "8507600030", "originCountry": "US", "cifValue": 120 }
```

Returns `RESOLVED_LOW_VALUE_REGIME` — duty computed as normal, VAT shown but
labelled *"VAT (not collected at the border)"*, because for consignments of £135
or less the seller accounts for UK supply VAT at the point of sale. We also say
plainly that we could **not** verify any matching customs-duty relief at that
threshold, so the duty figure is the normal-import amount.

### Bulk mode — price a whole catalogue in one run

Pass an `items[]` array. Each row inherits any field you don't override.

```json
{
  "originCountry": "CN",
  "cifValue": 5000,
  "items": [
    { "commodityCode": "6109100010" },
    { "commodityCode": "6203423500", "cifValue": 12000 },
    { "commodityCode": "6402993100", "originCountry": "VN" },
    { "commodityCode": "2204211790", "originCountry": "CL", "quantityValue": 12, "quantityUnit": "hl" }
  ]
}
```

#### How long your catalogue will take

HMRC rate-limits the tariff API, so we hold a deliberate **10 requests per
second** — their documented ceiling is 750/minute, and we stay under it on
purpose so your run never gets throttled mid-catalogue. Throughput is therefore
predictable, and you can work out your own runtime before you buy:

```
runtime ≈ rows ÷ 10 per second
```

| Your catalogue | Runtime |
|---|---|
| 500 rows | ~50 seconds |
| 1,000 rows | ~1m 40s |
| 5,000 rows | ~8m 20s |
| 10,000 rows | ~16m 40s |
| 50,000 rows | ~1h 23m |
| 100,000 rows | ~2h 46m |

Runs are asynchronous — start it, get on with something else, collect the dataset
when it finishes. Every row is written as it completes, so you can start
consuming results before the run ends.

#### Volume pricing

Bulk rows cost less than interactive lookups, and get cheaper with volume:

| Rows in the run | Price per row |
|---|---|
| 1 – 1,000 | $0.030 |
| 1,001 – 10,000 | $0.018 |
| 10,001+ | $0.012 |

A 10,000-row catalogue costs **$192** — an effective **$0.0192 per row**.

**Tiers count within a single run and reset on the next one**, so run your
catalogue as one job rather than splitting it into batches. Each result row
carries a `billingTier` field so you can reconcile the invoice against your data.

### Don't know the commodity code?

Send a plain-text description instead of a code and you'll get ranked candidate
commodity codes with confidence scores and links.

**We will never pick the code for you.** Tariff classification is the importer's
legal responsibility, and a wrong commodity code is the most expensive mistake in
customs. We narrow it down; you or your broker confirm it.

### How we decide — so you can audit us

- **MFN is the default.** The standard third-country duty applies
  unconditionally, so that's what we compute.
- **Preferential rates are an alternative, never the headline.** A preference
  only applies with valid proof of origin — a fact about *your shipment*, not
  about the goods. We show it as a labelled scenario **and always state the
  precondition**: the document code to declare, the certification of origin
  required, and the tariff's own guidance on making it out. If the tariff
  publishes no documentary condition, we say so explicitly rather than leaving a
  cheaper rate looking unconditional.
- **Ambiguity means same-kind competition.** Two VAT rates. A hundred
  exporter-specific anti-dumping rates. Cases where the data genuinely offers
  several answers and gives us nothing to choose between them.
- **Conditional reliefs are listed, never applied.** End-use suspensions,
  airworthiness reliefs and quotas can cut your duty — but only if you hold the
  authorisation or the quota still has balance. We flag them; we don't assume them.

### Scope

Resolved from the live HMRC tariff for a UK import:

- **Customs duty** — ad valorem, specific (per litre, per kg, per 1,000 items)
  and compound.
- **Import VAT** — including where a commodity carries more than one rate.
- **Excise** — flagged on alcohol, tobacco and energy products.
- **The £135 low-value regime** — identified, with the VAT treatment spelled out.
- **Preferential rates** — with the exact document code you must declare.
- **Anti-dumping** — including exporter-specific additional codes and the flagged
  residual rate.
- **Prohibitions, restrictions, quotas and conditional reliefs.**
- **The full measure set** behind all of it, each with a regulation ID or a
  verifiable measure reference.

Historic and forward dates are supported — resolve rates as at any import date, so
you can price a shipment landing next month or check what applied last quarter.

Importing into the EU as well? The EU/TARIC equivalent ships as a separate Actor.

### What it won't do — stated up front

- **GBP only.** We don't apply exchange rates, because an unsourced FX rate would
  make every figure untraceable. Convert using the HMRC monthly rate first.
- **Excise is flagged, not calculated.** UK excise is charged per unit of product
  at rates published outside the tariff.
- **Quota balances are not tracked.** We tell you a quota exists; we can't tell
  you whether it's still open.
- **No customs-duty relief is applied below £135.** HMRC's published guidance at
  that threshold covers VAT only. We flag the regime and compute duty as normal
  rather than invent a relief we can't cite.

### Source, licence and attribution

Data comes from the **HMRC Trade Tariff API** — the same data behind
[trade-tariff.service.gov.uk](https://www.trade-tariff.service.gov.uk/) — licensed
under the **Open Government Licence v3.0**.

Every record carries a machine-readable `attribution` block containing the source
name, source URL, the API endpoint queried, the **retrieval timestamp**, the
licence and its URL, and an explicit statement that the data has been modified and
derived:

> Contains public sector information licensed under the Open Government Licence
> v3.0. Source: HM Revenue & Customs, UK Integrated Online Tariff. © Crown
> copyright.

> This data has been **modified and derived** from the official source. Measures
> were filtered by origin and date, classified into duty / VAT / excise / control
> categories, and monetary amounts were computed by this Actor from the published
> rates and the values you supplied. Computed amounts are the work of this Actor,
> not of HM Revenue & Customs, and are not endorsed by HMRC. Always verify against
> the source URL provided.

The tariff updates daily; responses are cached for 60 minutes by default. A
scheduled canary re-checks the upstream data shape and **fails loudly** if HMRC
changes anything — because a stale or silently wrong number is worse than an
error.

### Disclaimer

**Indicative estimate for planning purposes only. This is not customs advice and
carries no legal standing.**

Duty and VAT liability depends on the correct commodity code, the origin of the
goods and valid proof of that origin, the customs value as determined under UK
valuation rules, reliefs and authorisations held by the importer, and the
exporter's identity where trade remedies apply. **Verify with a licensed customs
broker or HMRC before making any customs declaration or commercial commitment.**

The same disclaimer is returned in a `disclaimer` field on every record, so it
travels with the data into your system.

***

<details>
<summary><strong>Technical notes</strong></summary>

#### Input

| Field | Type | Notes |
|---|---|---|
| `commodityCode` | string | 6, 8 or 10 digits. Spaces and dots accepted. Padded to 10. One of this or `productQuery` required. |
| `productQuery` | string | Plain-text description → ranked candidate codes. |
| `originCountry` | string | **Required.** ISO 3166-1 alpha-2, country of *origin*. |
| `cifValue` | number | **Required.** Cost + insurance + freight, GBP. Decimals accepted. |
| `currency` | string | `GBP` only in v1. |
| `quantityValue` | number | Only for per-unit duties. Must be paired with `quantityUnit`. |
| `quantityUnit` | string | One of `hl`, `l`, `1000l`, `lpa`, `kg`, `100kg`, `t`, `g`, `item`, `100 items`, `1000 items`, `pair`, `m`, `m2`, `m3`, `carat`, `mwh`. Matched exactly, never converted. |
| `quantity` | object | Legacy form, `{ "value": 50, "unit": "hl" }`. Still accepted; the flat fields win if both are given. |
| `importDate` | string | `YYYY-MM-DD`, defaults to today. |
| `items` | array | Bulk rows; each inherits unset fields from the top level. `bulkRows` is accepted as an alias. |
| `cacheTtlMinutes` | number | Default 60, max 1440, `0` to bypass. |
| `mode` | string | `resolve` (default) or `canary`. |

#### Upstream schema canary

Schedule a run with `{ "mode": "canary" }` (hourly suggested). It asserts
known-good facts about the upstream response — ad valorem and specific duty
parsing, the anti-dumping additional-code fan-out, residual-rate detection,
preference document conditions, regulation IDs, search, and 404 behaviour. **A
failed run is the alert.**

#### Authentication and rate limiting

Runs against HMRC's authenticated endpoint using OAuth 2.0 client credentials when
`HMRC_CLIENT_ID`, `HMRC_CLIENT_SECRET` and `HMRC_TOKEN_URL` are configured. Access
mode is chosen by configuration, never by a catch-block: if authentication is
selected and fails, the run fails rather than silently answering from a different
source. One token is cached and reused; a mid-run 401 triggers exactly one forced
refresh and retry. Rate limiting is a token bucket that honours `Retry-After`.
Tokens and credentials are never logged.

#### Known issues

- On Windows with Node 24, a local `node dist/main.js` prints a libuv teardown
  assertion after the run completes. Exit code is 0 and all data is written.
  Cosmetic only; the deployed image runs Node 22 on Linux and is unaffected.

</details>

# Actor input Schema

## `commodityCode` (type: `string`):

The 10-digit UK commodity code for your goods, as it appears on the declaration. Spaces and dots are fine — '2204 21 17 90' works. Shorter codes are padded with zeros, but be aware that 6- and 8-digit codes are usually headings or subheadings rather than declarable codes. If you enter one, we'll tell you exactly which 10-digit codes sit beneath it so your next attempt works. Don't know the code? Leave this blank and use Product description instead.

## `productQuery` (type: `string`):

Describe the goods in plain English, for example 'cotton t-shirts' or 'still wine in bottles'. You'll get back ranked candidate commodity codes to choose from. We never pick the code for you — tariff classification is the importer's legal responsibility, and a wrong code is the most expensive mistake in customs. Use this OR the commodity code above, not both.

## `originCountry` (type: `string`):

Two-letter country code for where the goods were MADE — not where they ship from. Origin is what drives the duty rate and whether a trade agreement preference is available. Examples: CN China, US United States, CL Chile, IN India, VN Vietnam, TR Türkiye.

## `cifValue` (type: `number`):

Customs value of the consignment: the cost of the goods plus insurance and freight to the UK border. This is the figure duty is calculated on. Decimals are accepted.

## `currency` (type: `string`):

GBP only. We deliberately don't apply exchange rates: an unsourced FX rate would make every figure on your output untraceable. Convert your CIF value using the HMRC monthly exchange rate for your import month, then enter it here.

## `importDate` (type: `string`):

The date the goods enter free circulation, as YYYY-MM-DD. Rates are resolved as at this date, so you can price a shipment landing next month or check what applied last quarter. Leave blank for today.

## `quantityValue` (type: `number`):

How much you're importing, measured in the unit below. Only needed when duty is charged per unit rather than as a percentage of value — wine, spirits, tobacco and some agricultural goods. Leave both quantity fields blank if you're not sure: if we need a quantity we'll tell you exactly which unit to supply, rather than guess and give you a wrong total.

## `quantityUnit` (type: `string`):

The unit your quantity is measured in. It must match the unit the tariff uses for that commodity — we never convert between units, because a wrong conversion is a wrong duty. If it doesn't match, we'll tell you which unit is required.

## `items` (type: `array`):

Price a whole catalogue in one run. Each row can set its own commodityCode, originCountry, cifValue, quantityValue and quantityUnit — anything you leave out falls back to the values above. Throughput is about 10 rows per second, so 10,000 rows takes roughly 17 minutes; runs are asynchronous and rows appear in the dataset as they complete. Volume pricing gets cheaper as the run gets longer and resets each run, so run a catalogue as one job rather than splitting it into batches.

## `cacheTtlMinutes` (type: `integer`):

The UK tariff is updated once a day, so we reuse a result for the same commodity code, origin and import date for this long instead of asking HMRC again. Lower it if you need a guaranteed fresh read; set 0 to always go to HMRC.

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

Leave on Resolve to calculate landed cost. Canary is a health check that verifies HMRC's data still looks the way we expect and fails the run loudly if it doesn't — schedule it hourly if you depend on this in production.

## Actor input object example

```json
{
  "commodityCode": "2204211790",
  "originCountry": "CL",
  "cifValue": 20000,
  "currency": "GBP",
  "quantityValue": 50,
  "quantityUnit": "hl",
  "items": [
    {
      "commodityCode": "6109100010"
    },
    {
      "commodityCode": "7318154890",
      "originCountry": "IN",
      "cifValue": 30000
    },
    {
      "commodityCode": "2204211790",
      "originCountry": "CL",
      "cifValue": 12000,
      "quantityValue": 12,
      "quantityUnit": "hl"
    }
  ],
  "cacheTtlMinutes": 60,
  "mode": "resolve"
}
```

# 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 = {
    "commodityCode": "2204211790",
    "originCountry": "CL",
    "cifValue": 20000,
    "quantityValue": 50,
    "quantityUnit": "hl",
    "items": [
        {
            "commodityCode": "6109100010"
        },
        {
            "commodityCode": "7318154890",
            "originCountry": "IN",
            "cifValue": 30000
        },
        {
            "commodityCode": "2204211790",
            "originCountry": "CL",
            "cifValue": 12000,
            "quantityValue": 12,
            "quantityUnit": "hl"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("kestraz/uk-import-duty-landed-cost").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 = {
    "commodityCode": "2204211790",
    "originCountry": "CL",
    "cifValue": 20000,
    "quantityValue": 50,
    "quantityUnit": "hl",
    "items": [
        { "commodityCode": "6109100010" },
        {
            "commodityCode": "7318154890",
            "originCountry": "IN",
            "cifValue": 30000,
        },
        {
            "commodityCode": "2204211790",
            "originCountry": "CL",
            "cifValue": 12000,
            "quantityValue": 12,
            "quantityUnit": "hl",
        },
    ],
}

# Run the Actor and wait for it to finish
run = client.actor("kestraz/uk-import-duty-landed-cost").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 '{
  "commodityCode": "2204211790",
  "originCountry": "CL",
  "cifValue": 20000,
  "quantityValue": 50,
  "quantityUnit": "hl",
  "items": [
    {
      "commodityCode": "6109100010"
    },
    {
      "commodityCode": "7318154890",
      "originCountry": "IN",
      "cifValue": 30000
    },
    {
      "commodityCode": "2204211790",
      "originCountry": "CL",
      "cifValue": 12000,
      "quantityValue": 12,
      "quantityUnit": "hl"
    }
  ]
}' |
apify call kestraz/uk-import-duty-landed-cost --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,kestraz/uk-import-duty-landed-cost"
        }
    }
}

```

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/7EF16SG0SqyWAzeUZ/builds/ySb7fLOgtgAQ1omnC/openapi.json