# Video Intelligence Analyzer — AI Transcripts & Analysis (`khadinakbar/video-intelligence-analyzer`) Actor

Turn YouTube, TikTok and Instagram speech into transcripts, source-linked summaries, chapters, claims, actions and answers. For research and content briefs. Speech analysis only; pay per delivered video plus usage. Failed analysis preserves an unbilled transcript.

- **URL**: https://apify.com/khadinakbar/video-intelligence-analyzer.md
- **Developed by:** [Khadin Akbar](https://apify.com/khadinakbar) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $120.00 / 1,000 analyzed videos

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

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## How to integrate an Actor?

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

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

### Video Intelligence Analyzer

For researchers, educators and creative strategists, turn video speech into one evidence-linked record per video: original transcript, summary, claims, actions and question answers.

**Private cloud candidate under validation.** Source parsing, schema validation and failure/billing behavior have offline test coverage. Live source retrieval, AI quality and final release acceptance are being evaluated. This Actor remains private.

### What does Video Intelligence Analyzer do?

Turn YouTube, TikTok and Instagram speech into a consistent research record: the original transcript, a source-linked summary, takeaways, chapter suggestions, claims, actions, entities, question answers and suggested content copy. Each factual finding includes exact source excerpts and segment references. Source timestamps appear only when the transcript provides them.

This is speech-content analysis. It does not examine video frames, identify people by voice, fact-check external claims, or measure retention and engagement. A generated content brief is explicitly labeled as a suggestion.

### Best fit

- Researchers comparing what speakers actually said across public videos.
- Educators turning captioned lessons into structured notes and follow-up questions.
- Creative strategists examining spoken hooks, audience cues and calls to action.
- AI agents that need source-grounded question answers with machine-readable evidence.

For a transcript-only extraction job, select `mode: "transcript"`. For an existing transcript, supply it directly to skip source fetching. All processing focuses expose the same fields and cost controls.

### Source coverage

| Source | Transcript route | Practical boundary |
|---|---|---|
| YouTube videos and Shorts | Public caption tracks | No audio transcription when YouTube captions are unavailable |
| TikTok | Native captions, then short AI fallback | AI fallback is limited to 120 seconds; longer native captions may work |
| Instagram reel or video post | Short AI speech transcription | Up to 120 seconds per video; carousel video clocks remain independent |
| Supplied transcript | Caller text, SRT/VTT text, or timed segments | No source lookup; timing stays unknown when not supplied |

Paid long transcription is disabled. Private, login-gated, deleted, speechless or otherwise unavailable videos may return no transcript or a provider failure. Profiles, playlists and shortened TikTok URLs are not accepted. Expand TikTok share links to the full `@creator/video/ID` URL first. Availability and model quality still require real cloud validation.

### Example workflow

An analyst starts with three public explainer videos and asks, “What next steps does the speaker recommend?” The output keeps each video's original transcript, gives answers only when the speech supports them, and attaches source passages. Instagram carousel videos remain separate records so their timestamps are meaningful. The analyst can review the quoted passages before using the findings in a brief.

### Quick start input

```json
{
  "videoUrls": ["https://www.youtube.com/watch?v=bjVIDXPP7Uk"],
  "mode": "analyze",
  "focus": "research",
  "questions": ["What actions does the speaker recommend?"],
  "outputLanguage": "English",
  "maxVideos": 1,
  "maxProviderCostUsd": 0.03
}
```

This URL is a source example, not a verified live-run receipt. `maxVideos` counts delivered underlying videos, including individual Instagram carousel members. One run accepts up to 20 combined URLs and supplied transcripts. Duplicate canonical source URLs are processed once.

An offline transcript-only example needs no upstream credentials:

```json
{
  "mode": "transcript",
  "transcripts": [{
    "id": "launch-meeting",
    "title": "Launch meeting",
    "segments": [{
      "text": "We will ship on Friday.",
      "startSeconds": 0,
      "endSeconds": 3
    }]
  }]
}
```

These are synthetic example words. Use `text` instead of `segments` for plain text, SRT or WEBVTT. Each timed segment requires `text`, `startSeconds` and `endSeconds`; set both times to `null` when unknown. Do not provide contradictory text and segments.

### Inputs

| Field | Default and bounds | Effect |
|---|---|---|
| `videoUrls` | Optional; up to 20 combined inputs | Full public HTTPS video links |
| `transcripts` | Optional; up to 20 combined inputs | `{id, text}` or `{id, segments}` with optional title/sourceUrl |
| `mode` | `analyze` or `transcript` | Includes AI analysis, or extracts speech only |
| `focus` | `general`, `research`, `marketing`, `education` | Emphasizes the relevant spoken-content findings |
| `questions` | Up to 5; 300 characters each | Answers with evidence or `notInTranscript: true` |
| `outputLanguage` | `English`; up to 50 characters | Generated analysis language; original transcript and quotes remain unchanged |
| `transcriptLanguage` | Optional language code | Requests a source caption language on supported YouTube/TikTok routes; not translation |
| `maxVideos` | 10; range 1–20 | Stops before delivering additional underlying videos |
| `maxProviderCostUsd` | $0.10; range $0.001–$1 | Bounds estimated provider spend with persistent reservations |

Every transcript is bounded to 60,000 UTF-8 text bytes and 2,000 segments. Analysis additionally requires its complete serialized prompt to fit a 110,000-byte envelope. The Actor does not silently truncate long transcripts. Split oversized supplied transcripts into separate jobs. If the transcript is usable but analysis fails, its result is preserved with `status: "analysis_failed"` and no result event charge.

### What data do you receive?

One dataset item represents one underlying video or supplied transcript. Useful fields include:

- `transcript.text`, `transcript.segments`, `transcript.timing`: complete bounded original speech and available timestamps.
- `analysis.summary`, `takeaways`, `claims`, `actionItems`, `entities`: generated findings with exact quotes and source segment references.
- `analysis.chapters`: chapter titles anchored to real source segments; start times are null when unavailable.
- `analysis.creative`: supported spoken hook, audience and call to action; absent information stays null.
- `analysis.answers`: your questions, evidence-backed answers or an explicit unknown.
- `analysis.contentBrief`: suggested title, description and keywords, marked `generatedSuggestion: true`.
- `analysis.coverage`: segment counts and `truncated: false` for accepted analyses.
- `provenance`: transcript provider, model, fetch time, source language and timing availability.
- `exports`: run-storage record keys for the Markdown report and available SRT/VTT subtitles.

Illustrative finding shape, using synthetic speech:

```json
{
  "text": "A Friday launch is planned.",
  "quote": "ship on Friday",
  "evidence": [{"segmentId": 0, "startSeconds": 0, "endSeconds": 3}]
}
```

Quotes are copied directly from selected original source segments after the referenced segment IDs are validated; quotes are not generated by the model. It does not independently prove every generated interpretation. Claims have `externallyVerified: false`; review passages before relying on them. AI source timing can be approximate phrase timing rather than exact word timing.

`OUTPUT` and `RUN_SUMMARY` record the terminal outcome, counts, diagnostics, named events and estimated provider spending. Outcomes distinguish `COMPLETE`, `PARTIAL`, `VALID_EMPTY`, `INVALID_INPUT`, `UPSTREAM_FAILED` and `CONFIG_ERROR`. A provider outage with no useful data fails honestly. A genuine successful lookup with no available transcript is `VALID_EMPTY`.

### Reports and exports

Use Apify Dataset export for JSON, CSV, Excel or other dataset formats. Nested analysis is best preserved in JSON. Download individual reports from the default key-value store using the keys in each row's `exports` object. SRT and VTT are available only when every source segment has actual timing; the Actor does not fabricate subtitle timing.

### API usage after private deployment

This example becomes executable after the private Actor is created and configured. Replace the placeholder token through your environment; do not paste credentials into input or source control.

```bash
curl --fail-with-body \
  --request POST \
  --header "Authorization: Bearer $APIFY_TOKEN" \
  --header 'Content-Type: application/json' \
  --data '{"videoUrls":["https://www.youtube.com/watch?v=bjVIDXPP7Uk"],"maxVideos":1}' \
  'https://api.apify.com/v2/acts/khadinakbar~video-intelligence-analyzer/run-sync-get-dataset-items?timeout=240&maxTotalChargeUsd=0.15'
```

For larger batches, start an asynchronous run, retain the run ID, and read its default dataset after checking `OUTPUT` and `RUN_SUMMARY`. A synchronous timeout does not imply that a run stopped: inspect that same run before submitting a replacement.

### Use with AI agents

Suggested prompt:

> Analyze these video URLs with a maximum of three delivered videos. Answer “Which specific next steps are recommended?” Return each answer with the source URL, exact excerpt, segment ID and available timestamp. Read the terminal outcome and preserve transcript-only partial results. Treat claims as speaker claims, not verified facts.

The structured inputs and outputs are designed for agent use. Hosted Apify MCP discovery, permissions and actual client execution remain untested for this local candidate. Follow the [current Apify MCP documentation](https://docs.apify.com/integrations/mcp) after private deployment; no standalone MCP server or connected-app write action is included.

### Pricing and spending controls

The proposed model is Pay per event plus user-paid Apify platform usage. Candidate rates are **$0.12 per analyzed video**, **$0.02 per transcript-only video**, and **$0.00005 automatic startup**, subject to measured cloud economics. These are configured for private validation; check the live Actor Pricing tab for the effective record. No tier discounts or customer total-cost claim is established.

The analyzed-video event includes its transcript, questions and brief; there is no additional transcript charge for that result. Transcript-only events apply only when that mode was explicitly selected. Each delivered Instagram carousel video is a distinct billing unit. No result event is charged for empty speech, invalid input, failed extraction or a preserved transcript whose analysis failed. Platform usage and the proposed automatic startup event can still cost money on those paths.

`maxProviderCostUsd` bounds estimated upstream work using published-rate reservations. It is not an Apify event cap or an invoice guarantee. Apify's Maximum cost per run limits event charges; platform usage is separate. Uncertain requests retain their reservation. No paid automatic retry or paid long-transcription fallback is enabled. Interrupted delivery is reconciled against dataset records and named charges; unresolved effects stop instead of being blindly repeated.

### Best results and troubleshooting

Use clear speech, existing public captions for YouTube and short speech-bearing TikTok/Instagram clips. Keep questions specific and compare the quoted passages. Missing source timing remains null. A requested caption language with no matching track can produce no transcript. If a source has no speech/captions, provide your own authorized transcript. For source-size limits, split a supplied transcript. A configuration failure requires fixing owner-managed settings before retrying; an ambiguous checkpoint requires inspecting saved delivery and charge evidence first.

### Builder’s note

Instagram carousel videos can each start at time zero. Combining them into a single timeline would attach misleading timestamps to findings, so this implementation keeps separate identities and clocks. The same reasoning applies to untimed text: a real excerpt is more useful than an invented timestamp.

### Connect the workflow

For dedicated caption collection, start with the public [YouTube Transcript and Subtitle Data Scraper](https://apify.com/khadinakbar/youtube-transcript-extractor), [TikTok Transcript Scraper](https://apify.com/khadinakbar/tiktok-transcript-scraper) or [Instagram Transcript Scraper](https://apify.com/khadinakbar/instagram-transcript-scraper). To analyze an existing transcript here, map its speech into `transcripts[].text`, or map timed cues into `transcripts[].segments`. Keep original source URLs for provenance. This Actor also fetches transcripts itself when you begin with video URLs.

### Local setup and responsible use

Run `npm ci`, then `npm test`. Put local test input in `storage/key_value_stores/default/INPUT.json` and run `npm start`. Remote transcript fetching uses owner-managed `SCRAPECREATORS_API_KEY`; analysis also uses `OPENAI_API_KEY`. Keep these in environment secrets. They are never accepted from ordinary input or included in dataset records, outputs or application logs.

Process public or authorized content in accordance with applicable source/provider terms. Transcripts can contain personal information; control access to run storage and set retention appropriate to your use. This independent Actor is not affiliated with YouTube, TikTok or Instagram. Cloud acceptance, human source/data-use review and the user's publication decision remain separate steps.

# Actor input Schema

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

Paste full YouTube, TikTok @creator/video/ID, or Instagram reel/post HTTPS URLs. Up to 20 combined inputs. Expand shortened TikTok share links first. Profiles and playlists are unsupported. YouTube needs public captions; short AI transcription on TikTok/Instagram is limited to 120 seconds.

## `mode` (type: `string`):

Choose analyze for a full transcript plus source-linked findings and question answers. Choose transcript to skip AI analysis. One corresponding result event per delivered video; failed analysis preserves an unbilled transcript.

## `questions` (type: `array`):

Ask up to 5 questions, each up to 300 characters. Answers cite exact transcript excerpts and segment IDs. Questions unsupported by speech return notInTranscript: true. These questions do not trigger web research.

## `focus` (type: `string`):

Select which spoken-content findings to emphasize. All focuses return the same output shape. Marketing analysis uses speech evidence and does not measure retention, engagement or visual creative performance.

## `outputLanguage` (type: `string`):

Name the language for generated analysis, such as English, Arabic or Urdu. Original transcript and evidence quotes remain in the source language. This setting does not translate captions or generate translated subtitles.

## `transcriptLanguage` (type: `string`):

Optional caption language code, for example en, es or en-US. Applied to supported YouTube/TikTok source routes. Omit to let the provider choose. Unavailable language tracks can return no transcript; this is not an automatic translation request.

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

Deliver up to this many underlying videos, 1–20. Instagram carousel videos count separately and retain independent clocks. A cap stop is PARTIAL; no later analysis is dispatched. At most 20 combined URLs and supplied transcripts are accepted.

## `maxProviderCostUsd` (type: `number`):

Bound estimated upstream spend within this run ($0.001–$1). Reservations use published prices and include uncertain requests. This is separate from Apify event charges and platform usage, not a whole-run customer invoice cap. Set the run's Maximum cost per run to limit event spending.

## `transcripts` (type: `array`):

Optional array of {id, text} or {id, segments:\[{text,startSeconds,endSeconds}]}; title and sourceUrl are optional. Provide both times as null when unknown. IDs use letters, numbers, underscores and hyphens. Max 60,000 UTF-8 text bytes and 2,000 ordered segments per video; no silent truncation. Supplied speech skips source fetching.

## Actor input object example

```json
{
  "videoUrls": [
    "https://www.youtube.com/watch?v=bjVIDXPP7Uk"
  ],
  "mode": "analyze",
  "focus": "general",
  "outputLanguage": "English",
  "maxVideos": 10,
  "maxProviderCostUsd": 0.1
}
```

# Actor output Schema

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

No description

## `output` (type: `string`):

No description

## `runSummary` (type: `string`):

No description

# 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 = {
    "videoUrls": [
        "https://www.youtube.com/watch?v=bjVIDXPP7Uk"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("khadinakbar/video-intelligence-analyzer").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 = { "videoUrls": ["https://www.youtube.com/watch?v=bjVIDXPP7Uk"] }

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

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,khadinakbar/video-intelligence-analyzer"
        }
    }
}
```

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/3fenpeaOyO8D67mPq/builds/QSYRCRVCi4qwUpDW5/openapi.json