# YouTube Comments Pain Point & Buyer Intent Finder (`herazur/youtube-comments-pain-point-buyer-intent-finder`) Actor

Turn YouTube video, channel and keyword comments into complaints, questions, feature requests, competitor mentions and purchase signals. Export evidence-backed opportunity rankings for product research.

- **URL**: https://apify.com/herazur/youtube-comments-pain-point-buyer-intent-finder.md
- **Developed by:** [Furkan Toluç](https://apify.com/herazur) (community)
- **Categories:** Social media
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$250.00 / 1,000 analysis reports

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 Comments Pain Point & Buyer Intent Finder

Turn public YouTube comments into a structured product-research report. Start with competitor videos, channels or search keywords and analyze **up to 10,000 comments per run**. Find complaints, questions, feature requests, competitor mentions, purchase intent, alternative requests and product problems, with original quotes and source links.

Built for Amazon sellers, SaaS founders, marketing agencies, product managers and YouTubers researching what an audience needs.

### Quick start

1. Enter YouTube video/channel URLs or search keywords.
2. Set the global comment and video limits. Start with 100 comments and one video to preview the output.
3. Optionally enter competitor names for brand matching.
4. Run the Actor. Download the dataset as JSON, CSV or Excel, or open the **Opportunity report (JSON)** output.

```json
{
  "keywords": ["wireless headphones review"],
  "maxVideos": 3,
  "maxComments": 1000,
  "competitors": ["Sony", "Bose", "Apple"],
  "maxUpstreamCostUsd": 5
}
```

Video URLs and keyword searches can be combined. Direct video URLs are prioritized, followed by channel discovery and keyword discovery. Comments are collected in video order, so the first video can fill the entire limit. This is not a balanced sample across channels. Collection stops at the global limit or source budget. Disabled comments, limited access and low-volume videos can return fewer comments.

### What you get

The default dataset contains three row types (`recordType`):

| Type | Contents |
| --- | --- |
| `summary` | Actual analyzed count, category totals, duplicates removed, source run IDs, warnings and limitations |
| `opportunity` | Theme, suggested improvement, comment count, score, category breakdown and up to five original quotes |
| `comment` | Original text, video and available comment links, likes, multiple signal labels and themes |

The `REPORT` key-value-store record provides the summary and ranked opportunities without individual comment rows. Set `includeComments` to false for a compact dataset. Category and theme counts overlap: one comment may be a question, an alternative request, and a pricing signal at the same time.

### Seven signal categories

| Signal | Example |
| --- | --- |
| Complaints | “This is too expensive.” |
| Questions | “Does this work with Android?” |
| Feature requests | “Please add offline support.” |
| Competitor mentions | “I prefer Notion.” — when Notion is supplied |
| Purchase intent | “Where can I buy this?” |
| Alternative requests | “Is there a cheaper alternative?” |
| Product problems | “Battery dies too quickly.” |

### Analysis method and scores

This version uses transparent **English and Turkish rules**, not an LLM. It does not require an AI API key. Nine predefined themes cover battery/charging, price, compatibility, reliability, speed, usability, support, quality and privacy. Other signals are grouped for manual review. Competitor mentions require user-supplied names; the Actor does not infer brands automatically.

The **Pain Point Score (0–100)** is a research prioritization heuristic:

`40 × theme share of all analyzed comments + 30 × complaint share within theme + 20 × buying/alternative share within theme + 10 × min(1, log10(1 + theme comment count) / 3)`

Scores use actual counts, are rounded to integers, and are not a purchase probability or proof of market demand. Example quotes are selected by likes. Suggested opportunities are fixed recommendations for each theme, not generated market forecasts. Sarcasm, complex negation, context and unsupported languages can lead to false positives or missed signals. Inspect the quotes before making decisions.

Deduplication uses comment ID when available, otherwise normalized text within a video. Equal text with different IDs is retained because distinct commenters can express the same need. YouTube ranking and source availability affect the sample; results do not represent all customers.

### Pricing and permissions

This Actor charges **$0.25 per completed analysis report**, covering up to 10,000 comments. The report is saved before its charge event. No report event is charged when collection or analysis fails before the report is produced.

**Live collection has additional costs.** It calls [YouTube Scraper](https://apify.com/streamers/youtube-scraper) for channel/keyword discovery and [YouTube Comments Scraper](https://apify.com/streamers/youtube-comments-scraper) for comments. Those Actors charge your Apify account separately at their current rates, plus applicable platform usage. `maxUpstreamCostUsd` defaults to $5 for source runs; it is separate from this Actor's fee. This is a source-spending guard, not a guarantee of collecting 10,000 comments for $5. Check source pricing before large runs.

The Actor requires full Actor permissions to start source runs and read their datasets. It uses the runtime's Apify token; never put your token in the input. Imported comments skip source Actors and their fees. No YouTube or AI API key is required.

This Actor's own platform usage is included in the report fee. Discovery runs are individually capped at $0.50 within your source budget. If a source's billing has not settled, its budget is reserved conservatively and `upstreamCostUsd` is `null`; the source run's Billing tab shows final charges. This may stop collection early. Account concurrency limits are retried for up to five minutes.

### Import your existing comments

Clear the prefilled source URL before using import mode. Do not combine imports and live sources.

```json
{
  "comments": [
    {"id":"example-1","text":"Battery dies too quickly.","likes":12},
    {"id":"example-2","text":"Is there a cheaper alternative?","likes":4},
    {"id":"example-3","text":"Does this work with Android?","likes":2}
  ],
  "maxComments": 10000
}
```

These are illustrative comments, not measured research. Imported objects accept `text` (or `comment`/`commentText`), optional `id`, `videoUrl`, `commentUrl`, `likes` and `publishedAt`.

### Troubleshooting

- **No comments collected:** check that comments are enabled, try another video, and inspect linked source runs. Empty live results fail explicitly.
- **Fewer comments than requested:** increase source budget or videos; requested limits are maxima, not promised counts.
- **Permission or source payment error:** grant the documented Actor permissions and ensure your account can run both paid source Actors.
- **Few detected signals:** the audience may not discuss product issues, or comments may use unsupported languages or wording. Unclassified comments remain in the export.

Only public comments are collected. The Actor omits commenter profile fields from its output. Use the data responsibly and comply with applicable platform terms. For bugs, open an issue on this Actor with a run ID and a non-sensitive sample.

# Actor input Schema

## `startUrls` (type: `array`):

Video, Shorts, live video, or channel URLs. Provide URLs and/or keywords. Leave empty when importing comments.

## `keywords` (type: `array`):

Discover videos for product names, competitor brands, or niche keywords.

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

Global collection/analysis limit across all videos, up to 10,000. Actual count depends on accessible comments and budget.

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

Global video discovery limit. Videos are processed in order until the comment limit is reached.

## `competitors` (type: `array`):

Exact brand/product names, e.g. Notion, Evernote, Samsung. Case insensitive, whole-name matching. No names are assumed.

## `sortCommentsBy` (type: `string`):

Top comments for established concerns, newest first for recent feedback.

## `maxUpstreamCostUsd` (type: `number`):

Total budget passed to paid discovery/comment source runs. Separate from this Actor's report fee and platform usage. A small budget can return fewer comments. Source prices are controlled by their publishers.

## `includeComments` (type: `boolean`):

Include individual comment rows alongside summary and opportunity rows in the dataset.

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

Alternative to live collection: an array of objects with text and optional id, videoUrl, commentUrl, likes. Leave YouTube URLs and keywords empty. Max 10,000 comments.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.youtube.com/watch?v=xObhZ0Ga7EQ"
    }
  ],
  "maxComments": 1000,
  "maxVideos": 10,
  "sortCommentsBy": "TOP_COMMENTS",
  "maxUpstreamCostUsd": 5,
  "includeComments": true
}
```

# Actor output Schema

## `report` (type: `string`):

No description

## `results` (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 = {
    "startUrls": [
        {
            "url": "https://www.youtube.com/watch?v=xObhZ0Ga7EQ"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("herazur/youtube-comments-pain-point-buyer-intent-finder").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 = { "startUrls": [{ "url": "https://www.youtube.com/watch?v=xObhZ0Ga7EQ" }] }

# Run the Actor and wait for it to finish
run = client.actor("herazur/youtube-comments-pain-point-buyer-intent-finder").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 '{
  "startUrls": [
    {
      "url": "https://www.youtube.com/watch?v=xObhZ0Ga7EQ"
    }
  ]
}' |
apify call herazur/youtube-comments-pain-point-buyer-intent-finder --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,herazur/youtube-comments-pain-point-buyer-intent-finder"
        }
    }
}

```

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/y3eGDs61k98KhPAqa/builds/CQTebsEVChyJ9I9ij/openapi.json