# Multi Video Topic Synthesizer (`mrdoe/multi-video-topic-synthesizer`) Actor

Reads several YouTube videos on the same subject and returns one cross-video report: where they agree, where they contradict each other, a consolidated summary, timestamped citable quotes, and a ready-to-edit blog draft.

- **URL**: https://apify.com/mrdoe/multi-video-topic-synthesizer.md
- **Developed by:** [MrDoe](https://apify.com/mrdoe) (community)
- **Categories:**
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.20 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

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

## How to integrate an Actor?

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

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

![Multi-Video Topic Synthesizer — compare several YouTube videos on one topic](https://api.apify.com/v2/key-value-stores/kE36venAoVchGsE6b/records/multi-video-topic-synthesizer--website.png)

### What does Multi-Video Topic Synthesizer do?

Multi-Video Topic Synthesizer reads 2-10 YouTube videos that cover the same subject and returns one cross-video report instead of ten separate summaries: a consolidated summary written across all the videos together, the specific points where the videos agree, the points where they contradict or frame things differently, a set of timestamped citable quotes pulled from different videos, and a ready-to-edit blog post draft. You give it a list of video URLs; it gives you one structured comparison you can read in minutes instead of watching every video end to end.

It's built for content researchers, students comparing explainers on the same concept, journalists cross-checking multiple takes on a story, and content teams drafting a blog post that references several sources.

### Why use Multi-Video Topic Synthesizer?

- **Cross-video comparison, not single-video summaries** - the report is written by reading all the videos together, so agreement and disagreement points are genuine comparisons, not independent recaps stitched together.
- **Citable, timestamped quotes** - notable quotes carry the source video and an approximate timestamp, so you can jump straight to the moment and cite it properly.
- **Full transcripts included** - every video's complete transcript and metadata (title, channel, duration, publish date, view count) travels with the report for your own research.
- **Ready-to-edit blog draft** - a 300-500 word synthesis draft you can paste straight into an editor and adjust.
- **Clean, structured output** - one row per run with consistent field names, ready for CSV, JSON, or an API call.
- **No account or login needed** - works fully logged out.

### What makes this different

Most YouTube tools on the market either scrape a raw transcript or summarize one video at a time - useful, but you still have to read every summary yourself and work out where the sources agree or disagree. This Actor does that comparison step for you: one synthesis pass reads every supplied video's transcript together and reports the actual overlap and the actual disagreements, with citations back to the specific video. If two or three videos genuinely say the same thing, you get a confirmed agreement point; if they don't, you get an honest empty result rather than an invented conflict.

### How it works

![How Multi-Video Topic Synthesizer works: your videos, a collection and comparison engine, one synthesis report](https://api.apify.com/v2/key-value-stores/kE36venAoVchGsE6b/records/multi-video-topic-synthesizer--how-it-works.png)

1. **Your input** - a list of 2-10 YouTube video URLs on the same topic, and an optional short label describing what they're being compared on.
2. **The Actor collects it** - it reads every video's metadata and transcript in parallel, works without login, and handles rate limits and retries for you.
3. **Your output** - one report: a consolidated summary, agreement points, contradiction points, citable quotes, and a blog post draft, plus every video's full transcript and metadata.

### What data can you extract?

| Field                   | Description                                                                          |
| ------------------------ | ------------------------------------------------------------------------------------ |
| `topic`                  | The comparison label you supplied, or `null` if left blank.                          |
| `videoCount`             | Number of videos successfully read.                                                  |
| `transcribedVideoCount`  | Number of those videos with a usable transcript.                                     |
| `videos`                 | Per-video metadata and full transcript: id, url, title, channel, publish date, duration, view count, thumbnail, transcript language/status, transcript text. |
| `consolidatedSummary`    | 4-8 sentence summary written across all the videos together.                         |
| `agreementPoints`        | List of `{ point, videoIds }` - claims multiple videos support, with which videos support them. |
| `contradictionPoints`    | List of `{ point, positions: [{ videoId, position }] }` - where the videos differ.   |
| `citableQuotes`          | List of `{ videoId, quote, approxOffsetSeconds, timestamp }` - verbatim, timestamped. |
| `blogPostDraft`          | A ready-to-edit blog post synthesising the videos.                                   |
| `synthesisConfidence`    | `high`, `medium`, or `low` confidence in the synthesis.                              |
| `enrichmentStatus`       | Whether the synthesis was produced, and if not, why.                                 |
| `scrapedAt`              | ISO timestamp of the run.                                                            |

### How to use Multi-Video Topic Synthesizer

1. Open the Actor in the Apify Console.
2. In **YouTube videos to compare**, paste 2-10 video URLs that cover the same subject.
3. Optionally set a **Topic / comparison context** label and a **Preferred transcript language**.
4. Press **Start**.
5. When the run finishes, open the **Dataset** tab and export to JSON, CSV, or Excel, or connect it to your workflow.

![Multi-Video Topic Synthesizer input form with three video URLs and a topic label](https://api.apify.com/v2/key-value-stores/kE36venAoVchGsE6b/records/multi-video-topic-synthesizer--input.png)

### Input Parameters

| Parameter            | Type            | Required | Default              | Description                                                                                        |
| --------------------- | --------------- | -------- | --------------------- | --------------------------------------------------------------------------------------------------- |
| `videoUrls`           | array           | Yes      | 3 example videos      | 2-10 entries: a watch URL, youtu.be link, Shorts link, or bare video ID, one per video to compare.  |
| `topic`               | string          | No       | —                      | A short label for what the videos are being compared on. Used only to focus the report - it does not search for videos. |
| `language`            | string          | No       | `en`                   | Two-letter transcript language code. Falls back to each video's default track if unavailable.      |
| `openRouterApiKey`    | string (secret) | No       | —                      | Optional key for the service that writes the synthesis report. Without it, transcripts and metadata are still returned and the report fields are left empty. |
| `proxyConfiguration`  | object          | Yes      | Apify residential      | Proxy settings. A residential proxy is required; the default uses Apify's residential proxy.       |

### Output Data

One dataset item per run, covering every video supplied. Real sample record (transcripts trimmed for length):

```json
{
    "topic": "How neural networks work",
    "videoCount": 3,
    "transcribedVideoCount": 3,
    "videos": [
        {
            "videoId": "aircAruvnKk",
            "url": "https://www.youtube.com/watch?v=aircAruvnKk",
            "title": "But what is a neural network? | Deep learning chapter 1",
            "channel": "3Blue1Brown",
            "durationSeconds": 1120,
            "transcriptStatus": "ok",
            "transcript": "..."
        },
        {
            "videoId": "CqOfi41LfDw",
            "title": "The Essential Main Ideas of Neural Networks",
            "channel": "StatQuest with Josh Starmer",
            "transcriptStatus": "ok",
            "transcript": "..."
        },
        {
            "videoId": "jmmW0F0biz0",
            "title": "Neural Networks Explained in 5 minutes",
            "channel": "IBM Technology",
            "transcriptStatus": "ok",
            "transcript": "..."
        }
    ],
    "consolidatedSummary": "Neural networks are computational models inspired by the human brain, designed to recognize patterns and solve complex problems. They consist of interconnected nodes or 'neurons' organized into layers: input, hidden, and output...",
    "agreementPoints": [
        {
            "point": "Neural networks are composed of interconnected nodes or 'neurons' organized into layers.",
            "videoIds": ["CqOfi41LfDw", "jmmW0F0biz0", "aircAruvnKk"]
        }
    ],
    "contradictionPoints": null,
    "citableQuotes": [
        {
            "videoId": "aircAruvnKk",
            "quote": "The way the network operates, activations in one layer determine the activations of the next layer.",
            "approxOffsetSeconds": 4,
            "timestamp": "0:04"
        }
    ],
    "blogPostDraft": "Neural networks, inspired by the human brain, are powerful tools in machine learning and artificial intelligence...",
    "synthesisConfidence": "high",
    "enrichmentStatus": "ok",
    "scrapedAt": "2026-09-04T21:40:00.000Z"
}
```

![Multi-Video Topic Synthesizer report exported as a dataset table](https://api.apify.com/v2/key-value-stores/kE36venAoVchGsE6b/records/multi-video-topic-synthesizer--export.png)

### Usage Examples

- **Compare explainers on the same concept** - three "how X works" videos from different channels to see where they agree before you cite one in a write-up.
- **Cross-check a news story** - several channels' coverage of the same event, to spot which claims are corroborated and which are only made once.
- **Draft a roundup post** - feed in the source videos for a "best explanations of X" post and use the blog draft as your starting point.
- **Research prep** - pull the full transcripts of every candidate video before deciding which one to reference in depth.

![Multi-Video Topic Synthesizer one real comparison report record](https://api.apify.com/v2/key-value-stores/kE36venAoVchGsE6b/records/multi-video-topic-synthesizer--output.png)

### Tips for Best Results

- Pick videos that genuinely cover the same subject - the comparison quality depends on real topical overlap, not just similar titles.
- Use the **Topic** field to tell the report what angle to focus the comparison on when the videos cover a broad subject from different angles.
- Keep the language code consistent with the videos' available captions for the cleanest transcripts.
- Start with 3-5 videos for a fast, easy-to-read report; use the full 10-video range for deeper research digests.

### Known Limitations

- Requires an explicit list of video URLs or IDs - it does not search YouTube for videos on a topic. If you don't already have candidate videos, find them on YouTube first, then paste the links in.
- A video with no captions in any language is included in the report with `transcriptStatus` explaining why, but is excluded from the synthesis.
- The synthesis report reflects the default free-tier analysis model; quality varies with transcript length and topical overlap between the videos supplied.
- Runs with the full 10-video range take longer and, under heavy demand on the free-tier analysis service, the synthesis step can occasionally be skipped (raw transcripts and metadata are still returned in full, with `enrichmentStatus` explaining why).
- `agreementPoints` and `contradictionPoints` are only populated when the videos actually overlap on a claim - unrelated videos correctly return an empty list rather than a fabricated comparison.
- Very long videos are read up to a large transcript budget per video; extremely long transcripts are excerpted for the synthesis step while the full transcript is still returned in `videos`.

### Integrations

Connect the dataset to Zapier, Make, Google Sheets, or your own pipeline via the Apify API and webhooks. Schedule recurring runs from the Apify Console to keep a research log of new videos as they're published.

### Export Formats

Download results as JSON, CSV, Excel, or XML from the Dataset tab, or fetch them programmatically via the Apify API.

### Frequently Asked Questions

#### How many videos can I compare at once?

Between 2 and 10 videos per run. The default example run compares 3.

#### Can I compare videos in a language other than English?

Yes - set the preferred transcript language and each video uses that caption track when available, falling back to its default track otherwise.

#### Does it search YouTube for videos on a topic?

No. You supply the video URLs or IDs directly; the Actor does not run a keyword search.

#### Why are some report fields empty?

`contradictionPoints` is empty when the supplied videos don't actually disagree on anything - that's a real result, not a missing one. Report fields are also left empty if the analysis key isn't supplied or the analysis service is temporarily unavailable; the full transcripts and metadata are always returned regardless.

#### Are duplicate videos handled?

Yes - the same video supplied twice (by URL, short link, or ID) is only read once.

#### Can I schedule recurring runs?

Yes, using Apify's built-in Scheduler on the Actor Task.

#### Do I need a YouTube account or login?

No. The Actor reads publicly available video pages and captions and does not require any account.

#### Am I charged for failed results?

No - you're only charged for a report that was actually produced.

### Support

Use the Issues tab on the Actor's Apify Console page to report a problem or request a feature.

### Legal / Responsible Use

You are responsible for complying with YouTube's terms of service, applicable law, and responsible data-use requirements when using this Actor's output.

# Actor input Schema

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

2-10 entries, one per video, all on the same subject. Paste a YouTube video URL, a youtu.be link, a Shorts link, or a bare 11-character video ID. The report compares these videos against each other, so pick videos that actually cover the same topic.

## `topic` (type: `string`):

Optional. A short label for what these videos are being compared on, e.g. "neural networks explained". Used only to focus the report - it does not search for videos.

## `language` (type: `string`):

Two-letter language code for the transcripts, for example "en", "es", "de". If a video doesn't have that language, its default caption track is used instead.

## `openRouterApiKey` (type: `string`):

Optional. A key for the service that writes the cross-video report. Without it, the Actor still returns every video's full transcript and metadata and leaves the comparison fields empty. Stored securely and never shown in output or logs.

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

A residential proxy is required - video data is not served to datacenter traffic. The default uses Apify's residential proxy.

## Actor input object example

```json
{
  "videoUrls": [
    {
      "url": "https://www.youtube.com/watch?v=aircAruvnKk"
    },
    {
      "url": "https://www.youtube.com/watch?v=CqOfi41LfDw"
    },
    {
      "url": "https://www.youtube.com/watch?v=jmmW0F0biz0"
    }
  ],
  "topic": "How neural networks work",
  "language": "en",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

## `reports` (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": [
        {
            "url": "https://www.youtube.com/watch?v=aircAruvnKk"
        },
        {
            "url": "https://www.youtube.com/watch?v=CqOfi41LfDw"
        },
        {
            "url": "https://www.youtube.com/watch?v=jmmW0F0biz0"
        }
    ],
    "topic": "How neural networks work",
    "language": "en",
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("mrdoe/multi-video-topic-synthesizer").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": [
        { "url": "https://www.youtube.com/watch?v=aircAruvnKk" },
        { "url": "https://www.youtube.com/watch?v=CqOfi41LfDw" },
        { "url": "https://www.youtube.com/watch?v=jmmW0F0biz0" },
    ],
    "topic": "How neural networks work",
    "language": "en",
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("mrdoe/multi-video-topic-synthesizer").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": [
    {
      "url": "https://www.youtube.com/watch?v=aircAruvnKk"
    },
    {
      "url": "https://www.youtube.com/watch?v=CqOfi41LfDw"
    },
    {
      "url": "https://www.youtube.com/watch?v=jmmW0F0biz0"
    }
  ],
  "topic": "How neural networks work",
  "language": "en",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call mrdoe/multi-video-topic-synthesizer --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,mrdoe/multi-video-topic-synthesizer"
        }
    }
}

```

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/KkDbU4TdlcIoGxLaG/builds/mShLHkhORKCOTgV5o/openapi.json
