# YouTube Comment Questions & Content Requests (`ntriqpro/youtube-comment-questions`) Actor

Find public YouTube video comments that heuristically ask questions, request content, or report issues.

- **URL**: https://apify.com/ntriqpro/youtube-comment-questions.md
- **Developed by:** [daehwan kim](https://apify.com/ntriqpro) (community)
- **Categories:** Social media, Marketing
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $10.00 / 1,000 matched comment delivereds

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

## YouTube Comment Questions & Content Requests

Unofficial, non-affiliated tool for finding selected public comments on YouTube videos that heuristically look like questions, content requests, or issue reports. It uses the MIT-licensed `youtubei.js` package (`18.0.0`) and does not download video or audio.

### What it does

Provide up to 20 public YouTube video IDs or exact `youtube.com`, `www.youtube.com`, `m.youtube.com`, or `youtu.be` video URLs. The Actor normalizes them to canonical watch URLs, requests public top-level comments sequentially, and delivers one dataset row for each unique comment ID that matches the selected deterministic rules.

Invalid input is an explicit `invalid_input` outcome, not a comment-collection result. Empty, malformed, oversized, credentialed, non-HTTPS, or lookalike-host video entries end the run before any provider request, `actor-start` charge, or `question-result` charge. The Actor writes an actionable `INVALID_INPUT_NOTICE` record plus `SUMMARY` and `OUTPUT` to the key-value store; these notice records are not dataset rows and are never billed comment results. Storage, billing, and other unexpected runtime failures are not converted into this outcome and remain failed runs.

Input limits are shared by all users: `maxCommentsPerVideo` defaults to 200 and is capped at 2,000; `maxResults` defaults to 100 and is capped at 2,000. Newest-first is the default to surface recent how-to questions and troubleshooting; top comments remain available. Pagination has a bounded page count and a short continuation delay, so output is a sample of available top-level comment pages, not a promise to return all comments.

### Detection and output

`rules-v1` uses visible punctuation, English interrogative/request/issue phrases, and Korean question/request/issue patterns. It includes the `signalTypes`, rule IDs, and matched evidence terms that selected a comment. English/Korean labels are character-pattern heuristics; other and ambiguous text is `unknown`. It deliberately does not judge topicality or whether an issue is still active, so jokes and rhetorical wording can remain in results when a listed rule matches.

Every matched comment is one row even when it has several signals. Exact repeated comment IDs are de-duplicated, while different comment IDs are preserved. Each row includes a safe canonical comment URL, text, provider `likeCountText` and `replyCountText`, nullable `approximateLikes` and `replyCount` only for unambiguous English-style public counts, `publishedText`, observation time, and transparent priority reasons. Unparsed localized counts do not add a count-based priority reason.

Illustrative output only; this is not an observation from YouTube:

```json
{
  "videoId": "dQw4w9WgXcQ",
  "commentId": "illustrative-comment-id",
  "text": "Could you make a tutorial about this?",
  "signalTypes": ["question", "content_request"],
  "matchedRules": ["question-mark", "english-make-video"],
  "evidenceTerms": ["?", "make a tutorial"],
  "detectedLanguage": "en",
  "replyStatus": "not_checked",
  "detectionMethod": "rules-v1"
}
```

The Actor does not infer unanswered status, buying intent, sentiment, author identity, profile data, or a semantic meaning beyond the listed rules. Known creator-authored comments are excluded only when the provider's `author_is_channel_owner` flag is explicitly `true`; pinned, `false`, and unavailable owner flags remain eligible. The provider necessarily transmits comment metadata for this decision, but the Actor does not output or store author names, IDs, or profiles. It does not follow comment links, extract contacts, or use an LLM or external model API. Email and phone-like tokens in delivered text are redacted.

### Availability and compliance boundaries

Public comments can be disabled, unavailable, challenged, rate limited, or blocked by the provider. Those outcomes are reported only in `SUMMARY` and `OUTPUT` key-value records as `disabled`, `blocked_unknown`, or `unknown`; diagnostic records are not added to the dataset. The Actor does not log raw input URLs, credentials, or comment-linked URLs, does not use login/cookies, proof tokens, proxy rotation, anti-blocking workarounds, alternate identities, or a JavaScript interpreter.

The client injects an HTTPS-only allowlisted fetch function for exact YouTube provider hosts, disables redirects, omits credentials, and uses a timeout. It creates one fast-fail session with `retrieve_player: false`; it does not fetch or execute a player, download media, or make a second identity after refusal.

The implementation is based on the documented `Innertube.create`, `getComments`, `Comments.contents`, and `Comments.getContinuation` interfaces in `youtubei.js`. A dated 2026-09-13 smoke test verified public top-level comments and continuation for one video. This validates one observed access path at that time; it does not guarantee availability for every video or future run, and it is not customer-revenue evidence.

### Pricing

Pay-per-event pricing is `$0.01` for `actor-start` after valid input and before investigation, and `$0.01` for each charged `question-result`. No separate platform-fee events are configured. For 100 charged result rows plus the start event, a user can set a `$1.01` maximum total charge; this is an example user cap, not a platform default.

The same functionality and safety limits apply to free and paid plans. There is no free-plan-specific feature, input, or result gate. `Actor.pushData(row, 'question-result')` stores the row before the SDK charges its events; an error propagates and there is no storage-and-billing transaction guarantee. The Actor counts a PPE delivery only when the `question-result` event count increases by one. All run diagnostics remain in key-value storage.

### License notices

This Actor depends on `youtubei.js`, distributed under the MIT License. YouTube and related marks belong to their respective owners. This Actor is unofficial and is not affiliated with, endorsed by, or sponsored by YouTube or its affiliates.

# Actor input Schema

## `videos` (type: `array`):

One to 20 public YouTube video IDs or video URLs. IDs are normalized to canonical watch URLs.

## `sort` (type: `string`):

Use newest-first order to surface recent questions and troubleshooting, or choose top comments.

## `maxCommentsPerVideo` (type: `integer`):

Safety cap for top-level comments checked per video. This is a sampling limit, not a promise to inspect all comments.

## `maxResults` (type: `integer`):

Maximum selected comment rows delivered across all videos.

## `includeTypes` (type: `array`):

A comment can have more than one selected signal and is still delivered as one row.

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

Optional heuristic filter. English and Korean detection is character-pattern based; other or ambiguous comments are labeled unknown.

## Actor input object example

```json
{
  "videos": [
    "-tbSCMbJA6o"
  ],
  "sort": "newest",
  "maxCommentsPerVideo": 200,
  "maxResults": 100,
  "includeTypes": [
    "question",
    "content_request",
    "issue"
  ],
  "language": "auto"
}
```

# Actor output Schema

## `summary` (type: `string`):

No description

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

No description

## `invalidInputNotice` (type: `string`):

Written only for an expected invalid-input outcome; it is not a billed comment result row.

# 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 = {
    "videos": [
        "-tbSCMbJA6o"
    ],
    "sort": "newest",
    "maxCommentsPerVideo": 200,
    "maxResults": 100,
    "includeTypes": [
        "question",
        "content_request",
        "issue"
    ],
    "language": "auto"
};

// Run the Actor and wait for it to finish
const run = await client.actor("ntriqpro/youtube-comment-questions").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 = {
    "videos": ["-tbSCMbJA6o"],
    "sort": "newest",
    "maxCommentsPerVideo": 200,
    "maxResults": 100,
    "includeTypes": [
        "question",
        "content_request",
        "issue",
    ],
    "language": "auto",
}

# Run the Actor and wait for it to finish
run = client.actor("ntriqpro/youtube-comment-questions").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 '{
  "videos": [
    "-tbSCMbJA6o"
  ],
  "sort": "newest",
  "maxCommentsPerVideo": 200,
  "maxResults": 100,
  "includeTypes": [
    "question",
    "content_request",
    "issue"
  ],
  "language": "auto"
}' |
apify call ntriqpro/youtube-comment-questions --silent --output-dataset

```

## MCP server setup

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

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/Nj3nemFEOC5ehNjPh/builds/c0AucI4iShU9CQFqt/openapi.json