# YouTube Claude Mentions Tracker (`ianymu/youtube-claude-mentions`) Actor

Track YouTube videos mentioning Claude Code, Claude AI, claude.ai, or Anthropic Claude. Pulls metadata + transcript, surfaces the mention sentence, tags sentiment (positive/neutral/negative), and ranks results. Brand monitoring, competitor analysis, and tutorial discovery in one scheduled run.

- **URL**: https://apify.com/ianymu/youtube-claude-mentions.md
- **Developed by:** [Yanlong Mu](https://apify.com/ianymu) (community)
- **Categories:** AI, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN 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/platform/actors/running/actors-in-store#pay-per-usage

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use 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

### What does YouTube Claude Mentions do?

**YouTube Claude Mentions** is a focused scraper that finds every YouTube video talking about **Claude Code**, **Claude AI**, **claude.ai**, or **Anthropic Claude**, and ships a ranked dataset you can use for brand monitoring, competitor analysis, or sourcing tutorial creators. For each match it returns the video title, channel name, view count, publish date, the exact sentence that mentions Claude, a positive/neutral/negative sentiment label, the canonical YouTube URL, and the thumbnail URL. Source: [youtube.com](https://www.youtube.com/).

Run it once or schedule it weekly on the [Apify platform](https://apify.com/) for hands-off competitor intelligence — Apify handles proxy rotation, scheduling, API access, webhook integrations, and run monitoring out of the box.

### Why use YouTube Claude Mentions?

- **Brand & competitive intelligence** — track how the AI community talks about Claude vs ChatGPT, Gemini, Copilot, or Cursor.
- **Sentiment trendlines** — diff weekly runs to see whether buzz is turning positive or negative after a model release.
- **Find creator partners** — surface high-view channels already producing Claude tutorials so you can sponsor, collaborate, or cite them.
- **Tutorial discovery** — collect the best Claude Code walkthroughs in one dataset instead of clicking through 100 YouTube search results.
- **Sales triggers** — spot creators reviewing competitor tools that haven't yet covered Claude.

### How to use YouTube Claude Mentions

1. Click **Start** on this Actor's page on Apify Store.
2. Optionally edit the input on the **Input** tab — `searchQueries`, `maxVideosPerQuery`, `since`. The defaults work out of the box.
3. Press **Save & Start**. A typical run finishes in 2–5 minutes depending on transcript availability.
4. Open the **Output** tab to browse, sort, or download results as JSON, CSV, Excel, or HTML.
5. Hook into the [Apify API](https://docs.apify.com/api/v2), Zapier, Make, or your own webhook to pipe results into a dashboard.

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `searchQueries` | string[] | `["Claude Code tutorial", "Claude AI coding", "Anthropic Claude review"]` | YouTube search queries to scan, sorted by upload date so freshest videos come first. |
| `maxVideosPerQuery` | integer | `30` | Upper bound on videos inspected per query before transcript fetching. |
| `since` | ISO date string | 90 days ago | Skip videos older than this date (uses YouTube's relative time text). |

Example input JSON:

```json
{
  "searchQueries": [
    "Claude Code tutorial",
    "Anthropic Claude vs ChatGPT",
    "claude.ai review 2026"
  ],
  "maxVideosPerQuery": 50,
  "since": "2026-03-01"
}
````

### Output

Each dataset record represents one video with a verified Claude mention:

```json
{
  "title": "I built a SaaS in 3 hours using Claude Code",
  "channelName": "AI Builder",
  "channelUrl": "https://www.youtube.com/@AIBuilder",
  "views": 142000,
  "publishDate": "2026-04-18T00:00:00.000Z",
  "publishedText": "1 month ago",
  "mentionContext": "Claude Code is amazing — it handles the whole repo at once and the diffs are clean.",
  "sentiment": "positive",
  "sentimentScore": 2,
  "url": "https://www.youtube.com/watch?v=dQw4w9WgXcQ",
  "thumbnailUrl": "https://i.ytimg.com/vi/dQw4w9WgXcQ/hqdefault.jpg",
  "videoId": "dQw4w9WgXcQ",
  "durationSeconds": 832,
  "descriptionSnippet": "In this video I show how Claude Code shipped a working app in under three hours.",
  "transcriptAvailable": true,
  "matchedQuery": "Claude Code tutorial",
  "scrapedAt": "2026-05-21T18:42:11.234Z"
}
```

You can **download the dataset in JSON, HTML, CSV, or Excel** from the Output tab, or fetch it programmatically via the [Apify Dataset API](https://docs.apify.com/api/v2#/reference/datasets/item-collection).

### Data table

| Field | Description |
|---|---|
| `title` | Video title |
| `channelName` | Channel display name |
| `channelUrl` | Channel URL |
| `views` | Approximate view count at scrape time |
| `publishDate` | Best-effort ISO publish date parsed from "X days ago" |
| `publishedText` | Raw relative time text from YouTube |
| `mentionContext` | The ~1-sentence excerpt around the Claude mention |
| `sentiment` | `positive`, `neutral`, or `negative` (keyword heuristic) |
| `sentimentScore` | Integer score (positive words minus negative words) |
| `url` | Canonical video URL |
| `thumbnailUrl` | Highest-resolution thumbnail URL |
| `videoId` | YouTube video ID |
| `durationSeconds` | Video length |
| `descriptionSnippet` | First metadata snippet shown on search results |
| `transcriptAvailable` | Whether the auto-generated transcript was fetched |
| `matchedQuery` | Which input query surfaced this video |
| `scrapedAt` | ISO timestamp of the scrape |

### How much does it cost to scrape YouTube mentions?

This Actor is pay-per-result style work — most runs finish in 2–5 minutes of compute. With the **Apify free tier** you get $5/month of free platform credit, which typically covers tens of runs of this Actor at default settings. Heavy users (large `maxVideosPerQuery`, many queries) should expect <$0.10 per run on a paid plan. Set `maxVideosPerQuery` lower for faster, cheaper runs.

### Tips and advanced options

- **Schedule weekly.** Set a weekly cron in the Apify Console and diff datasets to track sentiment over time.
- **Add competitor keywords.** Append queries like `Cursor AI vs Claude`, `GPT-5 vs Claude`, `Copilot vs Claude Code` to surface cross-product comparison videos.
- **Use webhooks.** Wire the Actor to Slack or Discord via [Apify integrations](https://apify.com/integrations) so your team gets a ping on every new high-view mention.
- **Combine with downstream Actors.** Pipe `mentionContext` strings into a sentiment LLM for higher-accuracy classification, or feed `channelUrl` into a YouTube channel scraper for deeper enrichment.
- **Tune `since`.** A tight `since` window (e.g. last 7 days) gives a daily news-style feed; a wide one (12 months) gives a market overview.

### FAQ, disclaimers, and support

**Is this legal?** This Actor scrapes only publicly available YouTube search results and the publicly accessible auto-generated transcripts that YouTube serves to anonymous users. Respect YouTube's [Terms of Service](https://www.youtube.com/t/terms) and your local laws. Don't republish copyrighted transcripts wholesale.

**Why are some videos missing a transcript?** Not every video has captions, and YouTube periodically rotates its caption-track URL format. When transcripts are unavailable we fall back to matching against the title and description only.

**How accurate is the sentiment label?** It's a transparent keyword heuristic, ideal for trend-line tracking. For production-grade sentiment, pipe `mentionContext` into an LLM (Apify has [official AI integrations](https://apify.com/store?category=AI)).

**Found a bug or want a feature?** File an issue on the [Apify Store Actor page](https://apify.com/) or contact Ian Mu at [github.com/ianymu](https://github.com/ianymu).

**Built by Ian Mu** — solo founder shipping the [Claude Verify-Before-Stop](https://github.com/ianymu/claude-verify-before-stop) toolchain and a 100-actor Apify portfolio. Generated with [Claude Code](https://claude.ai/code) using Claude Opus 4.7.

# Actor input Schema

## `searchQueries` (type: `array`):

List of YouTube search queries used to discover videos. Each query is sorted by upload date so you catch the freshest content first.

## `maxVideosPerQuery` (type: `integer`):

Maximum number of videos to inspect per query. Videos older than the 'since' date are skipped before fetching transcripts, so this is an upper bound on work.

## `since` (type: `string`):

ISO 8601 date (e.g. '2025-12-01' or '2026-04-01T00:00:00Z'). Defaults to 90 days ago.

## Actor input object example

```json
{
  "searchQueries": [
    "Claude Code tutorial",
    "Claude AI coding",
    "Anthropic Claude review"
  ],
  "maxVideosPerQuery": 30
}
```

# Actor output Schema

## `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 = {
    "searchQueries": [
        "Claude Code tutorial",
        "Claude AI coding",
        "Anthropic Claude review"
    ],
    "since": ""
};

// Run the Actor and wait for it to finish
const run = await client.actor("ianymu/youtube-claude-mentions").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 = {
    "searchQueries": [
        "Claude Code tutorial",
        "Claude AI coding",
        "Anthropic Claude review",
    ],
    "since": "",
}

# Run the Actor and wait for it to finish
run = client.actor("ianymu/youtube-claude-mentions").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "searchQueries": [
    "Claude Code tutorial",
    "Claude AI coding",
    "Anthropic Claude review"
  ],
  "since": ""
}' |
apify call ianymu/youtube-claude-mentions --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=ianymu/youtube-claude-mentions",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "YouTube Claude Mentions Tracker",
        "description": "Track YouTube videos mentioning Claude Code, Claude AI, claude.ai, or Anthropic Claude. Pulls metadata + transcript, surfaces the mention sentence, tags sentiment (positive/neutral/negative), and ranks results. Brand monitoring, competitor analysis, and tutorial discovery in one scheduled run.",
        "version": "0.1",
        "x-build-id": "JY2giMfal0bqNsvHe"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/ianymu~youtube-claude-mentions/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-ianymu-youtube-claude-mentions",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/ianymu~youtube-claude-mentions/runs": {
            "post": {
                "operationId": "runs-sync-ianymu-youtube-claude-mentions",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/ianymu~youtube-claude-mentions/run-sync": {
            "post": {
                "operationId": "run-sync-ianymu-youtube-claude-mentions",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "searchQueries": {
                        "title": "Search queries",
                        "type": "array",
                        "description": "List of YouTube search queries used to discover videos. Each query is sorted by upload date so you catch the freshest content first.",
                        "default": [
                            "Claude Code tutorial",
                            "Claude AI coding",
                            "Anthropic Claude review"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxVideosPerQuery": {
                        "title": "Max videos per query",
                        "minimum": 1,
                        "maximum": 200,
                        "type": "integer",
                        "description": "Maximum number of videos to inspect per query. Videos older than the 'since' date are skipped before fetching transcripts, so this is an upper bound on work.",
                        "default": 30
                    },
                    "since": {
                        "title": "Only include videos published after this ISO date",
                        "type": "string",
                        "description": "ISO 8601 date (e.g. '2025-12-01' or '2026-04-01T00:00:00Z'). Defaults to 90 days ago."
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
