# Youtube Video Summarizer (`scraper-engine/youtube-video-summarizer`) Actor

YouTube Video Summarizer instantly extracts key points, transcripts, and concise summaries from YouTube videos. Ideal for saving time, reviewing content, or generating insights—just enter a URL and get a quick summary, no watching required.

- **URL**: https://apify.com/scraper-engine/youtube-video-summarizer.md
- **Developed by:** [Scraper Engine](https://apify.com/scraper-engine) (community)
- **Categories:** Videos, Social media
- **Stats:** 179 total users, 3 monthly users, 100.0% runs succeeded, 3 bookmarks
- **User rating**: No ratings yet

## Pricing

$80.00 / 1,000 results

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?

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

### YouTube Video Summarizer — Metadata, Chapters and Transcripts

Get one structured JSON row per YouTube video: full metadata (title, views, likes, duration), chapters, thumbnails, channel details and the video's timestamped caption transcript — no HTML parsing, no browser automation to write yourself. Turn on optional AI summarization with your own AI provider key and every row also carries a short and a long-form summary. Paste your video URLs and run the Actor to see the output structure for yourself.

### What is YouTube Video Summarizer?

YouTube Video Summarizer is an Apify Actor that reads a list of YouTube video URLs and returns metadata, chapters, thumbnails, channel information and the timestamped transcript for each one, as consistent JSON. AI summarization is optional and off by default — no YouTube account or login is required for any part of the run; the Actor reads only what is publicly visible on the video page. It's built for content researchers, marketers repurposing video content, and developers or AI engineers feeding transcript data into downstream pipelines.

### What YouTube video data is publicly available to scrape?

Everything a signed-out visitor sees on a video's watch page — title, description, view/like counts, chapters, tags and captions — is publicly accessible. Data locked behind account status, region, or age gates is not.

| Data Category | Publicly Available | Restricted |
| --- | --- | --- |
| Video metadata (title, description, duration, views, likes, comment count) | Yes | — |
| Chapters, tags, hashtags, thumbnails | Yes | — |
| Timestamped captions/transcript | Yes, when a caption or auto-caption track exists | — |
| Channel details (name, subscriber count, about-page description, links) | Yes, from the channel's public "About" page | — |
| Members-only / channel-membership videos | No | Requires a paid channel membership login |
| Premium-only videos | No | Requires a YouTube Premium subscription login |
| Age-restricted videos | No | Requires a signed-in, age-verified session |
| Private videos | No | Visible only to the video owner |
| Region-locked (copyright-blocked) videos | No | Blocked entirely in the requester's region |

YouTube Video Summarizer only returns publicly visible data — what any visitor sees. Nothing behind a login wall.

### What data can I extract with YouTube Video Summarizer?

Each run returns one row per input URL, covering video identity, engagement metrics, and the transcript plus optional AI summary. Every key below is written by the Actor's row-building code (`ROW_KEYS` in `src/main.py`).

#### Video identity & descriptive fields

| Field Name | Description |
| --- | --- |
| `type` | Constant `"video"` |
| `status` | `"ok"` or `"error"` for this row |
| `id` / `video_id` | The YouTube video ID (same value in both keys) |
| `url` | Canonical `https://www.youtube.com/watch?v=…` URL, or `null` if extraction failed |
| `inputUrl` | The exact URL you supplied for this row |
| `title` | Video title |
| `description` | Full video description |
| `published_date` | Upload date, formatted `YYYY-MM-DD` |
| `relativeDate` | Human-readable age, e.g. `"3 month(s) ago"` |
| `category` | First category YouTube assigns to the video, if any |
| `language` | Video/audio language reported by YouTube, if available |
| `live_status` | Raw live-status signal, e.g. `not_live`, `is_live`, `was_live`, `is_upcoming` |
| `upload_type` | Derived: `normal`, `short`, `live`, `upcoming`, or `live_replay` |
| `isShort` | `true` if the video is a YouTube Short (URL path or vertical short-form video) |
| `resolution` | Reported video resolution, e.g. `1920x1080` |
| `age_limit` | Numeric age restriction reported by YouTube |
| `availability` | Raw availability signal, e.g. `public`, `private`, `premium_only`, `subscriber_only` |
| `tags` | Array of creator-assigned video tags |
| `hashtags` | Array of `#hashtags` parsed out of the title and description |
| `chapters` | Array of `{ start_time, end_time, title }` objects |
| `thumbnails` | Object keyed by quality: `default`, `medium`, `high`, `standard`, `maxres` (only keys that exist for this video are included) |
| `channel_id` | Channel ID |
| `channel_name` | Channel display name |
| `channel` | Nested object — see below |
| `error` | Friendly failure reason, or `null` on success |
| `scrapedAt` | UTC timestamp the row was produced |

`channel` is a nested object: `id`, `name`, `handle`, `url`, `subscriberCount`, `logo` (array of image URLs), `badges` (`["Verified"]` when applicable), `description`, `joined`, `country`, `subscribersText`, `viewsText`, `videosText`, `canonicalChannelUrl`, `links` (array of `{ title, url }`).

#### Engagement & duration metrics

| Field Name | Description |
| --- | --- |
| `duration_seconds` | Video length in seconds |
| `views` | View count |
| `likes` | Like count, if public |
| `comment_count` | Comment count, if comments are enabled |
| `engagement_rate` | `(likes + comment_count) / views`, rounded to 4 decimals; `null` when views is 0 or unavailable |

#### Transcript & AI summary fields

| Field Name | Description |
| --- | --- |
| `transcript` | Array of `{ start, dur, text }` timestamped caption segments |
| `transcriptText` | Full transcript as one plain-text string, or `null` if no caption track exists |
| `transcriptEntryCount` | Number of caption segments |
| `transcriptWordCount` | Word count of `transcriptText` |
| `transcriptSource` | Which caption track was used, e.g. `subtitles:en` or `auto_captions:en`; `null` if none found |
| `transcriptCoveragePercent` | Sum of caption segment durations divided by `duration_seconds`, ×100, capped at 100, rounded to 1 decimal; `null` when there is no transcript or no known duration |
| `summary` | Short AI summary (3–4 sentences); `null` unless AI summarization ran and succeeded |
| `long_summary` | Long-form Markdown AI summary with headings and bullets; `null` unless generated |
| `summary_source` | `"transcript"` if the summary was built from the caption text, `"title_description"` if it fell back to title + description because no transcript existed; `null` otherwise |
| `summaryStatus` | `disabled`, `no_api_key`, `skipped_too_long`, `no_source_text`, `generated`, or `failed` — see the FAQ below |

#### 🤖 Add-on: Need additional YouTube or video data?

If you only need captions and not the full metadata set, pair this with the **YouTube Video Subtitles Scraper**. Working across other video platforms too? The **Facebook Video Transcript Extractor** covers public Facebook videos, and **TikTok Scraper** covers TikTok profiles, videos and hashtag search in the same account.

### How does YouTube Video Summarizer differ from the official YouTube API?

The YouTube Data API v3 is Google's official public API and requires its own Google Cloud project and credentials; YouTube Video Summarizer requires neither. Per Google's own documentation (checked 2026‑08‑15), `captions.download` — the API's caption-retrieval endpoint — requires OAuth authorization and "the user to have permission to edit the video," meaning it cannot pull transcripts for videos you don't own. The default API quota allocation is 10,000 units/day shared across all endpoints (per Google's quota documentation, checked 2026‑08‑15).

| Feature | YouTube Data API v3 | YouTube Video Summarizer |
| --- | --- | --- |
| Setup | Google Cloud project, enabled API, API key or OAuth client | Paste URLs and run — no Google account needed |
| Caption/transcript access | OAuth + video-edit permission required; not available for videos you don't own | Reads the public caption track directly from the video page; no ownership required |
| Daily usage ceiling | Default 10,000 quota units/day across all endpoints | No platform-side daily unit quota — limited only by how many URLs you supply |
| AI summarization | Not part of the API | Optional built-in step using your own key, across 7 AI providers |
| Output shape | Separate calls for video, channel and caption resources | One row per video combining metadata, chapters, thumbnails, channel details and transcript |

Use the official API when you own the videos and need to manage captions or channel content under your own account. Use YouTube Video Summarizer when you need read-only metadata and transcripts for videos you don't own, across many URLs at once, without managing Google Cloud credentials.

### How to use YouTube Video Summarizer

Run it from the Apify Console or any Apify client — no code required to get your first result.

1. Open the Actor's page on the Apify Store and click **Try for free** (or **Start**, if you already have it saved).
2. Provide the required `urls` field — one or more YouTube video links.
3. Optionally turn on `enableAiSummaries`, pick an `aiModel`, and paste your own `aiApiKey` if you want summaries.
4. Set `maxDurationSeconds`, `maxRetries`, or `proxyConfiguration` if the defaults don't fit your batch.
5. Start the run and stream or download results from the dataset as JSON, CSV, or the other formats the Apify platform supports.

#### How to scale to bulk video extraction

`urls` is an array (`editor: stringList`, `minItems: 1`, no upper bound in the schema) — add as many video links as you need and each one is processed and pushed as its own row within the same run. There is no separate "batch" input; the array itself is the bulk mechanism.

### What can you do with YouTube video data?

- 📊 **Content analysts** tracking channel performance use `views`, `likes`, `comment_count` and `engagement_rate` to compare videos without opening YouTube Studio.
- ✍️ **Content marketers** repurposing video into blog posts use `transcriptText` and `chapters` to draft outlines without re-watching the video.
- 🔎 **Researchers** building topic datasets use `title`, `description`, `tags` and `hashtags` across many videos to study how creators frame a subject.
- 🤖 **AI engineers** building a RAG pipeline or agent tool feed `transcriptText` (or the timestamped `transcript` array) as source context, using `summary` as a pre-computed abstract to reduce token usage.
- 🏢 **Media teams** doing compliance or competitive review use `availability`, `age_limit` and `live_status` to flag videos that need manual follow-up.

Because output is typed, consistent JSON, it can be piped directly into a vector store, a LangChain document loader, or any LLM prompt without additional parsing.

### How does YouTube Video Summarizer handle rate limits and blocking?

Extraction runs through `yt_dlp` with several format-fallback strategies per video. By default requests go out directly; if you enable `proxyConfiguration`, that route is used from the start. Independently of your proxy setting, when running on the Apify platform the Actor keeps a fallback Apify Residential Proxy connection ready and switches to it once per video if a request looks retryable — timeouts, connection resets, SSL/certificate errors, "sign in to confirm you're not a bot," or HTTP 429/503. Each video is attempted up to `maxRetries` times (1–6, default 3), with a backoff sleep of `min(2 × attempt, 8)` seconds between attempts. If every attempt fails, or the video is private, members-only, premium-only, age-restricted, region-locked, unavailable, or not a valid YouTube URL, the row is returned with `status: "error"` and a plain-language `error` message — never a raw library or transport error. The Actor does not solve CAPTCHAs.

### ⬇️ Input

All parameters below come directly from `.actor/actor.json`'s input schema.

| Parameter | Required | Type | Description | Example Value |
| --- | --- | --- | --- | --- |
| `urls` | Yes | array of string | One or more YouTube video URLs. `minItems: 1`. Accepted shapes: `https://www.youtube.com/watch?v=VIDEO_ID`, `https://youtu.be/VIDEO_ID`, `https://www.youtube.com/shorts/VIDEO_ID`. Each link produces exactly one row. | `["https://www.youtube.com/watch?v=dQw4w9WgXcQ"]` |
| `enableAiSummaries` | No | boolean | Turn on the short + long AI summary for every video. Default `false`. When `true` you must also supply `aiApiKey` — there is no shared or built-in key. When `false`, metadata, chapters and transcript are still collected and `summary` / `long_summary` stay empty. | `true` |
| `aiModel` | No | string (enum) | Which AI model to use for summarization. Default `"gpt-4o-mini"`. Provider is auto-detected from the model name prefix. See the full enum list below. | `"claude-haiku-4-5"` |
| `aiApiKey` | No | string (secret) | Your own API key for the provider matching `aiModel`. If left empty, the Actor falls back to the matching environment variable (`OPENAI_API_KEY`, `ANTHROPIC_API_KEY`, `GOOGLE_API_KEY`/`GEMINI_API_KEY`, `XAI_API_KEY`, `DEEPSEEK_API_KEY`, `PERPLEXITY_API_KEY`, `MISTRAL_API_KEY`). With no key at all, summary fields return empty rather than placeholder text. | `"sk-ant-…"` |
| `maxDurationSeconds` | No | integer | Length guard for the AI step only. `minimum: 0`, default `0` (no limit). Videos longer than this still return full metadata and transcript, but the summary is skipped and `summaryStatus` is `"skipped_too_long"`. | `3600` |
| `maxRetries` | No | integer | How many times a single video is attempted before the row is returned with an error. `minimum: 1`, `maximum: 6`, default `3`. | `3` |
| `proxyConfiguration` | No | object | Apify Proxy settings (`editor: proxy`). Prefill: `{ "useApifyProxy": false }`. Optional for small runs; recommended for larger batches. | `{ "useApifyProxy": true }` |

**`aiModel` enum values:** `gpt-4o-mini` (GPT‑4o mini — OpenAI, cheap), `gpt-4o` (GPT‑4o — OpenAI), `gpt-4.1-mini` (GPT‑4.1 mini — OpenAI), `gpt-4.1` (GPT‑4.1 — OpenAI), `o3-mini` (o3‑mini — OpenAI, reasoning), `o1` (o1 — OpenAI, reasoning), `claude-haiku-4-5` (Claude Haiku 4.5 — Anthropic, cheapest), `claude-sonnet-5` (Claude Sonnet 5 — Anthropic), `claude-opus-4-8` (Claude Opus 4.8 — Anthropic, best), `gemini-2.0-flash-lite` (Gemini 2.0 Flash‑Lite — Google, cheapest), `gemini-2.0-flash` (Gemini 2.0 Flash — Google), `gemini-2.5-flash` (Gemini 2.5 Flash — Google), `gemini-2.5-pro` (Gemini 2.5 Pro — Google, best), `grok-3-mini` (Grok 3 mini — xAI, cheap), `grok-3` (Grok 3 — xAI), `deepseek-chat` (DeepSeek Chat/V3, cheap), `deepseek-reasoner` (DeepSeek Reasoner/R1), `sonar` (Sonar — Perplexity, cheap), `sonar-pro` (Sonar Pro — Perplexity), `mistral-small-latest` (Mistral Small, cheap), `mistral-large-latest` (Mistral Large).

⚠️ **Every pushed row — including rows where a video could not be read — is billed as one `row_result` event.** There is no separate uncharged error row; if you only want to review successful extractions, filter the dataset on `status == "ok"`.

#### Example input

```json
{
  "urls": [
    "https://www.youtube.com/watch?v=dQw4w9WgXcQ",
    "https://youtu.be/M7lc1UVf-VE"
  ],
  "enableAiSummaries": true,
  "aiModel": "claude-haiku-4-5",
  "aiApiKey": "sk-ant-your-own-key",
  "maxDurationSeconds": 3600,
  "maxRetries": 3,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

### ⬆️ Output

Every row is typed, normalized JSON with the same 42 keys on every run, whether the video succeeded or errored. Export the dataset as JSON, CSV, Excel, HTML, XML, or RSS directly from the Apify Console, or fetch it via the API/`apify-client`.

#### Example output

```json
{
  "type": "video",
  "status": "ok",
  "url": "https://www.youtube.com/watch?v=dQw4w9WgXcQ",
  "inputUrl": "https://www.youtube.com/watch?v=dQw4w9WgXcQ",
  "id": "dQw4w9WgXcQ",
  "video_id": "dQw4w9WgXcQ",
  "title": "Rick Astley - Never Gonna Give You Up (Official Video)",
  "description": "The official video for “Never Gonna Give You Up” by Rick Astley.",
  "published_date": "2009-10-25",
  "relativeDate": "16 year(s) ago",
  "duration_seconds": 213,
  "views": 1650000000,
  "likes": 18400000,
  "comment_count": 2300000,
  "engagement_rate": 0.0126,
  "category": "Music",
  "language": "en",
  "live_status": "not_live",
  "upload_type": "normal",
  "isShort": false,
  "resolution": "1920x1080",
  "tags": ["Rick Astley", "Never Gonna Give You Up", "80s"],
  "hashtags": ["#RickRoll"],
  "chapters": [
    { "start_time": 0, "end_time": 43, "title": "Intro" },
    { "start_time": 43, "end_time": 213, "title": "Song" }
  ],
  "thumbnails": {
    "default": "https://i.ytimg.com/vi/dQw4w9WgXcQ/default.jpg",
    "medium": "https://i.ytimg.com/vi/dQw4w9WgXcQ/mqdefault.jpg",
    "high": "https://i.ytimg.com/vi/dQw4w9WgXcQ/hqdefault.jpg",
    "standard": "https://i.ytimg.com/vi/dQw4w9WgXcQ/sddefault.jpg",
    "maxres": "https://i.ytimg.com/vi/dQw4w9WgXcQ/maxresdefault.jpg"
  },
  "age_limit": 0,
  "availability": "public",
  "channel_id": "UCuAXFkgsw1L7xaCfnd5JJOw",
  "channel_name": "Rick Astley",
  "channel": {
    "id": "UCuAXFkgsw1L7xaCfnd5JJOw",
    "name": "Rick Astley",
    "handle": "@RickAstleyYT",
    "url": "https://www.youtube.com/@RickAstleyYT",
    "subscriberCount": 4200000,
    "logo": ["https://yt3.googleusercontent.com/abc123"],
    "badges": ["Verified"],
    "description": "Official channel of Rick Astley.",
    "joined": "Oct 15, 2009",
    "country": "United Kingdom",
    "subscribersText": "4.2M subscribers",
    "viewsText": "2.1B views",
    "videosText": "150 videos",
    "canonicalChannelUrl": "https://www.youtube.com/@RickAstleyYT",
    "links": [{ "title": "Official Store", "url": "https://rickastleyshop.com/" }]
  },
  "transcriptSource": "subtitles:en",
  "transcriptEntryCount": 62,
  "transcriptWordCount": 411,
  "transcriptCoveragePercent": 97.4,
  "transcriptText": "We're no strangers to love. You know the rules and so do I…",
  "transcript": [
    { "start": "0.500", "dur": "3.200", "text": "We're no strangers to love" },
    { "start": "3.700", "dur": "3.100", "text": "You know the rules and so do I" }
  ],
  "summaryStatus": "generated",
  "summary": "An upbeat 1987 pop song by Rick Astley pledging unwavering commitment to a romantic partner, delivered over an energetic dance-pop arrangement.",
  "long_summary": "## Overview\nA classic 1987 pop single by Rick Astley...\n\n## Key themes\n- Loyalty and commitment\n- Classic 80s dance-pop production",
  "summary_source": "transcript",
  "error": null,
  "scrapedAt": "2026-08-15T09:12:03.000Z"
}
```

### How does it work?

YouTube Video Summarizer requests each video's public watch page directly (via `yt-dlp`), extracting metadata, chapters, thumbnails and the caption track without downloading any video or audio file — only text and structured data are collected. Channel details are filled in from the channel's public "About" page. If a request looks like it hit anti-bot friction (timeouts, connection resets, a bot-check response), the Actor automatically switches network route and retries, up to your configured `maxRetries`. Only what a signed-out visitor could already see is ever returned — no login, cookies, or session state are used. The output schema is fixed to the same 42 keys on every run, so downstream code doesn't break if YouTube changes its page layout.

### Integrations

YouTube Video Summarizer runs on the Apify platform, so it's reachable from anywhere that can call the Apify API.

#### Calling YouTube Video Summarizer programmatically

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_API_TOKEN>")
run = client.actor("<your-username>/youtube-video-summarizer").call(
    run_input={
        "urls": ["https://www.youtube.com/watch?v=dQw4w9WgXcQ"],
        "enableAiSummaries": False,
    }
)
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["title"], item["transcriptWordCount"])
```

Works in Go, Ruby, Node.js, cURL — any language that can make an HTTP request.

#### No-code tools (n8n, Make, LangChain)

In **n8n**, use the Apify node (or the HTTP Request node against the Apify API run endpoint) to start this Actor and read back the dataset. In **Make**, the Apify app's "Run an Actor" module does the same. In **LangChain**, Apify's `ApifyWrapper`/actor-call integration can invoke this Actor and load the resulting dataset directly as documents for a retriever or agent tool.

### ⚖️ Is it legal to scrape YouTube videos?

Scraping publicly visible YouTube video pages for metadata and captions is generally lawful when you only collect what any signed-out visitor already sees, subject to YouTube's own Terms of Service. YouTube Video Summarizer returns only that publicly available data — video metadata, chapters, thumbnails, channel "About" details and caption text. The core data here (titles, descriptions, view counts, chapters, transcript text) is published content rather than personal data about a private individual, so it sits under YouTube's Terms of Service and general content/database-rights considerations rather than GDPR/CCPA; channel names and handles are creators' public business identifiers, not private personal information. Consult legal counsel if your use case involves bulk storage of personal data.

### ❓ Frequently asked questions

#### What YouTube video fields does YouTube Video Summarizer return?

It returns `title`, `views`, `duration_seconds`, `transcriptText` and `channel_name` among 42 total fields per row — see the [data fields section](#what-data-can-i-extract-with-youtube-video-summarizer) above for the full list.

#### Does YouTube Video Summarizer require a YouTube account or login?

No. The Actor reads only publicly visible video pages and channel "About" pages; no YouTube account, cookies, or session is used anywhere in the source code.

#### How many videos can I extract in one run?

`urls` is an array with `minItems: 1` and no schema-enforced maximum — add as many links as you want processed in a single run; each produces its own dataset row.

#### What happens if a video is private, members-only, age-restricted or region-locked?

The row is still returned with `status: "error"`, `url: null`, and a plain-language `error` message (e.g. "This video is private.", "This video is available to channel members only.", "This video is unavailable in this region."). No exception is thrown for individual failed videos — the run continues to the next URL.

#### Can I scrape multiple YouTube videos at once?

Yes — pass multiple entries in the `urls` array in a single run; this is the Actor's only and complete bulk-input mechanism.

#### Does YouTube Video Summarizer work with Claude, ChatGPT and other AI agent tools?

It's callable as an Apify API/HTTP endpoint by any agent framework that can make an HTTP request, using `apify-client` or a raw REST call — see Integrations above.

#### How is this different from just pasting a link into an AI chatbot?

A chatbot summary is generated from whatever the model can infer about the link, with no guarantee of an actual transcript. This Actor first extracts the real caption track from YouTube (`transcriptSource`, `transcriptCoveragePercent` tell you exactly what was used) and only then summarizes that verified text with the AI provider and key you choose — plus you get the full metadata, chapters and channel data in the same structured row, across as many videos as you supply in one run.

#### Does YouTube Video Summarizer return data in a format LLMs can use directly?

Yes. Typed, normalized JSON with consistent field names across every run — no HTML parsing or CSS selectors. Pass `transcriptText` or the timestamped `transcript` array straight into an LLM prompt, a vector store, or an agent tool.

#### What happens when YouTube changes its layout or anti-bot system?

The Actor is maintained and the output schema stays stable across updates; no specific turnaround time is promised for fixes.

#### Can I use YouTube Video Summarizer without managing proxies or browser infrastructure?

Yes. No browser is launched — extraction goes through `yt-dlp` directly, and on the Apify platform the Actor automatically escalates to a residential proxy route if a request looks blocked, without any proxy setup required from you. Enabling `proxyConfiguration` yourself is optional and mainly useful for larger batches.

#### Which YouTube video fields work best for AI training data and RAG indexing?

For RAG, index `transcriptText` (or the timestamped `transcript` array for citation-level precision) alongside `title` and `description` for retrieval context. For structured training features, `duration_seconds`, `views`, `engagement_rate` and `transcriptWordCount` return as consistent typed numbers across every row.

### Related scrapers

| Scraper Name | What it extracts |
| --- | --- |
| YouTube Video Subtitles Scraper | Clean subtitles/transcripts only, from YouTube video URLs |
| Facebook Video Transcript Extractor | Transcripts from public Facebook videos |
| TikTok Scraper | TikTok profiles, videos, reposts, hashtags and keyword search results |

### 💬 Your feedback

Found a bug or missing a field? Let us know through the Actor's Issues tab on the Apify Store, or contact Scraper Engine support directly — reports like this keep the Actor maintained and accurate.

# Actor input Schema

## `urls` (type: `array`):

📺 **One or more YouTube video links to process.**

Accepted shapes:
• `https://www.youtube.com/watch?v=VIDEO_ID`
• `https://youtu.be/VIDEO_ID`
• `https://www.youtube.com/shorts/VIDEO_ID`

Each link produces exactly one row with metadata, transcript and (optionally) a summary. Add as many links as you need for bulk processing. 💡

## `enableAiSummaries` (type: `boolean`):

✨ **Turn on the short + long AI summary for every video.**

When ON you must also supply your own API key below - the Actor never uses a shared or built-in key. When OFF (default) all metadata, chapters and transcript fields are still collected and `summary` / `long_summary` stay empty.

## `aiModel` (type: `string`):

Provider is detected from the model name: `claude-*` = Anthropic, `gpt-*` / `o1` / `o3` = OpenAI, `gemini-*` = Google, `grok-*` = xAI, `deepseek-*` = DeepSeek, `sonar*` = Perplexity, `mistral-*` = Mistral. Cheaper mini / flash / haiku models are usually enough for summarization.

## `aiApiKey` (type: `string`):

🔐 **Your own API key for the provider that matches the model above.**

Stored as a secret and used only to request the summaries for this run. If you leave it empty the Actor also accepts the matching environment variable (`OPENAI_API_KEY`, `ANTHROPIC_API_KEY`, `GOOGLE_API_KEY`, `XAI_API_KEY`, `DEEPSEEK_API_KEY`, `PERPLEXITY_API_KEY`, `MISTRAL_API_KEY`). With no key at all, summary fields are returned empty rather than filled with placeholder text.

## `maxDurationSeconds` (type: `integer`):

🎚️ **Length guard for the AI step only.** Videos longer than this still return complete metadata and the full transcript, but the summary is skipped and `summaryStatus` reads `skipped_too_long`.

Example: `3600` = skip summaries for anything over 1 hour. `0` (default) = no limit.

## `maxRetries` (type: `integer`):

How many times a single video is attempted before the row is returned with an error reason. Example: `3` (default) usually clears temporary hiccups; raise it for large batches.

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

🛡️ **Optional network settings.** Leave it off for small runs. For larger batches, enabling Apify Proxy makes the run more reliable.

## Actor input object example

```json
{
  "urls": [
    "https://www.youtube.com/watch?v=dQw4w9WgXcQ"
  ],
  "enableAiSummaries": false,
  "aiModel": "gpt-4o-mini",
  "maxDurationSeconds": 0,
  "maxRetries": 3,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

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

All scraped items in the Actor's default dataset.

# 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 = {
    "urls": [
        "https://www.youtube.com/watch?v=dQw4w9WgXcQ"
    ],
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("scraper-engine/youtube-video-summarizer").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 = {
    "urls": ["https://www.youtube.com/watch?v=dQw4w9WgXcQ"],
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("scraper-engine/youtube-video-summarizer").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 '{
  "urls": [
    "https://www.youtube.com/watch?v=dQw4w9WgXcQ"
  ],
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call scraper-engine/youtube-video-summarizer --silent --output-dataset

```

## MCP server setup

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

```

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/2DZgHT8sqLrAJRY8c/builds/Jc7RXRBzEPuLBhn88/openapi.json