# YouTube Scraper (`automation-lab/youtube-scraper`) Actor

Scrape YouTube videos, channels, and comments at scale. Search by keyword, get video details (views, likes, duration, category), channel profiles (subscribers, verification), and comments. Uses YouTube InnerTube API — no browser, no API key needed.

- **URL**: https://apify.com/automation-lab/youtube-scraper.md
- **Developed by:** [Automation Lab](https://apify.com/automation-lab) (community)
- **Categories:** Social media, Videos
- **Features:** Limited permissions
- **Stats:** 368 total users, 34 monthly users, 99.9% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.50 / 1,000 video scrapeds

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

## YouTube Scraper

Scrape YouTube videos, channels, and comments at scale. Extract video metadata (titles, views, likes, duration, descriptions), channel info (subscribers, verification status), and comments (text, likes, replies). No YouTube API key required.

### What does YouTube Scraper do?

YouTube Scraper extracts structured data from YouTube using four modes:

- **Search** — Search YouTube by keyword and get video results with titles, views, duration, and thumbnails
- **Video details** — Get full metadata for specific videos including likes, category, keywords, and comment counts
- **Channels and videos** — Scrape channel profiles plus recent videos with channel IDs, names, URLs, views, durations, and publish-time text
- **Comments** — Extract comments from any video with author info, likes, reply counts, and hearted status

The scraper uses YouTube's internal API (InnerTube) for fast, reliable extraction without a browser. Results are returned as structured JSON ready for analysis.

### Why use YouTube Scraper? — Who is it for

**Who is it for?** YouTube Scraper is for marketers, researchers, data engineers, and developers who need structured YouTube data without dealing with API quotas or authentication overhead.

- **No API key needed** — Works without YouTube Data API quotas or credentials
- **All-in-one** — Search, video details, channels, and comments in a single tool
- **Rich metadata** — Views, likes, duration, category, keywords, publish dates, and more
- **Fast extraction** — Pure HTTP requests, no browser overhead (256 MB memory)
- **Pagination built-in** — Automatically fetches multiple pages of results
- **Flexible input** — Accepts URLs, video IDs, channel handles (@name), or channel IDs

### Use cases

#### Marketing and brand teams

- **Market research** — Track video performance, trending topics, and competitor channels
- **Brand monitoring** — Track mentions, comments, and engagement on relevant videos
- **SEO research** — Study YouTube search results, keywords, and ranking patterns

#### Agencies and content creators

- **Content analysis** — Analyze video metadata, engagement metrics, and publishing patterns to inform content strategy
- **Influencer analytics** — Gather channel stats, subscriber counts, and content output for partnership decisions
- **Competitive benchmarking** — Compare video performance across channels in your niche

#### Research and data teams

- **Sentiment analysis** — Extract comments for NLP processing and audience feedback
- **Academic research** — Collect structured data for social media studies and trend analysis
- **Dataset building** — Create training datasets from YouTube content metadata for ML models

### Input parameters

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `searchQueries` | string\[] | `[]` | Keywords to search on YouTube |
| `videoUrls` | string\[] | `[]` | Video URLs or IDs for detailed scraping |
| `channelUrls` | string\[] | `[]` | Channel URLs, handles, or IDs |
| `maxResults` | integer | `100` | Max videos per query or channel |
| `maxComments` | integer | `0` | Max comments per video (0 = skip) |
| `sortBy` | enum | `relevance` | Sort: relevance, date, viewCount, rating |
| `language` | string | `en` | Content language (ISO code) |
| `country` | string | `US` | Content country (ISO code) |

You can combine all three input types (search queries + video URLs + channel URLs) in a single run. Each channel input returns one channel profile followed by up to `maxResults` recent video rows; every channel-video row includes the resolved `channelId`, `channelName`, and `channelUrl`.

### Output example

#### Video result

```json
{
  "type": "video",
  "videoId": "dQw4w9WgXcQ",
  "title": "Rick Astley - Never Gonna Give You Up (Official Video)",
  "url": "https://www.youtube.com/watch?v=dQw4w9WgXcQ",
  "channelName": "Rick Astley",
  "channelId": "UCuAXFkgsw1L7xaCfnd5JJOw",
  "channelUrl": "https://www.youtube.com/channel/UCuAXFkgsw1L7xaCfnd5JJOw",
  "viewCount": 1747977458,
  "likeCount": 18828635,
  "duration": "3:33",
  "durationSeconds": 213,
  "publishedAt": "2009-10-24T23:57:33-07:00",
  "description": "The official video for \"Never Gonna Give You Up\" by Rick Astley...",
  "thumbnailUrl": "https://i.ytimg.com/vi_webp/dQw4w9WgXcQ/maxresdefault.webp",
  "category": "Music",
  "keywords": ["rick astley", "Never Gonna Give You Up", "rickroll"],
  "isLive": false,
  "commentCount": 2400000,
  "scrapedAt": "2026-03-05T02:31:42.157Z"
}
```

#### Channel result

```json
{
  "type": "channel",
  "channelId": "UCsBjURrPoezykLs9EqgamOA",
  "channelName": "Fireship",
  "channelUrl": "https://www.youtube.com/@Fireship",
  "handle": "@Fireship",
  "subscriberCount": "4.11M subscribers",
  "videoCount": "727 videos",
  "description": "High-intensity code tutorials and tech news...",
  "avatarUrl": "https://yt3.ggpht.com/...",
  "bannerUrl": "https://yt3.googleusercontent.com/...",
  "isVerified": true,
  "scrapedAt": "2026-03-05T02:31:50.123Z"
}
```

#### Comment result

```json
{
  "type": "comment",
  "videoId": "dQw4w9WgXcQ",
  "commentId": "Ugzge340dBgB75hWBm54AaABAg",
  "text": "can confirm: he never gave us up",
  "authorName": "@YouTube",
  "authorChannelId": "UCBR8-60-B28hp2BmDPdntcQ",
  "likeCount": 192,
  "replyCount": 960,
  "publishedTimeText": "10 months ago",
  "isHearted": true,
  "scrapedAt": "2026-03-05T02:31:44.277Z"
}
```

### How to scrape YouTube videos

1. Open [YouTube Scraper](https://apify.com/automation-lab/youtube-scraper) on Apify.
2. Enter search keywords in `searchQueries`, video URLs in `videoUrls`, or channel URLs in `channelUrls`.
3. Set `maxResults` to control how many videos to scrape per query or channel.
4. Optionally set `maxComments` to extract comments from videos.
5. Click **Start** and wait for the run to finish.
6. Download results as JSON, CSV, or Excel from the Dataset tab.

### How much does it cost to scrape YouTube?

YouTube Scraper uses pay-per-event pricing so you only pay for what you scrape:

| Event | Price |
|-------|-------|
| Run start | $0.005 |
| Video scraped | $0.003 |
| Channel scraped | $0.003 |
| Comment scraped | $0.0005 |

#### Cost examples

| Task | Items | Estimated cost |
|------|-------|---------------|
| Search 50 videos | 50 videos | ~$0.16 |
| 10 video details + comments (20 each) | 10 videos + 200 comments | ~$0.14 |
| 5 channels with 100 videos each | 5 channels + 500 videos | ~$1.52 |
| Bulk 1,000 search results | 1,000 videos | ~$3.01 |

Platform compute costs (typically $0.001–0.01 per run) are included in these estimates.

### API usage — code examples

#### Node.js

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

const client = new ApifyClient({ token: 'YOUR_API_TOKEN' });

const run = await client.actor('automation-lab/youtube-scraper').call({
    searchQueries: ['machine learning tutorial'],
    maxResults: 20,
});

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

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient('YOUR_API_TOKEN')

run = client.actor('automation-lab/youtube-scraper').call(run_input={
    'searchQueries': ['machine learning tutorial'],
    'maxResults': 20,
})

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

#### cURL

```bash
curl "https://api.apify.com/v2/acts/automation-lab~youtube-scraper/runs" \
  -X POST \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer YOUR_API_TOKEN" \
  -d '{"searchQueries": ["machine learning tutorial"], "maxResults": 20}'
```

### Integrations

YouTube Scraper works with all [Apify integrations](https://apify.com/integrations) out of the box:

- **Google Sheets** — Auto-export video stats and channel data to a spreadsheet for tracking performance over time
- **Slack / Email** — Get notified when scraping completes, or set up alerts for videos exceeding view thresholds
- **Webhooks** — Send results to your API endpoint for custom processing or content pipelines
- **Zapier / Make** — Connect to 5,000+ apps, e.g., save top-performing videos to Notion or trigger reports for new competitor uploads
- **Scheduled runs** — Set up recurring scrapes (hourly, daily, weekly) to monitor channels or search queries
- **Data warehouses** — Pipe data to BigQuery, Snowflake, or PostgreSQL for large-scale video analytics
- **AI/LLM pipelines** — Feed video titles, descriptions, and comments into sentiment analysis or content recommendation models

### Input examples

#### Search for videos

```json
{
  "searchQueries": ["python tutorial", "web development"],
  "maxResults": 50,
  "sortBy": "viewCount"
}
```

#### Get video details with comments

```json
{
  "videoUrls": [
    "https://www.youtube.com/watch?v=dQw4w9WgXcQ",
    "https://youtu.be/jNQXAC9IVRw"
  ],
  "maxComments": 100
}
```

#### Scrape channels

```json
{
  "channelUrls": [
    "@Fireship",
    "https://www.youtube.com/@mkbhd",
    "UCsBjURrPoezykLs9EqgamOA"
  ],
  "maxResults": 200
}
```

### Tips and best practices

- **Combine modes** — Use search queries, video URLs, and channel URLs in a single run to minimize startup costs
- **Start small** — Test with `maxResults: 10` before scaling up to hundreds
- **Comments are optional** — Set `maxComments: 0` (default) to skip comments and reduce costs
- **Flexible video input** — Pass full URLs (`youtube.com/watch?v=...`, `youtu.be/...`) or just the 11-character video ID
- **Channel handles** — Use `@ChannelName` format, full URL, or channel ID (starting with UC)
- **Sort options** — Use `viewCount` to find popular videos or `date` for the latest uploads
- **Localization** — Set `language` and `country` to get region-specific results

### Use with AI agents via MCP

YouTube Scraper is available as a tool for AI assistants that support the [Model Context Protocol (MCP)](https://docs.apify.com/platform/integrations/mcp). This lets you use natural language to scrape data — just ask your AI assistant and it will configure and run the scraper for you.

#### Setup for Claude Code

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

#### Setup for Claude Desktop, Cursor, or VS Code

Add this to your MCP config file:

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

Your AI assistant will use OAuth to authenticate with your Apify account on first use.

#### Example prompts

Once connected, try asking your AI assistant:

- "Scrape the top 50 videos for 'machine learning tutorial'"
- "Get all comments from this YouTube video"
- "Scrape channel info and videos from @mkbhd"

Learn more in the [Apify MCP documentation](https://docs.apify.com/platform/integrations/mcp).

### Limitations

- Comments are top-level only (no nested replies)
- Live stream chat messages are not captured
- Age-restricted videos may return limited metadata
- YouTube may rate-limit very large scraping jobs; the scraper handles retries automatically
- Removed, private or nonexistent videos produce no row; the run status lists how many requested videos were delivered and why the rest were not, and a run that delivers none of its requested videos ends as failed

### FAQ

**Does this scraper require a YouTube API key?**
No. It uses YouTube's internal InnerTube API, so you don't need a YouTube Data API key or quota.

**How many videos can I scrape per search query?**
Up to several hundred per query. YouTube's internal API paginates results, and the scraper follows pagination automatically up to your `maxResults` limit.

**Can I scrape comments from any video?**
Yes, as long as comments are enabled on the video. Set `maxComments` to the number of comments you want per video. Comments are top-level only (no nested replies).

**The scraper returns fewer results than expected — what's happening?**
YouTube may return fewer results than your `maxResults` setting if the search query has limited matches or if you're scraping a channel with fewer videos. For search queries, try broader keywords or different `sortBy` options.

**Some videos show 0 likes — is the scraper broken?**
No. YouTube hides like counts on some videos at the creator's request. When like counts are hidden, the API returns 0.

### How do you scrape YouTube without an API key?

YouTube's official Data API v3 has a daily quota of 10,000 units — enough for roughly 100 search queries or 10,000 video detail lookups. That quota resets once per day, and exceeding it requires applying for a quota increase (which Google often denies). For serious research or production pipelines, the official API is frequently too restrictive.

YouTube Scraper bypasses these limitations entirely by using YouTube's internal InnerTube API — the same API that the YouTube web app uses to load search results, video metadata, and comments. This API has no public quota system, no key requirement, and supports the full range of data available on the YouTube website.

The trade-off: YouTube can change its internal API at any time without notice, whereas the official Data API v3 is a stable, versioned product. For production use, be aware that internal API-based scrapers may need periodic updates when YouTube changes its front-end.

For cost comparison, YouTube Scraper charges $0.003 per video and $0.0005 per comment, with no monthly fees. The official API is "free" within quota but requires developer overhead, OAuth setup, and quota management — and research-grade quotas now require paid Google Cloud billing.

### How do you scrape YouTube comments at scale?

YouTube comments are one of the richest sources of unfiltered consumer opinion on products, services, and topics. To extract them with YouTube Scraper:

1. Set `videoUrls` to the list of videos you want comments from
2. Set `maxComments` to the number of comments per video (e.g., 500 for a medium-depth scrape)
3. Run the scraper — comments are returned as separate items with `type: "comment"` in the dataset

**Practical limits to know:**

- Very popular videos can have millions of comments; YouTube's internal API paginates them in batches of ~20
- Extracting 1,000 comments from a single video costs $0.50 (1,000 × $0.0005) plus the video metadata charge
- YouTube shows comments in "top comments" order by default (highest engagement first) — this is generally what you want for sentiment analysis since it surfaces the most-reacted opinions

**What you get per comment:** text content, author username, author channel ID, like count, reply count, whether the creator hearted it, and publish timestamp (as relative text like "2 years ago").

**Limitations:** The scraper returns top-level comments only — nested replies within comment threads are not included. For most NLP and sentiment use cases, top-level comments are sufficient.

### Error reporting

Failed operations send sanitized diagnostic input, exceptions and Actor, build and run IDs to our private GlitchTip service so we can repair them. Secret fields and URL queries are removed, and reports are retained for 30 days.

### Is it legal to scrape YouTube? — Legality

Scraping publicly available YouTube data — video metadata, channel statistics, and comments that any visitor can see without logging in — is generally legal under the US Ninth Circuit's ruling in hiQ Labs v. LinkedIn (2022), which held that scraping public web data does not violate the Computer Fraud and Abuse Act.

YouTube Scraper:

- Does not require authentication or bypass any login
- Only accesses data that is publicly visible on youtube.com
- Does not circumvent age restrictions or geographic blocks
- Does not download video files (only metadata, thumbnails, and text)

However, there are considerations:

- Google's Terms of Service prohibit automated scraping of YouTube. For personal research and small-scale analysis, enforcement is rare. For large commercial operations, be aware of the ToS risk.
- GDPR applies if you're collecting comment text linked to identifiable EU users for commercial purposes
- Academic researchers scraping for non-commercial studies operate in a stronger legal position than commercial data aggregators

When in doubt, use the official YouTube Data API for projects with strict compliance requirements, and use YouTube Scraper where quota constraints make the official API impractical.

### How do you track a YouTube channel's performance over time?

Tracking a channel's growth and video performance over time requires capturing snapshots at regular intervals and comparing them. Here's a practical setup:

**Step 1: Set up a scheduled scrape**
Configure YouTube Scraper with the channel URLs you want to track and set `maxResults` to cover all recent videos (e.g., 50 for active channels). Use [Apify Schedules](https://docs.apify.com/platform/schedules) to run weekly.

**Step 2: Export to a time-series dataset**
Each run adds new data to a dataset. Export to Google Sheets or BigQuery, appending rows with each run. The `scrapedAt` timestamp lets you build time-series charts.

**Step 3: Calculate growth metrics**
Compare subscriber count week-over-week for channel growth rate. For individual videos, compare view count between runs to measure velocity (views per day). Videos with accelerating view counts are being promoted by the algorithm.

**Key metrics to track:**

- Subscriber count delta (channel growth)
- View count velocity for recent videos (algorithm pickup)
- Like/view ratio (engagement quality signal)
- Upload frequency (content cadence)
- Video length trends (format experimentation)

Cost for monitoring 10 channels with 50 videos each, weekly: 10 channels × $0.003 + 500 videos × $0.003 ≈ $1.53 per run, or about $6/month.

### How do you do YouTube SEO research with a scraper?

YouTube SEO research involves understanding what keywords drive views, what video formats rank, and what content gaps competitors haven't filled. A scraper gives you the raw data to answer these questions systematically.

**Keyword research via search results:**
Search a target keyword in YouTube Scraper with `sortBy: "relevance"` and collect the top 50–100 results. For each video, note: title patterns (which words appear in every top-ranking title), video length (do short or long videos dominate?), view counts (what's the floor for ranking in the top 20?), and upload age (how fresh does content need to be?).

**Competitor channel analysis:**
Scrape competitor channels with `maxResults: 200` to get their full video catalog. Sort by view count to find their top performers. Look for:

- Topic clusters where they have many high-performing videos (they've established authority there)
- Topics with only one or two videos despite strong performance (an opportunity to go deeper)
- Upload cadence gaps (if they stopped covering a topic, that's your opening)

**Comment mining for content ideas:**
Extract comments from top-performing videos in your niche. Search for questions in the comment text — phrases like "how do I", "what about", "can you make a video on". These are content requests your audience is already making.

**Title and description patterns:**
Collect the `title`, `description`, and `keywords` fields from the top 20 videos for your target keyword. Identify which words appear in 50%+ of top-ranking titles — those are the terms YouTube's algorithm associates with relevance for that query.

### Related YouTube and video scrapers on Apify

- [YouTube Shorts Scraper](https://apify.com/automation-lab/youtube-shorts-scraper) -- extract Shorts data from YouTube channels
- [YouTube Transcript Scraper](https://apify.com/automation-lab/youtube-transcript) -- extract transcripts and subtitles from YouTube videos
- [YouTube Transcript Enhanced](https://apify.com/automation-lab/youtube-transcript-enhanced) -- transcripts with SRT/VTT export, paragraph chunking, and keyword search
- [TikTok Scraper](https://apify.com/automation-lab/tiktok-scraper) -- scrape TikTok videos, profiles, and hashtags
- [Instagram Scraper](https://apify.com/automation-lab/instagram-scraper) -- extract Instagram posts, profiles, and hashtags

### Changelog

### 2026-06-20

*Features*

- Added public task examples to help users start common YouTube video, channel, and comment scraping workflows.

### 2026-04-26

*Reliability*

- Switched YouTube requests to a lower-cost proxy path and fixed precheck issues blocking Store readiness.

### 2026-03-26

*Reliability*

- Added gzip request headers to reduce transfer size and improve YouTube request efficiency.

### 2026-03-24

*Changes*

- Improved Store documentation and input form sections for YouTube SEO and setup clarity.

### 2026-03-05

*Features*

- Launched YouTube scraping for videos, channels, and comments using YouTube InnerTube data.

# Changelog

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

# Actor input Schema

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

Keywords to search on YouTube. Each query returns up to maxResults videos.

## `videoUrls` (type: `array`):

YouTube video URLs or IDs to scrape detailed metadata for.

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

YouTube channel URLs, handles (@name), or IDs. Returns each channel profile and up to maxResults recent videos with channel attribution.

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

Maximum number of videos per search query or channel.

## `maxComments` (type: `integer`):

Maximum comments to scrape per video. Set to 0 to skip comments.

## `sortBy` (type: `string`):

Sort order for search results.

## `language` (type: `string`):

Content language (ISO code: en, de, fr, es, ja, etc.).

## `country` (type: `string`):

Content country (ISO code: US, GB, DE, JP, etc.).

## Actor input object example

```json
{
  "searchQueries": [
    "javascript tutorial"
  ],
  "maxResults": 10,
  "maxComments": 0,
  "sortBy": "relevance",
  "language": "en",
  "country": "US"
}
```

# Actor output Schema

## `dataset` (type: `string`):

Dataset containing scraped videos, channels, and comments.

## `debug` (type: `string`):

Key-value store containing first-item InnerTube responses for troubleshooting.

# 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 = {
    "searchQueries": [
        "javascript tutorial"
    ],
    "maxResults": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/youtube-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 = {
    "searchQueries": ["javascript tutorial"],
    "maxResults": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/youtube-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 '{
  "searchQueries": [
    "javascript tutorial"
  ],
  "maxResults": 10
}' |
apify call automation-lab/youtube-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,automation-lab/youtube-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/VfztCF92saVMldq1A/builds/rfZxgcK6B8pXJK2fl/openapi.json