# YouTube Comment Analyzer & Audience Intelligence (`signalforge_labs/my-actor-1`) Actor

Analyze YouTube comments for sentiment, themes, audience questions, objections, content requests, competitor mentions, evidence, and prioritized actions. No external AI key required.

- **URL**: https://apify.com/signalforge\_labs/my-actor-1.md
- **Developed by:** [SignalForge Labs](https://apify.com/signalforge_labs) (community)
- **Categories:**
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 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.

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

Turn public YouTube comments into a decision-ready audience report in minutes. Add one or more video URLs and get **sentiment, recurring themes, unanswered questions, objections, content requests, competitor mentions, evidence quotes, and prioritized next actions**—without reading thousands of comments or supplying an external AI key.

Use the results to decide what to publish next, improve an offer, compare campaign reactions, or brief a client with evidence instead of guesswork.

### What is YouTube Audience Intelligence?

YouTube Audience Intelligence is a YouTube comment analyzer for creators, agencies, product marketers, course businesses, researchers, and brands. It combines comment collection with structured audience analysis and produces outputs that both people and automations can use.

#### What you get

- An executive summary of the audience response
- Positive, neutral, and negative sentiment counts and rates
- Recurring themes ranked by number of mentions
- Pain points and purchase or usage objections
- Frequently asked audience questions
- Content, product, and feature requests
- Mentions of competitors, creators, products, or alternatives you choose to track
- Representative source comments for every major finding
- Prioritized actions ranked by estimated impact
- Structured dataset rows plus JSON, Markdown, and standalone HTML reports

No model key or separate OpenAI account is required. Runs can be scheduled, called through the Apify API, or connected to other Apify integrations.

### How to analyze YouTube comments

1. Open the **Input** tab and add one or more public YouTube video URLs.
2. Choose **Top comments** or **Newest first**, set a comment limit, and optionally add competitor or alternative names.
3. Click **Start**. When the run finishes, open **Output** to inspect the dataset or download `REPORT.html`, `REPORT.md`, or `OUTPUT` as JSON.

For a quick first test, use one public video and request 100 comments. Add several videos when you want to compare reactions across campaigns, creators, launches, or competitors.

### YouTube comment analyzer input

```json
{
  "sourceType": "youtube",
  "sourceUrls": [
    { "url": "https://www.youtube.com/watch?v=VIDEO_ID" }
  ],
  "sourceMaxItems": 100,
  "sourceSort": "top",
  "competitorNames": ["Brand A", "Creator B"],
  "maxItems": 5000,
  "evidencePerTheme": 3,
  "outputLanguage": "en"
}
```

| Field | What it controls |
|---|---|
| `sourceUrls` | One or more public YouTube video URLs |
| `sourceMaxItems` | Maximum comments requested for each video |
| `sourceSort` | Top comments or newest comments first |
| `competitorNames` | Optional names to detect in comment text |
| `maxItems` | Hard limit on comments included in the analysis |
| `evidencePerTheme` | Representative quotes retained for each theme |
| `outputLanguage` | Recommendation text in English or Simplified Chinese |

### What YouTube audience data does it return?

The first dataset item is the aggregate summary. The remaining items are normalized comments with sentiment, detected themes, questions, objections, and competitor mentions. A shortened summary item looks like this:

```json
{
  "recordType": "summary",
  "summary": {
    "totalReviews": 842,
    "positive": 503,
    "neutral": 211,
    "negative": 128,
    "positiveRate": 0.5974,
    "negativeRate": 0.152
  },
  "themes": [
    {
      "theme": "pricing",
      "mentions": 146,
      "share": 0.1734,
      "netSentiment": -0.31,
      "evidence": [{ "quote": "Is there a lower-priced plan?" }]
    }
  ],
  "questions": [
    { "topic": "pricing", "mentions": 37 }
  ],
  "objections": [
    { "topic": "pricing", "mentions": 24 }
  ],
  "priorityActions": [
    {
      "rank": 1,
      "action": "Revisit pricing and communicate package value",
      "relatedTheme": "pricing"
    }
  ]
}
```

The example above illustrates the schema; values depend on the comments collected in your run.

### Practical use cases

- **Creators:** find repeated questions and turn them into future videos, chapters, FAQs, or community posts.
- **Agencies:** generate an evidence-backed audience brief across several client or competitor videos.
- **Product teams:** surface feature requests, objections, pain points, and alternative products mentioned by viewers.
- **Marketers:** identify messages audiences repeat in their own words and compare reactions across campaigns.
- **Researchers:** export normalized comments and aggregate findings to JSON for downstream analysis.

### How much does it cost to analyze YouTube comments?

This Actor uses pay-per-result pricing: **$0.00005 per Actor start plus $1.00 per 1,000 output dataset items**. A run normally produces one summary item plus one item per analyzed comment.

Comment collection is performed by `streamers/youtube-comments-scraper` in your Apify account. That source Actor's charge is separate and is shown by Apify before and after the run. Your final cost therefore depends on the requested comment count and the source Actor's current pricing. Start with 100 comments to validate the output before scaling up.

### Accuracy, privacy, and limitations

- Only comments available to the public source Actor can be collected; private, disabled, removed, or inaccessible comments are not available.
- Sentiment, themes, questions, and objections are detected with deterministic language rules. They are fast and reproducible, but sarcasm, slang, mixed languages, and highly specialized terminology can require human review.
- Evidence quotes and source URLs are included so important conclusions can be checked against the original comments.
- Do not use the output for high-stakes decisions about individuals. Follow YouTube's terms, Apify's terms, and applicable privacy and data-protection laws.

### FAQ

#### Do I need a YouTube API key or an AI API key?

No. You only need an Apify account. The source Actor handles public comment collection, and this Actor performs the analysis.

#### Can I analyze several videos in one run?

Yes. Add multiple public video URLs to compare or combine audience reactions. Use `maxItems` to cap the total number analyzed.

#### Can I export the report?

Yes. Use the structured dataset or download JSON, Markdown, and standalone HTML reports. You can also call the Actor through the Apify API or schedule recurring runs.

#### Why did my run return fewer comments than requested?

The video may have fewer accessible comments, comments may be disabled, or the source Actor may not be able to access every thread. Check the run log and reduce the scope to one known-public video when troubleshooting.

### More audience and review intelligence tools

- [Review Intelligence Analyzer](https://apify.com/signalforge_labs/review-intelligence-analyzer) for pasted reviews, existing datasets, Google Maps reviews, and YouTube comments in one workflow.
- [Google Maps Review Intelligence](https://apify.com/signalforge_labs/my-actor) for local-business reputation, pain points, and service improvement opportunities.

# Actor input Schema

## `sourceType` (type: `string`):

Collect public comments from the supplied YouTube video URLs.

## `sourceUrls` (type: `array`):

Add one or more public YouTube video URLs.

## `sourceMaxItems` (type: `integer`):

Limit how many comments the source Actor requests for each video URL.

## `sourceSort` (type: `string`):

Choose whether to collect top comments or newest comments first.

## `competitorNames` (type: `array`):

Optional competitor, creator, product, or alternative names to track in comments.

## `maxItems` (type: `integer`):

Hard limit on the number of collected comments included in the analysis.

## `evidencePerTheme` (type: `integer`):

Number of representative comment quotes retained for each detected theme.

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

Language used for report labels and recommended actions.

## Actor input object example

```json
{
  "sourceType": "youtube",
  "sourceUrls": [],
  "sourceMaxItems": 100,
  "sourceSort": "top",
  "competitorNames": [],
  "maxItems": 5000,
  "evidencePerTheme": 3,
  "outputLanguage": "en"
}
```

# Actor output Schema

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

A summary record followed by normalized, sentiment-labeled review records.

## `htmlReport` (type: `string`):

A browser-ready executive report with themes, evidence, pain points, and recommended actions.

## `markdownReport` (type: `string`):

A portable report for Notion, documentation, email, or AI workflows.

## `jsonReport` (type: `string`):

The complete structured intelligence report for API integrations.

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("signalforge_labs/my-actor-1").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 = {}

# Run the Actor and wait for it to finish
run = client.actor("signalforge_labs/my-actor-1").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 '{}' |
apify call signalforge_labs/my-actor-1 --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,signalforge_labs/my-actor-1"
        }
    }
}

```

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/boWPWGEr24AC8CTtc/builds/1dUYb43fuwYxzOnx7/openapi.json