# YouTube Question Backlog & FAQ Brief (`symmetrical_omelet_yit/youtube-question-backlog`) Actor

Turn imported YouTube comments into a ranked question queue and recurring FAQ topics, with exact source evidence and creator-reply coverage. Import JSON or an existing Apify dataset. Export a readable HTML brief, CSV and JSON.

- **URL**: https://apify.com/symmetrical_omelet_yit/youtube-question-backlog.md
- **Developed by:** [Yigit Ibze](https://apify.com/symmetrical_omelet_yit) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

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

## 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

## YouTube Question Backlog & FAQ Brief

**Find the questions your audience keeps asking—and prepare your next useful answer.**

Turn an existing YouTube comment export into a ranked reply queue and a readable FAQ brief. See recurring question topics, the original wording, source links when available, and whether a creator reply was observed in the supplied snapshot.

Built for creators, community managers, product marketers and agencies working with product tutorials, reviews and launch videos.

### Try the sample

Leave **Explore the sample FAQ brief** on and click **Start**. The synthetic sample needs no key, login or collection step. Open **Open the FAQ brief** in the run outputs, or download the CSV reply queue.

For your own comments, turn the sample off and choose **one** source:

1. Select an existing Apify comment dataset in the input picker; or
2. Paste a JSON array of comment objects.

This version analyzes supplied comments. It does not scrape video URLs or collect live YouTube comments. Use your own export or collect comments with your preferred tool first. No AI API key is required.

### What you get

| Output | Purpose |
|---|---|
| HTML FAQ brief | Ranked topic cards, exact question evidence, response-coverage badges and the full reply queue |
| CSV reply queue | Questions, topics, likes, source links and observed creator-reply status |
| JSON report | Counts, grouped evidence, import statistics, method and warnings |
| Default dataset | One row per detected question candidate, ready for a workflow or spreadsheet |

The brief suggests topics to cover. It does not invent answers or send replies.

### Comment format

Minimum input:

```json
{
  "comments": [
    {"id":"example-1","text":"Does this work with Android?","likes":12},
    {"id":"example-2","text":"Does this also work with Android?","likes":4},
    {"id":"example-3","text":"How much is the monthly plan?","likes":3}
  ]
}
```

These are synthetic examples. For clickable source links, include a valid `videoId` (11 characters) and the original comment `id`. Source links are generated from those IDs; arbitrary supplied URLs are not copied into reports.

Common aliases are accepted: `text` / `comment` / `commentText` / `question`, `id` / `cid` / `commentId`, `likes` / `likeCount` / `voteCount`, plus `videoId` or a recognized YouTube `videoUrl`. YouTube Data API thread objects containing `snippet.topLevelComment` are also accepted. Clearly marked flattened reply rows (`type: "reply"`, `replyToCid` or `parentId`) are excluded and counted; they are not automatically joined to parents. Supply nested replies for coverage analysis. Exports with unsupported fields should be mapped to the documented format first.

You can re-import a question queue exported by this Actor. Its old computed reply status is not treated as source evidence: without original reply records and creator IDs, the new run correctly reports unknown coverage.

### Creator replies and coverage

Optionally supply the creator's stable `creatorChannelIds` (24-character IDs starting `UC`, not handles). Add `authorChannelId` to comments and replies. Supply replies as objects in `replies`, with `replyCount` / `totalReplyCount` and `repliesComplete` where known.

- **Creator reply observed:** a supplied reply has an exact matching creator channel ID. This does not mean the question was answered well or fully.
- **No creator reply observed:** creator IDs are known and supplied reply records meet the tool's completeness checks. This describes the supplied snapshot only.
- **Reply coverage unknown:** creator identity, reply authors or reply completeness cannot be established. Missing replies are never treated as proof of an unanswered question.

For example, `replyCount: 0` supplies a snapshot with no replies. A valid supplied reply array matching the declared count, or `repliesComplete: true` with valid reply records and no declared count, can establish supplied-record completeness. `repliesComplete: false` always means incomplete. Records with missing reply authors, duplicates or inconsistent counts stay conservative. These are validations of your source's claims, not an independent check against YouTube.

YouTube's thread response can omit some replies; do not label a partial export complete. See the [official thread documentation](https://developers.google.com/youtube/data/reference/rest/v3/commentThreads).

### How ranking and grouping work

The tool uses transparent English question patterns and conservative token overlap, without an LLM. It assigns Compatibility, Pricing, Setup, Availability, Features or Other topics. Similar wording may be grouped into an editorial topic; this is a heuristic, not a guarantee that questions have identical intent.

Questions with complete supplied coverage and no observed creator reply are prioritized. Unknown coverage remains visible. Repetition and likes help order the queue; likes are not buying intent or proof of demand. Check the original evidence before making a content decision. Sarcasm, rhetorical questions, context, paraphrases and unsupported languages can produce misses or false positives.

### Limits, privacy and permissions

Up to **1,000 supplied comments** and **8 MiB** per import. Each comment text is bounded at 10,000 characters; replies at 500 per thread and 10,000 total. Dataset imports take a bounded insertion-order sample and report truncation. Counts apply to usable imported comments, never the entire audience.

The Actor uses **Limited permissions**. The selected source dataset grants **READ** only; it is never modified. It does not call collection Actors, request your personal Apify token, or contact social platforms. Reports retain supplied public question text and source IDs, while omitting author names, handles, profile images and unrelated extra fields. Review comment text before sharing reports; text itself may contain personal information. Manage storage retention in your Apify account.

### Pricing

**Free beta: no developer fee.** Apify platform usage and storage costs apply. Any separate tool you use to collect comments has its own pricing. There is no hidden AI or collection fee in this Actor.

### Troubleshooting

- **No usable comments:** check that objects contain a supported text field, and are viewer comments rather than creator-authored comments.
- **No questions found:** a valid outcome; inspect the supplied sample and English-language scope.
- **Unknown reply coverage:** add exact creator channel IDs and complete reply records if your source provides them. Do not guess completeness.
- **Dataset access failed:** select the dataset using the input picker, which grants the required READ permission.
- **Interrupted delivery:** the saved report remains available. The Actor does not blindly replay an ambiguous dataset push; check the delivery state before reusing the run.

# Actor input Schema

## `demoMode` (type: `boolean`):

Fixed synthetic examples of recurring questions and different reply-coverage states. Turn off before supplying your own source. No network collection or API key.

## `sourceDatasetId` (type: `string`):

Optional existing Apify dataset containing YouTube comment objects. Reads at most maxComments records in insertion order. Use this OR pasted comments; leave blank for the sample. Read-only access is requested only for the selected dataset.

## `comments` (type: `array`):

Array of comment objects. Minimum: text. Recommended: id, videoId, likes, authorChannelId, replyCount, replies and repliesComplete. Common comment/commentText/question and cid/commentId aliases and YouTube API thread objects are accepted. See README examples. No URL scraping is performed.

## `creatorChannelIds` (type: `array`):

Stable YouTube channel IDs beginning UC (24 characters), not handles or channel URLs. Up to 20. For multiple channels, use only the creator IDs relevant to your imported videos.

## `reportName` (type: `string`):

Shown at the top of your exported brief, for example October product questions.

## `minGroupSize` (type: `integer`):

Mark a conservatively grouped topic as recurring at this count. All question candidates remain in the reply queue. English rules and token overlap can miss or misgroup questions; review the evidence.

## `maxComments` (type: `integer`):

Dataset sample cap, up to 1,000 records and 8 MiB. A pasted array larger than this limit is rejected. Dataset samples use insertion order and may not represent the full audience.

## Actor input object example

```json
{
  "demoMode": true,
  "comments": [],
  "creatorChannelIds": [],
  "reportName": "YouTube question backlog",
  "minGroupSize": 2,
  "maxComments": 1000
}
```

# Actor output Schema

## `questions` (type: `string`):

No description

## `reportHtml` (type: `string`):

No description

## `reportJson` (type: `string`):

No description

## `questionsCsv` (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 = {
    "demoMode": true
};

// Run the Actor and wait for it to finish
const run = await client.actor("symmetrical_omelet_yit/youtube-question-backlog").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 = { "demoMode": True }

# Run the Actor and wait for it to finish
run = client.actor("symmetrical_omelet_yit/youtube-question-backlog").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 '{
  "demoMode": true
}' |
apify call symmetrical_omelet_yit/youtube-question-backlog --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,symmetrical_omelet_yit/youtube-question-backlog"
        }
    }
}
```

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/aPO8LVL2GqYYgX0vh/builds/aRZWBFs828tezhGUQ/openapi.json