# XavvyNess AI Video Analyst (`xavvyness/xavvyness-video-intel`) Actor

Extract insights from any YouTube video without watching it. Transcript + AI analysis: summary, key moments, top quotes, chapter breakdown, and sentiment. Works on videos with English captions. No YouTube API key required. upport email: hello@xavvyness.ai

- **URL**: https://apify.com/xavvyness/xavvyness-video-intel.md
- **Developed by:** [XavvyNess](https://apify.com/xavvyness) (community)
- **Categories:** AI, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $10.00 / 1,000 ai-analyzed videos

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.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/platform/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

## 🎬 XavvyNess Video Intel — YouTube Transcript + AI Analysis

Extract full transcripts from any public YouTube video **and** get an AI-generated analysis — summary, key moments, top quotes, actionable insights, and chapter breakdown. No API key required for transcripts. Powered by Groq/Gemini free tier.

> **Beats YouTube Transcript Ninja on analysis depth.** Ninja gives you raw text. We give you a structured intelligence report.

---

### 🚀 What It Does

1. Fetches the full transcript from any public YouTube video (free, no YouTube API key needed)
2. Runs AI analysis to extract what actually matters
3. Returns clean structured JSON you can pipe into any workflow

**Perfect for:** content repurposing, competitive research, lecture notes, podcast summaries, SEO content, AI training data

---

### 📥 Input

| Field | Required | Default | Description |
|---|---|---|---|
| `urls` | ✅ | — | YouTube video URLs (one or more) |
| `depth` | — | `standard` | `quick` / `standard` / `deep` |
| `includeFullTranscript` | — | `false` | Include raw transcript text in output |

**Example input:**
```json
{
  "urls": ["https://www.youtube.com/watch?v=dQw4w9WgXcQ"],
  "depth": "standard",
  "includeFullTranscript": false
}
````

***

### 📤 Output

Output schema (from a live run — fields fully populated for videos with captions):

```json
{
  "url": "https://www.youtube.com/watch?v=JhCl-GeT4jw",
  "videoId": "JhCl-GeT4jw",
  "title": "Sam Altman: OpenAI, GPT-5, Sora, Board Saga, Elon Musk, Ilya, Power & AGI",
  "channelName": "Lex Fridman",
  "duration": "3:03:24",
  "views": "4,200,000",
  "transcriptAvailable": true,
  "transcriptLength": 48000,
  "summary": "Sam Altman discusses OpenAI's trajectory toward AGI, the board crisis and what it revealed about governance, the relationship with Elon Musk, Ilya Sutskever's departure, and his personal philosophy on power and safety. He argues AGI is closer than most think and defends OpenAI's for-profit restructuring.",
  "keyMoments": [
    "Board crisis: what actually happened and why it escalated",
    "GPT-5 capabilities Sam hints at but won't confirm",
    "AGI definition debate — Sam's surprisingly specific answer",
    "Reflections on Ilya Sutskever's role and departure"
  ],
  "topQuotes": [
    "I think we may be closer to AGI than most people think.",
    "The board situation was the most painful thing I've experienced professionally.",
    "Safety and capability are not in opposition — they reinforce each other."
  ],
  "actionableInsights": [
    "OpenAI is prioritizing AGI safety research alongside commercial products",
    "GPT-5 likely includes significant improvements in reasoning and coding",
    "Enterprise adoption will accelerate with better API reliability"
  ],
  "sentiment": "positive",
  "topicTags": ["AI", "AGI", "OpenAI", "leadership", "safety", "GPT-5"],
  "analyzedAt": "2026-04-08T22:26:23.933Z",
  "agent": "XavvyNess Video Intel"
}
```

> **Note:** For videos without English captions enabled, `transcriptAvailable` will be `false` and analysis fields will reflect that limitation. Works best with English-language videos that have auto-generated or manual captions.

***

### 💡 Analysis Depths

| Depth | Output | Best For |
|---|---|---|
| `quick` | Summary + 2 quotes | Fast content scanning |
| `standard` | Summary + key moments + quotes + sentiment + tags | General purpose |
| `deep` | Everything + chapter breakdown + actionable insights + audience type | Content strategy, research |

***

### ⚙️ Setup — API Keys

Add these to **Actor environment variables** (Apify Console → Actor → Environment):

| Variable | Required | Where to Get |
|---|---|---|
| `GROQ_API_KEY` | Recommended (free) | [console.groq.com](https://console.groq.com) |
| `GOOGLE_API_KEY` | Optional fallback | [aistudio.google.com](https://aistudio.google.com) |

> Transcripts are extracted without any API key. AI analysis requires at least one key.

***

### ❓ FAQ

**Q: What if a video has no captions?**\
A: You'll get `"noTranscript": true` with a clear reason — e.g. "Creator has disabled captions" or "Auto-generated captions not yet available". No silent failures.

**Q: Does it work after YouTube updates its page structure?**\
A: Yes. We use 3 rotating user agents and multiple caption URL extraction patterns. If one breaks, others catch it.

**Q: Can I process a whole channel?**\
A: Pass multiple URLs in the `urls` array. For channel-level scraping, pair with a YouTube Channel Scraper to get URLs first.

**Q: What about private or age-restricted videos?**\
A: These are detected and reported clearly in the output (`noTranscriptReason`). The actor never silently returns empty.

***

### 🔗 Use Cases

1. **Content repurposing** — Turn any YouTube video into a blog post, Twitter thread, or newsletter
2. **Competitor research** — Analyze what your competitors are saying in their video content
3. **Lecture notes** — Extract key points from educational videos automatically
4. **Podcast summaries** — Process podcast uploads for show notes and SEO content
5. **AI training data** — Build structured labeled datasets from video transcripts
6. **Due diligence** — Analyze earnings calls, conference talks, and product demos

***

### 📊 Performance

- ✅ Transcripts: ~2-5s per video
- ✅ AI analysis: ~5-10s per video (Groq) / ~8-15s (Gemini fallback)
- ✅ Resilient to YouTube page structure changes
- ✅ Clear error messages — never silent failures
- ✅ **Failed runs are not charged** — you only pay for successfully analyzed videos

***

### Integration

#### Via Apify JavaScript client

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

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

const run = await client.actor('8mAPNoFCgp7Ths6JM').call({
  urls: [
    'https://www.youtube.com/watch?v=dQw4w9WgXcQ',
    'https://www.youtube.com/watch?v=aircAruvnKk',
  ],
  depth: 'standard',
  includeFullTranscript: false,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach(video => {
  console.log(video.title);              // Video title
  console.log(video.summary);           // AI-generated summary
  console.log(video.keyMoments);        // Key moments array
  console.log(video.actionableInsights); // Action items
});
```

#### Via HTTP API

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/8mAPNoFCgp7Ths6JM/runs?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "urls": ["https://www.youtube.com/watch?v=dQw4w9WgXcQ"],
    "depth": "standard"
  }'
```

#### Via Make.com / Zapier

Use the **Apify** module → **Run Actor** action. Actor ID: `8mAPNoFCgp7Ths6JM`. Pass your YouTube URLs in the input JSON, then map `{{summary}}`, `{{keyMoments}}`, and `{{topQuotes}}` to your next automation step.

***

*Built by XavvyNess — AI agent services that do real work.*

# Actor input Schema

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

YouTube video URLs to transcribe and analyze.

## `depth` (type: `string`):

How deeply to analyze each video transcript.

## `includeFullTranscript` (type: `boolean`):

Include the complete raw transcript in the output.

## Actor input object example

```json
{
  "urls": [
    "https://www.youtube.com/watch?v=dQw4w9WgXcQ"
  ],
  "depth": "standard",
  "includeFullTranscript": false
}
```

# 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"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("xavvyness/xavvyness-video-intel").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"] }

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "XavvyNess AI Video Analyst",
        "description": "Extract insights from any YouTube video without watching it. Transcript + AI analysis: summary, key moments, top quotes, chapter breakdown, and sentiment. Works on videos with English captions. No YouTube API key required. upport email: hello@xavvyness.ai",
        "version": "1.0",
        "x-build-id": "DjTzOZ4gmhuBBGiiP"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/xavvyness~xavvyness-video-intel/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-xavvyness-xavvyness-video-intel",
                "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/xavvyness~xavvyness-video-intel/runs": {
            "post": {
                "operationId": "runs-sync-xavvyness-xavvyness-video-intel",
                "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/xavvyness~xavvyness-video-intel/run-sync": {
            "post": {
                "operationId": "run-sync-xavvyness-xavvyness-video-intel",
                "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": [
                    "urls"
                ],
                "properties": {
                    "urls": {
                        "title": "YouTube Video URLs",
                        "type": "array",
                        "description": "YouTube video URLs to transcribe and analyze.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "depth": {
                        "title": "Analysis Depth",
                        "enum": [
                            "quick",
                            "standard",
                            "deep"
                        ],
                        "type": "string",
                        "description": "How deeply to analyze each video transcript.",
                        "default": "standard"
                    },
                    "includeFullTranscript": {
                        "title": "Include Full Transcript",
                        "type": "boolean",
                        "description": "Include the complete raw transcript in the output.",
                        "default": false
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```