# YouTube Lead Qualifier Pro (`badruddeen/youtube-lead-qualifier-pro`) Actor

Instantly turn any YouTube niche into 5–30 qualified B2B leads with real business emails. AI-scores every channel 0–100 using Groq Llama 3.3 70B → delivers only the hottest ones in a ready-to-send CSV.

- **URL**: https://apify.com/badruddeen/youtube-lead-qualifier-pro.md
- **Developed by:** [Badruddeen Naseem](https://apify.com/badruddeen) (community)
- **Categories:** Lead generation, E-commerce, Automation
- **Stats:** 3 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.04 / actor start

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

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

## YouTube Lead Qualifier Pro

### What does YouTube Lead Qualifier Pro do?

YouTube Lead Qualifier Pro helps you extract qualified B2B leads from YouTube channels. Unlike the limited YouTube API, this actor enables you to identify and score high-potential business prospects directly from the platform.

YouTube Lead Qualifier Pro can extract:

- Channel metadata and business information
- Contact details and business emails
- AI-generated lead quality scores (0–100 scale)
- Channel performance metrics
- Niche and industry classification

---

### Overview

**YouTube Lead Qualifier Pro** is a powerful tool to **discover and AI-qualify YouTube channels** in any niche. Using **Groq Llama 3.3**, it evaluates channels based on your selected niche and scores them automatically. Only channels meeting your minimum AI score will be saved for further outreach or analysis.

Think of it as your AI-powered lead research assistant for YouTube.

---

### Features

- Gather YouTube channels in any niche using the YouTube Data API  
- AI scoring of channels using Groq Llama 3.3  
- Filter channels by minimum AI score  
- Optional use of YouTube cookies to avoid blocks  
- Output ready for CSV or JSON download
- Soft safety cap of 300 channels per run
- Optional early-stop when target number of qualified leads is reached

---

### Why scrape YouTube?

YouTube hosts over 2 billion logged-in users monthly and is a goldmine for B2B lead generation. Many successful businesses, agencies, consultants, and SaaS companies maintain active YouTube channels, making it an excellent source for identifying decision-makers and business prospects.

Here are some ways you could use YouTube lead data:

- Build targeted outreach lists for B2B sales campaigns
- Identify industry influencers and potential partners
- Research competitor channels and their audiences
- Find niche experts for collaboration opportunities
- Generate qualified leads for your sales pipeline

---

### Requirements

To run this actor, you need:

1. **Groq API Key** – Get one at [Groq.com](https://www.groq.com)  
2. **YouTube Data API Key** – Get one at [Google Cloud Console](https://console.cloud.google.com/apis/library/youtube.googleapis.com)  
3. **Optional:** YouTube logged-in cookies (only needed if blocked during scraping)  

---

### Input Schema

The actor expects a JSON input with the following structure:

```json
{
  "niche": "Marketing",
  "groqApiKey": "gsk_XXXXXXXXXXXXXXXXXXXX",
  "youtubeApiKey": "AIzaXXXXXXXXXXXXXXXXXXXX",
  "youtubeCookies": "",
  "maxChannels": 150,
  "minScore": 60
  "maxQualifiedLeads": 25
}
````

***

## Field Description

| Field               | Type    | Required | Description                                                                     |
| ------------------- | ------- | -------- | ------------------------------------------------------------------------------- |
| `niche`             | string  | Yes      | Niche or keyword to search for (e.g., "Shopify coach", "Real estate agent USA") |
| `groqApiKey`        | string  | Yes      | Your Groq.com API key (starts with gsk\_…)                                       |
| `youtubeApiKey`     | string  | Yes      | Your YouTube Data API key                                                       |
| `youtubeCookies`.   | string  | No       | Optional: logged-in YouTube cookies if blocked                                  |
| `maxChannels`       | integer | No       | Max channels to process (10–500). Default is 150                                |
| `minScore`          | integer | No       | Minimum AI score to qualify a channel (0–100). Default is 60                    |
| `maxQualifiedLeads` | integer | No | Optional: Stop processing once this many qualified leads are found |

***

### Output Schema

The actor returns a JSON array of channels that passed the AI score filter. Each channel object includes:

```
[
  {
    "channelName": "Channel Example",
    "channelUrl": "https://www.youtube.com/channel/XYZ",
    "subscriberCount": 12000,
    "videoCount": 45,
    "totalViews": 350000,
    "description": "Channel description here",
    "businessEmail": "contact@example.com",
    "aiScore": 78,
    "aiReasoning": "High relevance to niche and engagement metrics",
    "scoredAt": "2026-02-12T00:00:00.000Z"
  }
]
```

***

## Field Descriptions:

| Field             | Type    | Description                              |
| ----------------- | ------- | ---------------------------------------- |
| `channelName`     | string  | Name of the YouTube channel              |
| `channelUrl`      | string  | Direct URL to the channel                |
| `subscriberCount` | integer | Number of subscribers                    |
| `aiScore`         | integer | AI-generated qualification score (0–100) |
| `niche`           | string  | Niche that matched the search            |
| `email`           | string  | Contact email if found (optional)        |

## | The output can be downloaded as CSV or JSON directly from Apify.

## Notes

### Max Channels: Keep this number reasonable to avoid exceeding YouTube API quotas.

- There is a soft internal cap at 300 channels.

- The actor may stop early if maxQualifiedLeads is reached.

- AI Scoring: Channels below minScore will be automatically filtered out.

- Optional Cookies: Only required if YouTube blocks requests during processing.

***

### How to scrape YouTube

It's easy to extract qualified leads from [YouTube](https://www.youtube.com/) with YouTube Lead Qualifier Pro. Just follow these steps and you'll get your results in minutes.

1. Click on **Try for free**.
2. Enter the YouTube niche or search terms you want to target.
3. Click on **Run**.
4. When YouTube Lead Qualifier Pro has finished, preview or download your lead data as a CSV from the Dataset tab.

### How much will it cost to scrape YouTube?

Apify gives you $5 free usage credits every month on the [Apify Free plan](https://apify.com/pricing). You can get a substantial number of leads per month from YouTube Lead Qualifier Pro for that, so your initial leads will be completely free!

If you need to generate more leads regularly from YouTube, we recommend our [$49/month Starter plan](https://apify.com/pricing) - perfect for growing your B2B outreach efforts.

For larger-scale lead generation campaigns, the [$499 Scale plan](https://apify.com/pricing) offers enterprise-level capacity and priority support.

### Results

YouTube Lead Qualifier Pro delivers your leads as a ready-to-send CSV file containing:

- Channel name and URL
- Business email address
- Lead quality score (0–100, powered by Groq Llama 3.3 70B)
- Channel category and niche
- Contact information
- Engagement metrics

### Tips for scraping YouTube

- Focus on specific niches to improve lead quality and relevance
- Regularly review the AI scores to understand what makes a high-quality prospect
- Filter results by score threshold to prioritize outreach efforts
- Use the resulting CSV immediately for email campaigns or CRM imports
- Monitor delivery rates and engagement to refine your niche selection over time

### Is it legal to scrape YouTube?

Note that personal data is protected by GDPR in the European Union and by other regulations around the world. You should not scrape personal data unless you have a legitimate reason to do so. If you're unsure whether your reason is legitimate, consult your lawyers.

We also recommend that you read our blog post: [is web scraping legal?](https://blog.apify.com/is-web-scraping-legal/).

# Actor input Schema

## `testMode` (type: `boolean`):

✅ Default ON for safe automated testing. Turn OFF to fetch real channels and run AI scoring with your own API keys.

## `niche` (type: `string`):

What kind of channels to search for (e.g. shopify coach, real estate agent usa, saas founder)

## `groqApiKey` (type: `string`):

Your Groq.com API key (starts with gsk\_…)

## `youtubeApiKey` (type: `string`):

Your YouTube Data API key

## `youtubeCookies` (type: `string`):

Paste logged-in YouTube cookies only if you get blocked without login

## `maxChannels` (type: `integer`):

Maximum number of channels the actor will analyze (10–500). Soft capped at 300 internally.

## `minScore` (type: `integer`):

Only channels with AI score ≥ this value will be saved (0–100)

## `maxQualifiedLeads` (type: `integer`):

Optional: Stop processing once this many qualified leads have been found.

## Actor input object example

```json
{
  "testMode": true,
  "youtubeCookies": "",
  "maxChannels": 150,
  "minScore": 60
}
```

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

// Run the Actor and wait for it to finish
const run = await client.actor("badruddeen/youtube-lead-qualifier-pro").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("badruddeen/youtube-lead-qualifier-pro").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 '{}' |
apify call badruddeen/youtube-lead-qualifier-pro --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "YouTube Lead Qualifier Pro",
        "description": "Instantly turn any YouTube niche into 5–30 qualified B2B leads with real business emails. AI-scores every channel 0–100 using Groq Llama 3.3 70B → delivers only the hottest ones in a ready-to-send CSV.",
        "version": "0.0",
        "x-build-id": "9Jzr8m9DO6e6cp7nl"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/badruddeen~youtube-lead-qualifier-pro/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-badruddeen-youtube-lead-qualifier-pro",
                "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/badruddeen~youtube-lead-qualifier-pro/runs": {
            "post": {
                "operationId": "runs-sync-badruddeen-youtube-lead-qualifier-pro",
                "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/badruddeen~youtube-lead-qualifier-pro/run-sync": {
            "post": {
                "operationId": "run-sync-badruddeen-youtube-lead-qualifier-pro",
                "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",
                "required": [
                    "niche",
                    "groqApiKey",
                    "youtubeApiKey"
                ],
                "properties": {
                    "testMode": {
                        "title": "Test Mode (internal)",
                        "type": "boolean",
                        "description": "✅ Default ON for safe automated testing. Turn OFF to fetch real channels and run AI scoring with your own API keys.",
                        "default": true
                    },
                    "niche": {
                        "title": "Niche / Keyword",
                        "type": "string",
                        "description": "What kind of channels to search for (e.g. shopify coach, real estate agent usa, saas founder)"
                    },
                    "groqApiKey": {
                        "title": "Groq API Key (Secret)",
                        "type": "string",
                        "description": "Your Groq.com API key (starts with gsk_…)"
                    },
                    "youtubeApiKey": {
                        "title": "YouTube API Key (Secret)",
                        "type": "string",
                        "description": "Your YouTube Data API key"
                    },
                    "youtubeCookies": {
                        "title": "YouTube Cookies (optional) (Secret)",
                        "type": "string",
                        "description": "Paste logged-in YouTube cookies only if you get blocked without login",
                        "default": ""
                    },
                    "maxChannels": {
                        "title": "Max channels to process",
                        "minimum": 10,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Maximum number of channels the actor will analyze (10–500). Soft capped at 300 internally.",
                        "default": 150
                    },
                    "minScore": {
                        "title": "Minimum AI score to qualify",
                        "minimum": 0,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Only channels with AI score ≥ this value will be saved (0–100)",
                        "default": 60
                    },
                    "maxQualifiedLeads": {
                        "title": "Max Qualified Leads (optional)",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Optional: Stop processing once this many qualified leads have been found."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
