# Tiktok Video Downloader (`scrapers-hub/tiktok-video-downloader`) Actor

TikTok Video Downloader saves videos at your chosen resolution with title, channel, duration, thumbnail and video type. 📥 Watermark-free archiving for creators, agencies and researchers repurposing short-form video content.

- **URL**: https://apify.com/scrapers-hub/tiktok-video-downloader.md
- **Developed by:** [Scrapers Hub](https://apify.com/scrapers-hub) (community)
- **Categories:**
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.99 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#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

### 🎬 TikTok Video Downloader – No-Watermark Video, Metadata & Thumbnail Extraction

The **TikTok Video Downloader** takes a list of TikTok video URLs and returns a direct download link for each video alongside its title, channel, duration, thumbnail, and video type. The video file itself is fetched and stored in the run's key-value store, so the `downloadUrl` field in every record is a working link you can hand to a browser, a script, or a downstream media pipeline.

This TikTok downloader is built for batch work rather than one-off saves. Give it twenty, a hundred, or a thousand video URLs and it processes each one in turn, pushing a dataset record per video. That makes it a practical component in content archiving workflows, competitor research pipelines, creative-asset libraries, and any process where you need the actual video file rather than just a link to a page.

Each record also classifies the video by length: clips under a minute are labelled as reels, longer uploads as long videos. That single distinction turns out to be surprisingly useful when you are analysing a creator's output mix or deciding which assets fit which repurposing format.

***

### 📊 What Data Can You Extract with This TikTok Video Downloader?

Each dataset record covers one TikTok video URL and its processing outcome.

| Category | Fields | What it gives you |
| --- | --- | --- |
| 🔗 Source reference | `original_url` | The TikTok URL that was submitted, echoed back so records join to your input list |
| 📝 Video metadata | `title`, `channel` | The video's title text and the uploader channel it belongs to |
| ⏱️ Length & format | `duration`, `video_type` | Human-readable duration plus a reel or long-video classification |
| 🖼️ Imagery | `thumbnail` | Direct thumbnail image URL for the video |
| ⬇️ Media access | `downloadUrl` | A direct download link for the stored video file |
| ⚠️ Failure handling | `status`, `error` | Failure status and error message when a URL could not be processed |

The field that does the real work is `downloadUrl`. Rather than returning a fragile CDN URL that expires, the Actor fetches the video content and stores it in the run's key-value store, then returns a link to that stored record. The result is a download link that stays valid for the lifetime of the run's storage rather than for a few minutes.

***

### 🌟 Key Features of the TikTok Video Downloader

| Feature | Description |
| --- | --- |
| 📥 Batch URL processing | Submit an array of TikTok video URLs and get one dataset record per video |
| ⬇️ Stored video files | Each video is fetched and written to the run's key-value store, producing a durable download link |
| 🚫 No-watermark sourcing | Download candidates are resolved from a no-watermark video source where available |
| 📝 Metadata extraction | Title, channel, duration, and thumbnail are captured for every processed video |
| 🎞️ Reel vs long-video classification | `video_type` labels clips under 60 seconds as reels and longer uploads as long videos |
| 🔁 Fallback resolution | If the primary download candidate is not a valid video stream, an alternative progressive format is attempted |
| ✅ Content-type validation | Candidate links are checked for a video content type before being treated as downloads |
| ⚠️ Per-URL error isolation | A failure on one URL produces an error record rather than aborting the whole batch |
| 📊 Standard dataset output | Results export as JSON, CSV, Excel, XML, or HTML and are readable through the Apify API |

***

### 🚀 Why Choose This TikTok Video Downloader?

**You get the file, not just a link.** Most downloaders hand back a CDN URL that expires within minutes. This Actor fetches the video bytes and stores them, so the `downloadUrl` value remains usable long after the run has finished.

**Batch-first design.** The input is an array of URLs, processed one after another with independent error handling. One broken or removed video produces an error record and the batch continues — there is no all-or-nothing failure mode.

**Metadata comes with the media.** `title`, `channel`, `duration`, `thumbnail`, and `video_type` arrive in the same record as the download link, so your asset library is populated and catalogued in a single pass rather than two.

**Resilient link resolution.** The Actor validates that a candidate link actually serves video content before treating it as a download, and falls back to an alternative progressive format when the primary candidate does not check out.

***

### 📥 Input

```json
{
  "video_urls": [
    { "url": "https://www.tiktok.com/@examplecreator/video/7300000000000000000" },
    { "url": "https://www.tiktok.com/@anothercreator/video/7300000000000000001" }
  ],
  "desired_resolution": "1080p"
}
```

#### 🔧 TikTok Video Downloader Input Fields

| Field | Type | Required | Default | Description |
| --- | --- | --- | --- | --- |
| `video_urls` | array | ✅ Yes | — | TikTok video URLs to process. Each entry may be a plain URL string or an object with a `url` key |
| `desired_resolution` | string | No | `1080p` | Preferred resolution used when selecting among available video formats |

If `video_urls` is empty or missing, the run fails immediately with a message stating that no TikTok video URLs were provided.

#### 💡 Input Examples

**Download a single TikTok video**

```json
{
  "video_urls": [
    { "url": "https://www.tiktok.com/@examplecreator/video/7300000000000000000" }
  ]
}
```

**Batch download with plain URL strings**

```json
{
  "video_urls": [
    "https://www.tiktok.com/@creatorone/video/7300000000000000010",
    "https://www.tiktok.com/@creatortwo/video/7300000000000000011",
    "https://www.tiktok.com/@creatorthree/video/7300000000000000012"
  ],
  "desired_resolution": "1080p"
}
```

**Prefer a lower resolution for lighter files**

```json
{
  "video_urls": [
    { "url": "https://www.tiktok.com/@examplecreator/video/7300000000000000000" }
  ],
  "desired_resolution": "720p"
}
```

***

### 📤 Output

```json
{
  "original_url": "https://www.tiktok.com/@examplecreator/video/7300000000000000000",
  "title": "Three quick knife skills every home cook should know",
  "channel": "examplecreator",
  "duration": "48s",
  "thumbnail": "https://p16-sign.tiktokcdn-us.com/obj/example-thumbnail.jpeg",
  "video_type": "reel",
  "downloadUrl": "https://api.apify.com/v2/key-value-stores/EXAMPLESTOREID/records/Three_quick_knife_skills_every_home_cook_should_know.mp4"
}
```

A failed URL produces a compact error record instead:

```json
{
  "original_url": "https://www.tiktok.com/@examplecreator/video/7300000000000000099",
  "error": "Video unavailable",
  "status": "FAILED"
}
```

#### 🧾 TikTok Video Downloader Output Fields

| Field | Type | Description |
| --- | --- | --- |
| `original_url` | string | null | The TikTok URL that was submitted |
| `title` | string | null | Title of the video |
| `channel` | — | Channel the video belongs to |
| `duration` | string | number | Duration of the media in human-readable form |
| `thumbnail` | string | null | Thumbnail image URL |
| `video_type` | string | null | Whether the video is classified as a reel or a long video |
| `downloadUrl` | — | Direct download link for the stored video file |
| `status` | string | null | Status of the item, present when processing failed |
| `error` | string | null | Error message, if the item failed to process |

Note that `downloadUrl` contains a space in the field name. When accessing it in code, use bracket notation — `item["downloadUrl"]` in Python, `item["downloadUrl"]` in JavaScript — rather than dot notation.

***

### 💻 How to Use the TikTok Video Downloader (Step by Step)

#### Step 1: Collect the TikTok video URLs you need

Gather the full URLs of the videos you want to download. A usable TikTok URL contains the `/video/` path segment followed by the numeric video ID — the Actor extracts that ID to resolve download candidates. Profile URLs, hashtag pages, and shortened share links without the video path will not work, so expand or normalise them first.

#### Step 2: Build the `video_urls` array

Populate `video_urls` with your list. Both formats are accepted: plain URL strings, or objects with a `url` key. Mixing the two in the same array is fine. There is no fixed cap on the number of URLs, but each video is fetched and stored, so very large batches take proportionally longer and consume more storage.

#### Step 3: Set your preferred resolution

`desired_resolution` defaults to `1080p` and expresses which format you would prefer when several are available. Lower it to `720p` when file size matters more than fidelity — for example when you are archiving thousands of clips or feeding a transcription pipeline that does not benefit from higher resolution.

#### Step 4: Run the TikTok downloader and follow the log

Press **Start**. The run log reports each URL as it is processed, including any warnings about candidate links that returned an unexpected content type. Because videos are downloaded in full and written to storage, expect the run duration to scale with both the number and the length of the videos in your batch.

#### Step 5: Retrieve the download links from the dataset

Open the Dataset tab when the run completes. Each record contains the metadata and a `downloadUrl` link pointing at the stored file in the run's key-value store. Clicking the link in the Apify console downloads the video; the same URL works from `curl`, `wget`, or any HTTP client.

#### Step 6: Check the failed records

Filter the dataset for records containing `status` set to `FAILED`. These carry an `error` message and the `original_url` that produced it. Common causes are videos that have been deleted, made private, or restricted in the region the run executed from. Re-running just the failed URLs later is often enough to recover transient failures.

#### Step 7: Export and integrate into your media workflow

Export the dataset as JSON or CSV to feed an asset manager, or read it through the Apify API and pull each `downloadUrl` link programmatically. Because `title`, `channel`, `duration`, and `video_type` travel with the link, the export doubles as a catalogue — you can populate a media library's metadata fields directly from the same file that tells you where the videos are.

***

### 🔌 API Access & Integrations

Run the TikTok video downloader synchronously and get dataset items back:

```bash
curl -X POST "https://api.apify.com/v2/acts/scrapers-hub~tiktok-video-downloader/run-sync-get-dataset-items?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "video_urls": [
      { "url": "https://www.tiktok.com/@examplecreator/video/7300000000000000000" }
    ],
    "desired_resolution": "1080p"
  }'
```

Batch download and save the files locally with the Python client:

```python
import requests
from apify_client import ApifyClient

client = ApifyClient("YOUR_TOKEN")

run = client.actor("scrapers-hub/tiktok-video-downloader").call(run_input={
    "video_urls": [
        {"url": "https://www.tiktok.com/@creatorone/video/7300000000000000010"},
        {"url": "https://www.tiktok.com/@creatortwo/video/7300000000000000011"},
    ],
    "desired_resolution": "1080p",
})

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    if item.get("status") == "FAILED":
        print("FAILED", item.get("original_url"), item.get("error"))
        continue

    link = item.get("downloadUrl")
    print(item.get("channel"), "|", item.get("title"), "|", item.get("video_type"), item.get("duration"))

    if link and link != "not available":
        response = requests.get(link, timeout=120)
        filename = f"{item.get('title', 'video')[:60]}.mp4".replace("/", "_")
        with open(filename, "wb") as handle:
            handle.write(response.content)
```

The Actor also connects to Zapier, Make, Google Sheets, and Slack, and supports webhooks that fire on run completion so downloaded assets can be announced or catalogued automatically.

***

### 💡 Best Use Cases for TikTok Video Download Data

#### 🗄️ Brand content archiving and compliance records

Marketing and legal teams often need a durable copy of every video a brand publishes or is tagged in. Feeding a list of URLs through the TikTok downloader produces both the stored file behind `downloadUrl` and a metadata row containing `title`, `channel`, and `duration` — a complete, auditable archive rather than a folder of unlabelled MP4 files.

#### 🔍 Competitor content analysis

Collect a competitor's video URLs and process them in one batch. The `video_type` split between reels and long videos shows how they balance short hooks against extended content, while `duration` and `title` together reveal the length and framing patterns behind their most-used formats.

#### ✂️ Creative repurposing and multi-platform publishing

Creators repurposing TikTok content for other platforms need the underlying file, not a share link. The stored download plus the `thumbnail` URL gives you both the video and its cover image, ready for re-editing, subtitling, or reformatting for a different aspect ratio.

#### 🎙️ Transcription and AI content pipelines

Speech-to-text, captioning, and content-classification systems all need the actual media file as input. Batch-downloading with `desired_resolution` set to `720p` keeps file sizes manageable for a transcription pipeline where visual fidelity adds cost without adding accuracy.

#### 📚 Research and academic media study

Researchers studying social media discourse need a stable corpus, because TikTok videos are frequently deleted. Storing the file and preserving `original_url`, `channel`, `title`, and `duration` creates a citable dataset that remains intact even after the source video disappears.

#### 📺 Internal training and reference libraries

Teams that use short-form video for onboarding, social listening briefings, or creative inspiration can assemble a curated internal library. The metadata fields make the library searchable by channel and format, and `video_type` lets you filter to just the short-form examples when running a reels-focused session.

#### 🚨 Trend monitoring and rapid response

When a video about your brand or category starts circulating, capturing it quickly matters — originals get deleted or edited. A scheduled run over a monitored URL list preserves each video and records `original_url` and `channel`, giving the response team both the evidence and the context.

***

### ⚙️ Tips for Better TikTok Downloading Results

- **Normalise URLs before submitting.** The Actor extracts the video ID from the `/video/` path segment. Expand shortened share links and strip tracking parameters so every URL resolves cleanly.
- **Batch in moderate chunks.** Every video is downloaded in full and written to storage, so run duration and storage use scale directly with batch size. Several medium runs are easier to monitor and re-drive than one enormous one.
- **Lower `desired_resolution` when fidelity is not the point.** For transcription, classification, or bulk archiving, `720p` produces substantially smaller files without affecting the outcome.
- **Always handle the `downloadUrl` key with bracket notation.** The space in the field name breaks dot-notation access in most languages and is the most common integration bug with this Actor.
- **Re-run failed URLs separately.** Filter for `status` set to `FAILED`, extract those `original_url` values, and submit them as a smaller follow-up batch. Transient failures often succeed on a second attempt.
- **Download the stored files promptly.** The `downloadUrl` link points at the run's key-value store. If you need long-term retention, copy the files into your own storage rather than relying on the run's storage indefinitely.

***

### 🛠️ Troubleshooting

**The run failed immediately with a message about no URLs provided.**
`video_urls` was empty or missing. It is the required input — populate it with at least one TikTok video URL as either a string or an object with a `url` key.

**A record shows `"downloadUrl": "not available"`.**
No valid video stream could be resolved for that URL. This usually means the video has been removed, made private, or is region-restricted. Confirm the URL still opens in a browser, then retry it in a smaller batch.

**Some records came back with `status: "FAILED"` and an error message.**
Each URL is processed independently, so one failure does not stop the batch. Read the `error` value for the specific cause, then re-submit just the failed `original_url` values. Deleted and private videos will keep failing; transient network errors typically will not.

**My code cannot read the download link.**
The field is literally named `downloadUrl`, with a space. Access it as `item["downloadUrl"]` rather than `item.Download` or `item.download_video`.

**The downloaded file is not the resolution I requested.**
`desired_resolution` expresses a preference used when choosing among available formats. If TikTok does not serve the requested resolution for that particular video, the closest available format is used instead.

**A large batch took much longer than expected.**
Each video is fetched in full before the record is pushed, so total run time is a function of both video count and video length. Split large jobs into several runs, and prefer a lower `desired_resolution` when you are archiving in volume.

***

### ❓ Frequently Asked Questions About TikTok Video Downloading

**What does the TikTok Video Downloader do?**
It takes TikTok video URLs, resolves a download source for each, fetches the video into the run's key-value store, and returns a dataset record containing a direct download link plus title, channel, duration, thumbnail, and video type.

**How many videos can I download in one run?**
There is no fixed limit on the size of `video_urls`. Because each video is downloaded in full, practical batch size is governed by run time and storage rather than by a hard cap.

**Are the downloads watermark-free?**
The Actor resolves download candidates from a no-watermark video source where one is available, and falls back to an alternative progressive format when it is not.

**What URL format does the TikTok downloader accept?**
Full TikTok video URLs containing the `/video/` path segment and numeric video ID. Entries may be plain strings or objects with a `url` key, and both formats can be mixed in the same array.

**Can I download a whole creator's profile at once?**
No. The input is a list of individual video URLs. Collect the URLs first, then pass them to this Actor as a batch.

**What does `video_type` mean?**
Videos shorter than 60 seconds are classified as reels; anything longer is classified as a long video. It is a quick way to segment short-form from extended content.

**How long does the download link stay valid?**
The link points at a record in the run's key-value store. Copy files into your own storage if you need guaranteed long-term retention.

**Why does one output field have a space in its name?**
The field is named `downloadUrl` as produced by the Actor. Use bracket notation in code to access it.

**Does `desired_resolution` guarantee that resolution?**
No. It is a preference applied when selecting among the formats TikTok makes available for that video. If the requested resolution is not offered, another format is used.

**What happens if one URL in my batch is broken?**
That URL produces a record containing `original_url`, `error`, and `status` set to `FAILED`, and the batch continues with the remaining URLs.

**Can I get the thumbnail as well as the video?**
Yes. Every successful record includes a `thumbnail` URL pointing at the video's cover image.

**Does this Actor use a proxy or a headless browser?**
No proxy is configured and no headless browser is launched. The TikTok downloader works over direct HTTP requests.

**Can I integrate the TikTok video downloader with Zapier or Slack?**
Yes. It works with Zapier, Make, Google Sheets, and Slack integrations, and supports webhooks that fire when a run completes.

**Is downloading TikTok videos legal?**
Downloading publicly available videos for personal reference, research, or archival purposes is generally permissible, but the videos remain the copyright of their creators. Republishing or commercialising downloaded content without permission is not, and you are responsible for complying with TikTok's terms of service and applicable copyright law.

**Can I request a custom version of this TikTok downloader?**
Yes. Email `scraperhubapi@gmail.com` to discuss additional metadata fields, different storage destinations, or integration with your own media pipeline.

***

### 🆘 Support & Feedback

If a video fails to download, a link comes back unavailable, or a run behaves unexpectedly, report it on the **Issues** tab of the Actor page. Include the TikTok URL and the run ID so the failure can be reproduced.

For custom work — larger media pipelines, additional metadata extraction, or a tailored version of this TikTok video downloader for your own archive — email `scraperhubapi@gmail.com`.

If this Actor is useful to you, please leave a review on the Apify Store. Ratings and written feedback directly influence which improvements are prioritised.

***

### ⚖️ Disclaimer

The TikTok Video Downloader retrieves publicly available TikTok videos and their associated metadata. It does not log in, bypass authentication, or access private accounts, restricted content, or videos hidden behind any access control.

You are responsible for how you use the videos and data this TikTok downloader produces. All videos remain the intellectual property of the creators who made them. Downloading for personal reference, research, journalism, or archival purposes is a different matter from republishing, monetising, or redistributing that content — the latter requires the rights holder's permission. Comply with TikTok's terms of service at all times.

TikTok videos frequently feature identifiable individuals. Where you process such material, data protection law including the GDPR applies to you as the data controller, and you must establish a lawful basis, honour data subject rights, and apply appropriate retention limits. Take particular care with content involving minors.

Results are provided as-is. Videos may be deleted, made private, or region-restricted at any time, and previously working URLs can stop resolving without notice.

If you believe data or media returned by this Actor should be removed, email `scraperhubapi@gmail.com` with the details and the request will be reviewed.

# Actor input Schema

## `video_urls` (type: `array`):

List of TikTok video URLs to process.

## `desired_resolution` (type: `string`):

Select the desired resolution (e.g., 1080p, 720p, 480p, 360p).

## Actor input object example

```json
{
  "video_urls": [
    {
      "url": "https://www.tiktok.com/@therock/video/7473147398718573866"
    },
    {
      "url": "https://www.tiktok.com/@mrbeast/video/7476529277253635374"
    }
  ],
  "desired_resolution": "1080p"
}
```

# Actor output Schema

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

Records scraped by Tiktok Video Downloader, stored in the run's default dataset.

## `videoFiles` (type: `string`):

Downloaded TikTok MP4 files stored in the default key-value store.

# 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 = {
    "video_urls": [
        {
            "url": "https://www.tiktok.com/@therock/video/7473147398718573866"
        },
        {
            "url": "https://www.tiktok.com/@mrbeast/video/7476529277253635374"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapers-hub/tiktok-video-downloader").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 = { "video_urls": [
        { "url": "https://www.tiktok.com/@therock/video/7473147398718573866" },
        { "url": "https://www.tiktok.com/@mrbeast/video/7476529277253635374" },
    ] }

# Run the Actor and wait for it to finish
run = client.actor("scrapers-hub/tiktok-video-downloader").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 '{
  "video_urls": [
    {
      "url": "https://www.tiktok.com/@therock/video/7473147398718573866"
    },
    {
      "url": "https://www.tiktok.com/@mrbeast/video/7476529277253635374"
    }
  ]
}' |
apify call scrapers-hub/tiktok-video-downloader --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,scrapers-hub/tiktok-video-downloader"
        }
    }
}

```

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/2NyhICUDZJcP4FFB3/builds/2KSySNHlCWNvuvGfc/openapi.json