# YouTube Channel Analyzer - Audience Language & Sponsorship Fit (`salomon.labs/youtube-channel-analyzer`) Actor

Analyze YouTube channels for sponsorship: expected views from recent uploads, audience language inferred from real comments, upload cadence, engagement, whether they already take brand deals, and an estimated price from your own CPM.

- **URL**: https://apify.com/salomon.labs/youtube-channel-analyzer.md
- **Developed by:** [Alan Salomon](https://apify.com/salomon.labs) (community)
- **Categories:** Social media, Lead generation, Videos
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $30.00 / 1,000 analyzed channels

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/platform/actors/running/actors-in-store#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 Channel Analyzer — Reach, Audience Language & Sponsorship Fit

**Give it a list of YouTube channels. Get back what you actually need before you
offer anyone a sponsorship.**

Subscriber counts do not tell you what a video will get, and they do not tell you
who watches. This Actor reads a channel's recent uploads, a sample of its real
comments, and its recent video descriptions, and returns the numbers a brand
needs — each one with the evidence behind it.

### What you get, per channel

| Field | What it means |
|---|---|
| **Expected views** | The **median** of recent uploads — not the average, and not subscribers |
| **Days since last upload** | So a big number from a dormant channel cannot mislead you |
| **Audience language** | Inferred from a sample of real comments, with the sample size and confidence |
| **Takes sponsorships** | Whether recent videos carry brand deals — and separately, affiliate links, memberships and their own products |
| **Sponsors named** | Who has sponsored them recently, where the description says so |
| **Competitors seen** | Any brand you named, with the sentence it appeared in — read across the last ten videos, not just the last three |
| **Estimated price range** | Expected views × **your** CPM. Arithmetic on measured data |
| **Upload cadence and engagement** | How often they post, and their like rate |

### Why the median, not the average

One viral upload drags a channel's average 20–75% above what a normal video
gets. We measured it: `@RaidOwl` averages 28,933 views and the median is 16,500.
Price a sponsorship off the average and you overpay by that much.

### Why comments, not titles

YouTube translates video titles into whichever language you ask for. Request
English and a Mexican Spanish-language creator's titles come back in English —
the titles describe *your request*, not their audience. Comments are not
translated, so that is what we read.

### Two windows, on purpose

Audience language comes from **comments**, and three videos is plenty — the
language a sample points to is stable from about ten comments, so sampling stops
as soon as it has enough.

Sponsor history and competitor mentions come from **descriptions**, and that
window is wider by default, because "has this creator promoted my competitor
recently" is not a question three videos can answer. On one real channel, reading
three descriptions found no competitors and reading twelve found three of them.

Both are adjustable. Raising the description window makes runs slower, since each
extra video is one more page fetched.

### What it will not do

- **It will not tell you who to pick.** It returns facts and one piece of
  arithmetic. The weighting, the shortlist and the budget are yours — you know
  your market and we do not.
- **It will not guess a CPM.** Rates vary enormously by niche. Supply your own,
  or leave them blank and get every other field.
- **It will not claim a language it cannot support.** When a comment sample is
  too small or too mixed, the language is left blank with the reason stated,
  and the full distribution is still there for you to read. Audiences that write
  their own language in Latin script — romanized Hindi, for example — reliably
  defeat language detection, and we would rather say nothing than say "English".
- **It does not read transcripts.** A sponsor mentioned aloud and never linked in
  the description is invisible to it.
- **It does not report audience age or gender.** Those exist only in a creator's
  own YouTube Analytics or in paid panel data. Anyone selling them from the
  outside is modelling, not measuring.

### Input

Paste channel handles (`@name`), full channel URLs, or channel IDs (`UC...`).
Repeats in your list are charged once. Optionally add your CPM range and the
competitors you want flagged.

Leave the input empty and it runs a small sample so you can see the output shape.

### Output

Two dataset views: **Shortlist** (the decision columns) and **Evidence** (sample
sizes, sponsor names, and the reason any answer was withheld). Export the
Shortlist view for a clean CSV — exporting the unfiltered dataset sorts all
columns alphabetically.

Every row carries the same columns, including rows for channels that could not be
read, so a spreadsheet built on the output never changes shape halfway down.

### Pricing

Pay per channel analyzed. Channels that could not be read are **not** charged —
our failure is not your bill.

# Actor input Schema

## `channelUrls` (type: `array`):

Channel handles (@name), full channel URLs, or channel IDs (UC...). Repeats are charged once. Leave empty to see a small sample run.

## `cpmLow` (type: `integer`):

What you are willing to pay per 1,000 views at the low end. Used only to turn expected views into a price range - we do not assume a rate for your market. Leave both CPM fields empty and you still get every other field.

## `cpmHigh` (type: `integer`):

The top of the same range. Integration rates vary enormously by niche - finance and B2B software sit far above gaming and entertainment - so this is your judgement, not ours.

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

Brands you do not want a creator to have promoted recently. Any mention in a recent video description is reported with the sentence it appeared in. Names shorter than three characters are ignored, because they match inside other words.

## `recentVideos` (type: `integer`):

Expected views is the MEDIAN of this many recent uploads, not the average - one viral video drags an average 20-75% above what a normal upload gets. Twelve is roughly a quarter for a weekly channel.

## `videosToSample` (type: `integer`):

Videos whose COMMENTS are read, which is where audience language comes from. Three is generous: the language a sample points to is stable from about ten comments, and sampling stops early once it has enough.

## `descriptionsToRead` (type: `integer`):

Videos whose DESCRIPTION is read, which is where sponsor history and competitor mentions come from. Wider than the comment sample on purpose - 'has this creator promoted my competitor recently' means more than three videos. Each extra video is one more page fetched, so raising this makes runs slower.

## `concurrency` (type: `integer`):

Lower is safer. This Actor reads a dozen pages per channel, and YouTube rate-limits aggressively. Five is the ceiling; measured on the platform, five channels at a time with twelve descriptions each peaks at 258 MB against the Actor's 512 MB.

## `delaySeconds` (type: `integer`):

Politeness is a feature: a blocked IP costs a whole run, not one row.

## Actor input object example

```json
{
  "channelUrls": [
    "@mkbhd",
    "https://www.youtube.com/@Fireship"
  ],
  "competitors": [
    "NordVPN",
    "Squarespace"
  ],
  "recentVideos": 12,
  "videosToSample": 3,
  "descriptionsToRead": 10,
  "concurrency": 3,
  "delaySeconds": 1
}
```

# Actor output Schema

## `shortlist` (type: `string`):

One row per channel: reach, activity, audience language, sponsor history, competitor mentions and an estimated price range.

## `evidence` (type: `string`):

Why each answer says what it says: sample sizes, sponsor names, and the reason any claim was withheld.

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

Every column, including the run summary record.

# 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 = {
    "channelUrls": [
        "@TechnoTim"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("salomon.labs/youtube-channel-analyzer").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 = { "channelUrls": ["@TechnoTim"] }

# Run the Actor and wait for it to finish
run = client.actor("salomon.labs/youtube-channel-analyzer").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 '{
  "channelUrls": [
    "@TechnoTim"
  ]
}' |
apify call salomon.labs/youtube-channel-analyzer --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,salomon.labs/youtube-channel-analyzer"
        }
    }
}

```

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/QjNRYLk5Qsr7OvlX0/builds/hjlJuqSxFA2SKpMZY/openapi.json