# YouTube Shorts Scraper — Search, Channel & Hashtag (`khadinakbar/youtube-shorts-scraper`) Actor

Scrape YouTube Shorts by keyword, channel, hashtag or Short URL: views, likes, comments, engagement rate, viral score, audio, optional transcripts and MP4 download. Works with Apify MCP and the API.

- **URL**: https://apify.com/khadinakbar/youtube-shorts-scraper.md
- **Developed by:** [Khadin Akbar](https://apify.com/khadinakbar) (community)
- **Categories:** Social media, Videos, MCP servers
- **Features:** Limited permissions
- **Stats:** 69 total users, 8 monthly users, 83.7% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $20.00 / 1,000 short scrapeds

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/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

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

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

## How to integrate an Actor?

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

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

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

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

# README

### What is YouTube Shorts Scraper — Search, Channel, Hashtag & MP4?

YouTube Shorts Scraper is an Apify Actor for public YouTube Shorts pages. It accepts a search keyword, a list of search keywords, channel Shorts tab URLs, hashtag URLs, or direct Short URLs. Each dataset record represents one scraped Short and includes the canonical URL, title, channel details, views, likes, comments, hashtags, audio metadata, engagement rate, viral score, and optional transcript data with timestamps. The outcome is a structured dataset you can review in Apify, export as JSON or CSV, or read through the Apify API. Filter by publish date with `publishedAfter` / `publishedBefore` to get only recent Shorts. It is also usable through Apify MCP.

**Cost at a glance:** one `Short Scraped` event per saved Short (MP4 download included), one `Transcript Extracted` event only when a transcript is returned, and one `Actor Start` event per run. Apify platform usage is included. Shorts skipped by the date window are not charged. See the Pricing tab for current prices.

### What's new

- **2026-11-10, v1.2.23 - Fast mode.** Shorts are now read directly from YouTube instead of through a browser. Same fields, same prices, runs finish in seconds (40 Shorts from one channel in about 20 seconds, with exact likes, comments and publish date on every row). If YouTube cannot be reached this way, the Actor falls back to the browser engine automatically.
- The default MP4 size cap is now 100 MB (was 200 MB). Raise `maxFileSizeMb` if you need bigger files.

### Download Shorts as MP4

Turn on **Download Shorts as MP4** (`downloadVideos: true`) to also save each Short as an MP4 file. Every row then gets:

| Field | Meaning |
| --- | --- |
| `downloadStatus` | `downloaded`, `failed`, or `not_requested` |
| `videoFileUrl` | Link to the saved MP4 in the run's key-value store |
| `fileSizeBytes`, `videoWidth`, `videoHeight` | Size and resolution of the saved file |
| `downloadRoute` | Network route that served the file: `direct`, `datacenter`, or `residential` |
| `downloadError` | Why a download failed or was skipped |

Pick the quality with `videoQuality` (360p, 480p, 720p, 1080p or best; default 720p). Quality is measured on the short side, so 720p means 720×1280 for a vertical Short. Downloads try a direct connection first, then a datacenter proxy. If YouTube blocks both, a residential fallback saves the Short at up to 360p within a bandwidth budget for each run; a Short that does not fit is marked `failed` with the reason, and its metadata is still returned.

### Best fit and connected workflows

This Actor fits workflows that begin with a Shorts discovery source and end with structured analysis.

Use it when you want to:

- collect Shorts around a topic from a search keyword or keyword list,
- review a creator's Shorts tab as part of creator research,
- monitor a hashtag page for trend tracking,
- enrich an existing Shorts URL list with engagement metrics,
- add transcript fields for Shorts with captions when transcript enrichment is enabled.

A common workflow is to scrape Shorts here first, then pass returned video URLs or channel context into downstream analysis. For comment-level research, connect the output to YouTube Comments Scraper (with Replies) when you want public replies and discussion around a returned YouTube record.

### Practical scenario

Maya, a content strategist, starts with a keyword list like "morning routine", "gym motivation", and "study tips". She runs the Actor with `searchQueries` and `maxResults` set for a focused batch. The dataset returns titles, channel names, view counts, like counts, comment counts, hashtags, engagement rate, viral score, and source URLs. Maya spots a Short with a high viral score and strong engagement rate, then opens the channel and uses the Short URL in her next briefing to review the format, hook, and caption style.

### Input

Choose one or more input modes in the same run.

| Field | Type | Purpose |
|---|---|---|
| `searchQuery` | string | Single keyword or phrase for a quick start search. |
| `searchQueries` | array of strings | Multiple search keywords, each executed separately. |
| `channelUrls` | array of strings | YouTube channel `/shorts` tab URLs. |
| `hashtagUrls` | array of strings | YouTube hashtag page URLs. |
| `startUrls` | array of objects | Direct Short URLs to enrich with metadata. |
| `maxResults` | integer | Maximum Shorts per keyword, channel, or hashtag source. |
| `publishedAfter` | string | Keep Shorts published on/after a date (`2026-10-01`) or within a relative window (`7 days`, `24 hours`, `3 months`). |
| `publishedBefore` | string | Keep Shorts published on/before a date or relative point. |
| `fastMode` | boolean | On by default. Reads YouTube directly (no browser): runs finish in seconds. Switches to the browser engine by itself if YouTube cannot be reached this way. |
| `maxConcurrency` | integer | Parallel requests (browser tabs when `fastMode` is off). |
| `proxyConfiguration` | object | Proxy settings for scraping and transcript fetches. |
| `includeTranscripts` | boolean | Enables transcript extraction for Shorts with captions. |
| `transcriptLanguage` | string | Preferred transcript language code. |

Focused example:

```json
{
  "searchQueries": [
    "morning routine",
    "gym motivation"
  ],
  "maxResults": 25,
  "maxConcurrency": 3,
  "includeTranscripts": true,
  "transcriptLanguage": "en",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

### Output

Each dataset item is one scraped Short.

| Field | Type | Purpose |
|---|---|---|
| `video_id` | string | YouTube Short video ID. |
| `title` | string | Short title. |
| `description` | string or null | Description text if present. |
| `url` | string | Canonical Short URL. |
| `channel_name` | string or null | Channel display name. |
| `channel_id` | string or null | Creator channel ID. |
| `channel_url` | string or null | Creator channel URL. |
| `channel_subscribers` | number or null | Subscriber count at scrape time. |
| `view_count` | number or null | View count at scrape time. |
| `like_count` | number or null | Like count at scrape time. |
| `comment_count` | number or null | Comment count at scrape time. |
| `duration_seconds` | number or null | Short duration in seconds. |
| `published_at` | string or null | Upload timestamp in ISO 8601 UTC. |
| `hashtags` | array of strings | Hashtags extracted from title and description. |
| `audio_title` | string or null | Music or audio track name. |
| `audio_author` | string or null | Audio creator or artist. |
| `thumbnail_url` | string or null | Thumbnail URL. |
| `engagement_rate` | number or null | Computed as `(likes + comments) / views`. |
| `viral_score` | number or null | Computed as `views / subscribers`. |
| `transcript_text` | string or null | Plain-text transcript when enabled and available. |
| `transcript_segments` | array or null | Timestamped transcript segments. |
| `transcript_language` | string or null | Transcript language code. |
| `is_auto_generated` | boolean or null | Whether the transcript came from ASR. |
| `transcript_word_count` | number or null | Transcript word count. |
| `scraped_at` | string | Scrape timestamp in ISO 8601 UTC. |
| `source_url` | string | Discovery URL that led to the Short. |

Illustrative record:

```json
{
  "video_id": "dQw4w9WgXcQ",
  "title": "5 Morning Habits That Changed My Life #shorts",
  "url": "https://www.youtube.com/shorts/dQw4w9WgXcQ",
  "channel_name": "HealthyHabitsDaily",
  "view_count": 4800000,
  "like_count": 182000,
  "comment_count": 3241,
  "hashtags": [
    "#morningroutine",
    "#productivity"
  ],
  "audio_title": "Calm Morning Beats",
  "audio_author": "LoFi Studio",
  "engagement_rate": 0.0384,
  "viral_score": 3.87,
  "transcript_language": "en",
  "is_auto_generated": true,
  "transcript_word_count": 87,
  "scraped_at": "2026-04-09T12:00:00.000Z",
  "source_url": "https://www.youtube.com/results?search_query=morning+routine&sp=EgQKAUgB"
}
```

### How it works

This Actor discovers public YouTube Shorts from search results, channel Shorts tabs, hashtag pages, or direct Short URLs, then opens each Short to read views, likes, comments, audio and channel details. With a date window set, it reads each Short's publish date and keeps only Shorts inside the window before saving or charging. Transcripts are added when `includeTranscripts` is on and captions exist. When `downloadVideos` is on, each Short is also saved as an MP4 in the run's key-value store. Every run ends with an `OUTPUT` and `RUN_SUMMARY` record (`COMPLETE`, `PARTIAL`, `VALID_EMPTY` or `INVALID_INPUT`) so automations can read the result. The dataset schema stores one record per Short, and the output schema exposes the dataset in JSON or CSV form through Apify links.

### Pricing and Apify platform usage

This Actor uses Pay per event pricing on Apify with Apify platform usage included. The live Pricing tab is the source of truth for current pricing details.

Charged events:

- Actor Start: charged once per run based on actor memory
- Short Scraped: charged per successfully scraped Short
- Transcript Extracted: charged only when a Short transcript is successfully fetched and `includeTranscripts` is enabled

Downloading Shorts adds no extra event charge; it is included in Short Scraped. Example: if a run returns twenty Shorts and transcripts are successfully fetched for eight of them, the pricing reflects twenty Short Scraped events, eight Transcript Extracted events, and one Actor Start event. Check the live Pricing tab in the Apify Console before running a job for the current rates.

### Use with AI agents (MCP)

This Actor is available through Apify MCP as a tool for collecting structured Shorts data for AI workflows.

Tool description: scrape public YouTube Shorts by keyword, channel Shorts tab, hashtag page, or direct Short URL, and return structured fields for downstream analysis, retrieval, or enrichment.

Exact Actor identity: `khadinakbar/youtube-shorts-scraper`

> Scrape YouTube Shorts for the keyword "morning routine". Return up to 20 results, include transcripts when captions are available, and provide the dataset rows with titles, channels, views, hashtags, viral score, and source URLs.

Output interpretation:

- `viral_score` compares a Short's views to the channel's subscriber count.
- `engagement_rate` combines likes and comments relative to views.
- `transcript_text` and `transcript_segments` appear only when transcript enrichment is enabled and a transcript is available.
- `source_url` shows which search, channel, or hashtag page led to the item.

Provenance:

- Each record comes from the dataset produced by this Actor.
- `scraped_at` records when the item was collected.
- `url` points to the canonical YouTube Shorts URL.

Scope, pagination, and cost guidance:

- `searchQueries`, `channelUrls`, and `hashtagUrls` respect `maxResults` per input source.
- Direct Short URLs are fetched individually and returned as fully scraped records.
- The primary event is charged per Short scraped.
- Transcript extraction adds a separate event only for successful transcript fetches.

### Apify API example

JavaScript example with `APIFY_TOKEN` and dataset readback:

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

const client = new ApifyClient({
  token: process.env.APIFY_TOKEN,
});

const run = await client.actor('khadinakbar/youtube-shorts-scraper').call({
  searchQueries: ['morning routine'],
  maxResults: 10,
  includeTranscripts: false,
});

const datasetId = run.defaultDatasetId;
const { items } = await client.dataset(datasetId).listItems();

console.log(items);
```

### Best results and outcome guidance

Start with a narrow keyword, a single channel Shorts tab, or a specific hashtag when you want a tighter dataset. Use `searchQueries` for batch research, and use `startUrls` when you already have specific Shorts to enrich. Keep `maxResults` aligned with the size of the source you want to review, and keep `maxConcurrency` at the default unless you hit rate limits. When transcripts matter, enable `includeTranscripts` and set `transcriptLanguage` to the preferred ISO 639-1 code. For the newest Shorts from a creator, combine a channel URL with `publishedAfter: "7 days"`.

### Continue the workflow

- Then use [YouTube to MP3 Downloader](https://apify.com/khadinakbar/youtube-to-mp3-downloader) to continue YouTube records selected with YouTube Shorts Scraper into a focused media workflow.
- Then use [YouTube Transcript and Subtitle Data Scraper](https://apify.com/khadinakbar/youtube-transcript-extractor) to continue YouTube records selected with YouTube Shorts Scraper into a focused media workflow.

### Design note

I found that the dataset contract includes both `engagement_rate` and `viral_score` as computed output fields, which makes the Actor useful for ranking Shorts without extra post-processing.

### FAQ

#### When should I use a search keyword versus a channel URL?

Use a search keyword or keyword list when you want topic discovery across many creators. Use a channel `/shorts` URL when you want the Shorts catalog for one creator.

#### When should I use a hashtag URL?

Use a hashtag URL when the workflow starts from a trend, niche label, or campaign tag and you want Shorts that are grouped around that tag.

#### When should I use direct Short URLs?

Use direct Short URLs when you already have a list of Shorts and want to enrich them with views, likes, comments, hashtags, audio data, or transcripts.

#### Which output fields are useful for ranking?

`view_count`, `engagement_rate`, and `viral_score` are the main ranking fields. `hashtags`, `audio_title`, and `audio_author` help with trend analysis.

#### How are transcripts handled?

When `includeTranscripts` is enabled, the Actor returns transcript fields for Shorts where captions are available. The dataset includes both plain text and timestamped segments.

#### Can I get only Shorts published after a date?

Yes. Set `publishedAfter` to a date such as `2026-10-01` or a relative window such as `7 days`, and optionally `publishedBefore`. Shorts outside the window, or with no readable publish date, are skipped without a charge.

#### Do I pay for the fast mode?

No. You pay the same per-Short price as before. Fast mode only makes the run quicker and lighter. Example: 100 Shorts from one channel costs 100 x the Short price plus a tiny start fee; transcripts add the transcript price only for Shorts that have one.

#### Does MP4 download cost extra?

No extra event. The MP4 is included in the `Short Scraped` event for that Short.

#### Why did I get fewer Shorts than maxResults?

The source page may list fewer Shorts, the date window may skip some, or Shorts without readable metadata are left out instead of being saved as empty rows. The `OUTPUT` record states the outcome and how many Shorts the date window skipped.

#### How does this connect to other YouTube workflows?

A common next step is to pass the returned Short URLs or creator context into YouTube Comments Scraper (with Replies) for comment analysis.

### Responsible use

Use this Actor for publicly accessible YouTube Shorts and for lawful data collection that fits your compliance requirements and the YouTube terms that apply to your use case. Downloaded videos belong to their creators: reuse them only where you own the rights, have the creator's permission, or another legal basis applies. Review access, retention, and downstream processing practices before combining the dataset with other personal or behavioral data.

# Changelog

This Actor's version history is a separate document: https://apify.com/khadinakbar/youtube-shorts-scraper/changelog.md

# Actor input Schema

## `searchQuery` (type: `string`):

Single keyword or phrase to search YouTube Shorts for (e.g. 'gym motivation', 'cooking hacks 2025'). For multiple keywords in one run, use the Search keywords list below.

## `searchQueries` (type: `array`):

List of keywords or topics to search YouTube Shorts for. Each query runs separately and up to maxResults Shorts are scraped per query. Use this for batch keyword research.

## `channelUrls` (type: `array`):

YouTube channel /shorts tab URLs to scrape all Shorts from a specific creator. Example: https://www.youtube.com/@MrBeast/shorts — paste the full URL including /shorts. Use for competitor analysis or creator research.

## `hashtagUrls` (type: `array`):

YouTube hashtag page URLs to scrape all Shorts tagged with a specific hashtag. Example: https://www.youtube.com/hashtag/gymtok — paste the full URL. Best for trend and niche research.

## `startUrls` (type: `array`):

Specific YouTube Short URLs to fetch full metadata for. Example: https://www.youtube.com/shorts/VIDEO_ID. Use when you already have a list of Shorts you want to enrich with engagement data.

## `maxResults` (type: `integer`):

Maximum number of Shorts to scrape per search keyword, channel, or hashtag URL. Direct Short URLs are always fully scraped. Fast mode handles hundreds in one run; for 500+ keep an eye on the run time limit.

## `publishedAfter` (type: `string`):

Keep only Shorts published on or after this point. Use a date like 2026-10-01 or a relative window like '7 days', '24 hours', '2 weeks' or '3 months'. Shorts outside the window (or with no readable publish date) are skipped and not charged. Leave empty for no lower bound.

## `publishedBefore` (type: `string`):

Keep only Shorts published on or before this point. Same formats as Published after, e.g. 2026-10-15 or '1 day'. Leave empty for no upper bound.

## `fastMode` (type: `boolean`):

On by default: reads YouTube directly instead of opening a browser, so runs finish in seconds and use far less compute. If YouTube cannot be reached this way from the run's connection, the Actor switches to the browser engine on its own. Turn off only to force the browser engine.

## `maxConcurrency` (type: `integer`):

How many Shorts are fetched at the same time. Fast mode uses at least 5. In browser mode (fastMode off) this is the number of browser tabs; lower values (1-3) reduce bot detection and memory use.

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

Proxy settings. No proxy is needed for keyword searches and basic metadata. Switch to Apify residential proxies if individual Short pages are blocked or if you need view counts from private/unlisted videos.

## `includeTranscripts` (type: `boolean`):

When true, fetches the closed-caption transcript for each Short and returns transcript_text, transcript_segments (with timestamps), transcript_language, is_auto_generated, and transcript_word_count. Shorts with voiceover or narration (storytime, motivational, how-to) usually have transcripts; dance/music/visual-only Shorts typically do not. IMPORTANT: YouTube rate-limits the transcript endpoint from datacenter IPs — enable Apify residential proxy (proxyConfiguration: {"useApifyProxy": true, "apifyProxyGroups": \["RESIDENTIAL"]}) for reliable transcript fetches. Adds $0.005 per Short where a transcript was actually fetched (Shorts without captions cost nothing extra). Default: false. NOT a separate scraper — use `khadinakbar/youtube-transcript-extractor` if you need transcripts from full-length YouTube videos.

## `transcriptLanguage` (type: `string`):

ISO 639-1 two-letter language code for the transcript (e.g., 'en' for English, 'es' for Spanish, 'pt' for Portuguese, 'hi' for Hindi, 'fr' for French). If the requested language is unavailable, falls back to English, then to the first available caption track. Only used when includeTranscripts is true. Default: 'en'.

## `downloadVideos` (type: `boolean`):

When true, each Short is also downloaded as an MP4 and saved to the run's key-value store; the row gets videoFileUrl, fileSizeBytes, resolution and the route used. Direct and datacenter downloads use your chosen quality; if YouTube blocks both, a residential fallback saves the Short at up to 360p within a per-run bandwidth budget. Defaults to false (metadata only).

## `videoQuality` (type: `string`):

Maximum resolution when downloadVideos is true, measured on the short side (720p = 720×1280 for a vertical Short). Defaults to 720p; 'best' can pull 4K files of 50 MB or more.

## `maxFileSizeMb` (type: `integer`):

Skip a download when the file would be larger than this many megabytes. Integer from 1 to 2000; defaults to 100 (a typical Short is well under 30 MB).

## Actor input object example

```json
{
  "searchQuery": "morning routine tips",
  "searchQueries": [],
  "channelUrls": [],
  "hashtagUrls": [],
  "startUrls": [],
  "maxResults": 3,
  "publishedAfter": "",
  "publishedBefore": "",
  "fastMode": true,
  "maxConcurrency": 5,
  "proxyConfiguration": {
    "useApifyProxy": false
  },
  "includeTranscripts": false,
  "transcriptLanguage": "en",
  "downloadVideos": false,
  "videoQuality": "720p",
  "maxFileSizeMb": 100
}
```

# Actor output Schema

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

Dataset containing all scraped YouTube Shorts. Access via API or download as CSV/JSON from the Apify console.

## `csvExport` (type: `string`):

Download all scraped Shorts as a CSV file, ready for Excel or Google Sheets.

## `output` (type: `string`):

Machine-readable terminal outcome, persisted item count, warnings, and charge totals.

## `runSummary` (type: `string`):

Detailed lifecycle evidence including the final outcome, stop reason, failures, and build identifiers.

# 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 = {
    "searchQuery": "morning routine tips",
    "searchQueries": [],
    "channelUrls": [],
    "hashtagUrls": [],
    "startUrls": [],
    "maxResults": 3,
    "maxConcurrency": 5,
    "proxyConfiguration": {
        "useApifyProxy": false
    },
    "includeTranscripts": false,
    "transcriptLanguage": "en"
};

// Run the Actor and wait for it to finish
const run = await client.actor("khadinakbar/youtube-shorts-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 = {
    "searchQuery": "morning routine tips",
    "searchQueries": [],
    "channelUrls": [],
    "hashtagUrls": [],
    "startUrls": [],
    "maxResults": 3,
    "maxConcurrency": 5,
    "proxyConfiguration": { "useApifyProxy": False },
    "includeTranscripts": False,
    "transcriptLanguage": "en",
}

# Run the Actor and wait for it to finish
run = client.actor("khadinakbar/youtube-shorts-scraper").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 '{
  "searchQuery": "morning routine tips",
  "searchQueries": [],
  "channelUrls": [],
  "hashtagUrls": [],
  "startUrls": [],
  "maxResults": 3,
  "maxConcurrency": 5,
  "proxyConfiguration": {
    "useApifyProxy": false
  },
  "includeTranscripts": false,
  "transcriptLanguage": "en"
}' |
apify call khadinakbar/youtube-shorts-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,khadinakbar/youtube-shorts-scraper"
        }
    }
}
```

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/PSFecYjvfHumjoiRu/builds/heqWoc0irHKI2KiAI/openapi.json