MCP: YouTube Intelligence (Apify Actor)

TL;DR for AI agent builders for content analytics, AI / LLM apps, and brand-monitoring workflows: Exposes YouTube Intelligence as a Model Context Protocol server with discoverable tools (video metadata, channel data, comments, transcripts) and compact agent-ready JSON responses. Compared to generic platform MCPs from the Anthropic catalog, this is a vertical-data MCP returning enriched YouTube payloads (video plus channel plus comments plus transcript in one envelope) instead of forcing your agent to chain four API calls. Flat low PPE per tool call on this wrapper, plus upstream actor PPE charges pass through. Free Apify plan covers exploration on your $5 platform credit.

Run it in 30 seconds

# Via the Apify Python SDK
from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")
run = client.actor("seibs.co/mcp-youtube-intelligence").call(run_input={
    "tool": "get_video_intelligence",
    "args": {
        "video_urls": [
            "https://www.youtube.com/watch?v=dQw4w9WgXcQ"
        ],
        "tier": "standard"
    }
})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

Or via curl:

curl -X POST "https://api.apify.com/v2/acts/seibs.co~mcp-youtube-intelligence/run-sync-get-dataset-items?token=<YOUR_APIFY_TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{"tool": "get_video_intelligence", "args": {"video_urls": ["https://www.youtube.com/watch?v=dQw4w9WgXcQ"], "tier": "standard"}}'

Or click "Try for free" on this page if you prefer the no-code UI.

What you get

Each run produces:

• A clean dataset, filterable in the Apify console and downloadable as CSV or JSON
• An OUTPUT.html dashboard preview of your top records
• A sample-output preview at ./.actor/sample-output.json

Per-archetype custom artifacts shipped with this actor:

• Agent-ready JSON envelope ({ tool, args, ok, count, items, summary, error })
• Compact item payloads (nulls dropped, raw HTML dropped)
• Stable tool catalog discoverable via list_tools

---

Why this exists

youtube-intelligence is powerful but is a batch-scraper at heart - one big input schema, one big dataset. Agents want small, semantically named tools with narrow contracts. This actor is the adapter:

• One tool per run. Pass {tool: "fetch_transcript", args: {video_url: "..."}} and get back exactly the shape that tool promises.
• AI-friendly output. Boolean ok, named data payload, named error, optional count. No deep-nested scraper artifacts to map around.
• Cheap to invoke. Flat $0.003 per tool call on top of the pass-through cost of the underlying scraper run. Predictable line items for agent platforms.

Available tools

Call with tool: "list_tools" (free, no charge) to get the live manifest with JSON Schema input definitions.

Tool	Purpose	Required args
fetch_transcript	Full transcript text + timestamped segments	video_url
fetch_metadata	Title, channel, views, likes, chapters, hashtags, thumbnails	video_url
bulk_transcripts	Batched transcripts (up to 50 videos)	video_urls
search_channel	Recent videos from a channel by ID, @handle, or URL	channel_id_or_handle
find_sponsored_segments	Detect ad-read windows in the transcript with {start, end, confidence}	video_url

All tools accept either a full YouTube URL or a bare 11-char video ID.

Input

{
  "tool": "fetch_transcript",
  "args": {
    "video_url": "https://www.youtube.com/watch?v=dQw4w9WgXcQ",
    "lang": "en"
  }
}

Output (pushed to the default dataset)

{
  "ok": true,
  "tool": "fetch_transcript",
  "data": {
    "video_url": "https://www.youtube.com/watch?v=dQw4w9WgXcQ",
    "video_id": "dQw4w9WgXcQ",
    "title": "Rick Astley - Never Gonna Give You Up",
    "channel": "Rick Astley",
    "language": "en",
    "is_generated": false,
    "segment_count": 87,
    "duration_seconds": 213.0,
    "text": "We're no strangers to love ...",
    "segments": [{"start": 0.0, "duration": 4.2, "text": "We're no strangers to love"}]
  }
}

On error: {"ok": false, "tool": "...", "error": "...", "args": {...}}.

Pricing

• $0.003 per MCP tool call (this actor).
• Pass-through for the underlying youtube-intelligence run (its own pay-per-event pricing: $0.002 metadata, $0.005 enriched, $0.009 premium, plus optional comments / channel-data add-ons).

list_tools is free.

Integration snippets

Claude (Anthropic SDK, tool use)

import anthropic, json
from apify_client import ApifyClient

apify = ApifyClient(token="apify_api_...")
client = anthropic.Anthropic()

def call_yt_tool(name: str, args: dict) -> dict:
    run = apify.actor("Seibs.Co/mcp-youtube-intelligence").call(
        run_input={"tool": name, "args": args}
    )
    items = list(apify.dataset(run["defaultDatasetId"]).iterate_items())
    return items[0] if items else {"ok": False, "error": "no items"}

tools = [{
    "name": "fetch_transcript",
    "description": "Fetch full transcript for a YouTube video.",
    "input_schema": {
        "type": "object",
        "properties": {"video_url": {"type": "string"}, "lang": {"type": "string"}},
        "required": ["video_url"],
    },
}]

msg = client.messages.create(
    model="claude-opus-4-7",
    max_tokens=1024,
    tools=tools,
    messages=[{"role": "user", "content": "Summarize https://youtu.be/dQw4w9WgXcQ"}],
)
# When msg.stop_reason == "tool_use", dispatch via call_yt_tool(...) and feed the result back.

LangChain

from langchain.tools import StructuredTool
from pydantic import BaseModel, Field
from apify_client import ApifyClient

apify = ApifyClient(token="apify_api_...")
ACTOR_ID = "Seibs.Co/mcp-youtube-intelligence"

def _call(tool: str, args: dict) -> dict:
    run = apify.actor(ACTOR_ID).call(run_input={"tool": tool, "args": args})
    items = list(apify.dataset(run["defaultDatasetId"]).iterate_items())
    return items[0] if items else {}

class TranscriptArgs(BaseModel):
    video_url: str = Field(..., description="YouTube URL or 11-char video ID")
    lang: str = Field("en", description="ISO 639-1 transcript language")

fetch_transcript = StructuredTool.from_function(
    name="fetch_transcript",
    description="Fetch full transcript for a YouTube video.",
    args_schema=TranscriptArgs,
    func=lambda video_url, lang="en": _call("fetch_transcript", {"video_url": video_url, "lang": lang}),
)
# Add fetch_transcript to your agent's tools list.

LlamaIndex

from llama_index.core.tools import FunctionTool
from apify_client import ApifyClient

apify = ApifyClient(token="apify_api_...")

def fetch_metadata(video_url: str) -> dict:
    """Fetch YouTube video metadata (title, channel, views, likes, chapters)."""
    run = apify.actor("Seibs.Co/mcp-youtube-intelligence").call(
        run_input={"tool": "fetch_metadata", "args": {"video_url": video_url}}
    )
    return next(apify.dataset(run["defaultDatasetId"]).iterate_items(), {})

yt_tool = FunctionTool.from_defaults(fn=fetch_metadata)
# Pass yt_tool into AgentRunner / FunctionAgent / ReActAgent.

Lindy (no-code agent)

1. Add a new Action -> "Apify - Run Actor".
2. Actor: Seibs.Co/mcp-youtube-intelligence.
3. Input (JSON): {"tool": "find_sponsored_segments", "args": {"video_url": "{{video_url}}"}}.
4. Bind the dataset's first record to subsequent steps - use data.sponsored_segments for the ad-read windows.

n8n / Make

Use the Apify node, point it at this actor, and set Run Input to the same {tool, args} shape. Both platforms can read the default dataset directly from the run.

Design notes

• Single-tool dispatch pattern mirrors how MCP servers expose tools/list + tools/call, but compresses both into the Apify run lifecycle so existing platform integrations work without custom MCP transport.
• list_tools is the discovery surface. Free, deterministic, returns valid JSON Schema for every tool. Use it to dynamically register tools in your agent at startup.
• All output is flat-shaped. Agents can JSON.parse the dataset record and read data.title, data.segments, etc. without unwrapping scraper internals.
• find_sponsored_segments is a heuristic (regex over transcript text + 60s decay window). It is fast, free of third-party deps, and tuned on common ad-read cadence. Expect false positives on creator-read promos; tune downstream with confidence threshold (0.5 base, +0.1 per additional trigger).

Roadmap (deferred)

• Real MCP transport (stdio + SSE) via usesStandbyMode for clients that speak MCP natively.
• summarize_video tool that pipes transcript -> an LLM and returns a structured summary.
• find_chapters_with_transcript that fuses chapter metadata with their transcript spans.
• Sponsorship detection v2 using the SponsorBlock community dataset as a ground-truth overlay.

Save your input as an Apify Task

Apify Tasks let you save a configured input once and re-run it with a single click - no need to re-type search terms, locations, filters, or tier settings every time. Tasks are the foundation for everything that comes next: schedules, monitor mode, and webhook routing all attach to a saved Task, not to the raw actor.

Steps to save your current input as a Task:

1. On this actor's Apify Store page, click Run with your input fully configured.
2. Click the Save as task button at the top of the run page.
3. Name the task something memorable (e.g. Saved YouTube query for agent - on-demand).
4. Reload the task page and click Start anytime to re-run with the same inputs.

Tasks unlock the next two features below: scheduling and monitor mode.

Run this weekly with Apify Schedules

Apify Schedules cron-run any saved Task automatically. Pair this with the saved Task above and you get hands-off recurring runs with no manual clicks.

Steps to schedule a Task:

1. Save your input as a Task (see above).
2. Go to https://console.apify.com/schedules and click Create new schedule.
3. Pick your Task and set the cron expression. Common patterns:
   • Daily at 9am UTC: 0 9 * * *
   • Weekly on Mondays at 9am: 0 9 * * 1
   • Monthly on the 1st: 0 9 1 * *
4. Save. Apify will run your Task on that schedule automatically, push the dataset to whatever integrations you have wired up, and fire run-completion webhooks.

Schedules are unusual for MCP wrappers because AI agents invoke them on-demand. Use Tasks for saved configs but skip the cron schedule unless you have a specific batch-run use case.

Monitor mode (v2, beta)

Monitor mode is the v2 evolution of this actor and is currently in BETA. It turns a recurring schedule into a true change-feed instead of a firehose of duplicate records.

How it works:

• When this actor runs under an Apify Schedule, monitor mode is enabled automatically.
• Instead of emitting ALL records every run, it emits ONLY records that are NEW or CHANGED since the last scheduled run.
• A digest record summarizes the delta (X new, Y changed, Z removed) at the top of every run.
• Optional: provide a Slack or email webhook URL in the monitor_webhook_url input field and the digest fires there too, so your team gets the delta in their inbox or channel without polling the dataset.
• Cost: a single scheduled_delta_run event ($0.05) per scheduled run, plus standard PPE on emitted delta records only. Predictable monthly cost, no surprise bills from re-charging for unchanged records.

Monitor mode is rolling out to the top 3 actors first (this one included if it's hotel-motel-lead-finder, google-maps-reviews-pro, or mcp-accounting-firm-leads). Full portfolio coverage by end of June.

Support

Built by Seibs.Co. Issues / requests: open a thread on the Apify Console actor page.

Found this useful?

If this actor saved you time or money, please consider leaving a quick review on the Apify Store. Reviews help other buyers find work that solves their problem and let me prioritize the features paying customers actually use. Leave a review: https://apify.com/seibs.co/mcp-youtube-intelligence#reviews