# YouTube Channel Intelligence & Transcript Analyzer (`mindgamelabs/youtube-channel-intelligence`) Actor

Other YouTube tools dump raw transcripts. This one hands you the strategy: point it at any channel and get a cross-video intelligence report - topics, hook patterns, what top videos share, content gaps. Transcripts + AI summaries included. Unofficial; not affiliated with YouTube.

- **URL**: https://apify.com/mindgamelabs/youtube-channel-intelligence.md
- **Developed by:** [Market Maker](https://apify.com/mindgamelabs) (community)
- **Categories:** AI, Social media, Videos
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 transcript extracteds

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

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

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

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js/docs.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/integrations/mcp.md).

If your project is in a different language, use 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 Channel Intelligence & Transcript Analyzer

Turn any YouTube channel into a strategy brief. Give this Actor a channel URL and it pulls the
recent videos, extracts their transcripts, writes a concise AI summary of each, and — the part
nobody else does — synthesizes **one cross-video intelligence report** for the whole channel:
the topics it really covers, the title and hook patterns that recur, what its top-performing
videos share, and where the content gaps are.

Most YouTube tools hand you 500 rows of raw transcript. This one hands you the memo.

> **Unofficial.** This Actor is not affiliated with, endorsed by, or connected to YouTube or
> Google. It processes publicly available video data only.

### What you get

- **Per-video rows** — title, URL, channel, publish date, duration, view count, status, full
  transcript, and (optional) an AI summary of the key points.
- **A channel report row** — a synthesized strategy analysis across all analyzed videos.

### Features

- Analyze one channel or many in a single run
- Full transcript extraction (public captions), cleaned and de-duplicated
- Concise per-video AI summaries — the concrete methods, tools, and claims, no filler
- Cross-video **channel intelligence report**: topic clusters, hook/title patterns,
  top-performer commonalities, upload cadence, content gaps, and a one-line positioning read
- Typed, structured output with separate **Videos** and **Channel reports** views
- Fails gracefully per video (age-restricted, no captions, removed) — one bad video never
  sinks the run

### Use cases

- **Competitor research** — read a rival channel's whole strategy in one run
- **Content planning** — find the gaps and the patterns that win in your niche
- **Creator due diligence** — brief yourself on any channel before a collab or sponsorship
- **Research & trend tracking** — turn a channel's back-catalog into searchable notes
- **Agent workflows** — call it from Claude, Cursor, or any MCP client to feed channel
  intelligence into a larger pipeline

### Input

| Field | Type | Description |
|---|---|---|
| `channelUrls` | array (required) | One or more channel URLs, e.g. `https://www.youtube.com/@channelname` |
| `maxVideos` | integer | Recent videos to analyze per channel (default 10) |
| `includeSummaries` | boolean | Add an AI summary to each video (default true) |
| `includeChannelReport` | boolean | Generate the cross-video report per channel (default true) |
| `llmApiKey` | secret string | Optional — bring your own Anthropic key to run the AI at cost |

```json
{
  "channelUrls": ["https://www.youtube.com/@anthropic-ai"],
  "maxVideos": 10,
  "includeSummaries": true,
  "includeChannelReport": true
}
````

### Output

**Video row:**

```json
{
  "type": "video",
  "channel": "Anthropic",
  "title": "The different levels of how Claude thinks",
  "videoUrl": "https://www.youtube.com/watch?v=...",
  "publishedDate": "2026-07-06",
  "durationMinutes": 5.5,
  "viewCount": 280588,
  "status": "ok",
  "summary": "- ...\n- ...",
  "transcript": "Think of the mind like an ocean..."
}
```

**Channel report row:**

```json
{
  "type": "channelReport",
  "channel": "Anthropic",
  "channelUrl": "https://www.youtube.com/@anthropic-ai",
  "videosAnalyzed": 10,
  "report": "1) Core topics... 2) Title/hook patterns... 3) Top videos share..."
}
```

### Pricing (pay per event)

You pay only for what the run produces:

| Event | Price |
|---|---|
| Transcript extracted | $0.003 / video |
| Video summarized | $0.04 / video |
| Channel report generated | $1.50 / channel |

A typical 10-video run with summaries and a report costs about **$1.93**. Platform usage
(compute, proxy) is billed to your account at Apify's standard rates. You are charged only for
work that succeeds.

### How to use

1. Paste one or more channel URLs into `channelUrls`.
2. Set `maxVideos` (higher = deeper report, more cost).
3. Run. Read the **Channel reports** view for the strategy memo; the **Videos** view for the
   per-video detail and transcripts.
4. Calling from an AI agent? The Actor is exposed via Apify's MCP server — your agent can
   discover it, read this schema, and call it directly.

### Troubleshooting

| Symptom | Cause / fix |
|---|---|
| A video shows `status: no_captions` | That video has no public captions; nothing to transcribe. |
| A video shows `status: age_restricted` or `blocked` | Not publicly accessible without sign-in; skipped by design. |
| Summaries/report are empty | No AI key available for that run — transcripts still returned. |
| Run returns few videos | The channel has fewer public uploads than `maxVideos`. |

### FAQ

**Is this legal?** The Actor processes only publicly available video pages and their public
captions, and produces transformative analysis. It does not access private, paid, or
login-walled content. You are responsible for how you use the output.

**Is this affiliated with YouTube?** No. It is an independent tool and is not affiliated with,
endorsed by, or connected to YouTube or Google.

**Can AI agents call this?** Yes — it's available through the Apify MCP server with typed input
and output schemas.

# Actor input Schema

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

REQUIRED. One or more YouTube channel URLs, e.g. https://www.youtube.com/@channelname . The actor fetches recent public videos, extracts their transcripts, optionally summarizes each, and writes one cross-video intelligence report per channel.

## `maxVideos` (type: `integer`):

How many recent videos to analyze per channel. Higher gives a deeper report but costs more. Default 10.

## `includeSummaries` (type: `boolean`):

Add a concise AI summary to each video row. Adds one video-summarized charge per successfully summarized video.

## `includeChannelReport` (type: `boolean`):

Synthesize one strategy report per channel: topic clusters, title and hook patterns, upload cadence, what the top videos share, and content gaps. Adds one channel-report-generated charge per channel.

## `llmApiKey` (type: `string`):

Optional. Bring your own OpenAI-compatible API key (DeepSeek by default) to run the AI at cost. Leave blank to use the built-in AI, billed via the per-event pricing.

## `llmBaseUrl` (type: `string`):

OpenAI-compatible base URL. Default https://api.deepseek.com . Groq: https://api.groq.com/openai/v1

## `summaryModel` (type: `string`):

Model id for per-video summaries. Default deepseek-v4-flash.

## `reportModel` (type: `string`):

Model id for the channel report. Default deepseek-v4-flash; step up to deepseek-v4-pro for richer synthesis.

## Actor input object example

```json
{
  "channelUrls": [
    "https://www.youtube.com/@anthropic-ai"
  ],
  "maxVideos": 10,
  "includeSummaries": true,
  "includeChannelReport": true,
  "llmBaseUrl": "https://api.deepseek.com",
  "summaryModel": "deepseek-v4-flash",
  "reportModel": "deepseek-v4-flash"
}
```

# 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 = {
    "channelUrls": [
        "https://www.youtube.com/@anthropic-ai"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("mindgamelabs/youtube-channel-intelligence").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 = { "channelUrls": ["https://www.youtube.com/@anthropic-ai"] }

# Run the Actor and wait for it to finish
run = client.actor("mindgamelabs/youtube-channel-intelligence").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "channelUrls": [
    "https://www.youtube.com/@anthropic-ai"
  ]
}' |
apify call mindgamelabs/youtube-channel-intelligence --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=mindgamelabs/youtube-channel-intelligence",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "YouTube Channel Intelligence & Transcript Analyzer",
        "description": "Other YouTube tools dump raw transcripts. This one hands you the strategy: point it at any channel and get a cross-video intelligence report - topics, hook patterns, what top videos share, content gaps. Transcripts + AI summaries included. Unofficial; not affiliated with YouTube.",
        "version": "0.1",
        "x-build-id": "VksrveSydu6qKo4j4"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/mindgamelabs~youtube-channel-intelligence/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-mindgamelabs-youtube-channel-intelligence",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/mindgamelabs~youtube-channel-intelligence/runs": {
            "post": {
                "operationId": "runs-sync-mindgamelabs-youtube-channel-intelligence",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/mindgamelabs~youtube-channel-intelligence/run-sync": {
            "post": {
                "operationId": "run-sync-mindgamelabs-youtube-channel-intelligence",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "channelUrls"
                ],
                "properties": {
                    "channelUrls": {
                        "title": "YouTube channel URLs",
                        "minItems": 1,
                        "type": "array",
                        "description": "REQUIRED. One or more YouTube channel URLs, e.g. https://www.youtube.com/@channelname . The actor fetches recent public videos, extracts their transcripts, optionally summarizes each, and writes one cross-video intelligence report per channel.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxVideos": {
                        "title": "Videos per channel",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "How many recent videos to analyze per channel. Higher gives a deeper report but costs more. Default 10.",
                        "default": 10
                    },
                    "includeSummaries": {
                        "title": "Generate per-video AI summaries",
                        "type": "boolean",
                        "description": "Add a concise AI summary to each video row. Adds one video-summarized charge per successfully summarized video.",
                        "default": true
                    },
                    "includeChannelReport": {
                        "title": "Generate cross-video channel report",
                        "type": "boolean",
                        "description": "Synthesize one strategy report per channel: topic clusters, title and hook patterns, upload cadence, what the top videos share, and content gaps. Adds one channel-report-generated charge per channel.",
                        "default": true
                    },
                    "llmApiKey": {
                        "title": "Your LLM API key (optional)",
                        "type": "string",
                        "description": "Optional. Bring your own OpenAI-compatible API key (DeepSeek by default) to run the AI at cost. Leave blank to use the built-in AI, billed via the per-event pricing."
                    },
                    "llmBaseUrl": {
                        "title": "LLM base URL (advanced)",
                        "type": "string",
                        "description": "OpenAI-compatible base URL. Default https://api.deepseek.com . Groq: https://api.groq.com/openai/v1",
                        "default": "https://api.deepseek.com"
                    },
                    "summaryModel": {
                        "title": "Summary model (advanced)",
                        "type": "string",
                        "description": "Model id for per-video summaries. Default deepseek-v4-flash.",
                        "default": "deepseek-v4-flash"
                    },
                    "reportModel": {
                        "title": "Report model (advanced)",
                        "type": "string",
                        "description": "Model id for the channel report. Default deepseek-v4-flash; step up to deepseek-v4-pro for richer synthesis.",
                        "default": "deepseek-v4-flash"
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
