# Youtube Channel Finder (`scrapers-hub/youtube-channel-finder`) Actor

🔎 YouTube Channel Finder helps you discover, analyze & grow your next niche channels fast. Find relevant creators, track performance insights, and uncover opportunities for marketing, research & collaboration. 🚀

- **URL**: https://apify.com/scrapers-hub/youtube-channel-finder.md
- **Developed by:** [Scrapers Hub](https://apify.com/scrapers-hub) (community)
- **Categories:** Social media, Lead generation, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.99 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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/docs.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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 Channel Finder 🔍

**YouTube Channel Finder** helps you discover YouTube channels at scale by searching with your own keywords and (optionally) focusing on a target country—so you can quickly build lists for outreach, collaboration, and YouTube channel discovery without doing everything manually. Whether you’re a marketer, recruiter, or data enthusiast looking to **find YouTube channels**, **search YouTube channel by name**, or **find YouTubers by niche**, this tool turns public web data into usable channel records.  

---

### Why choose YouTube Channel Finder?

| Feature | Benefit |
| --- | --- |
| ✅ **Keyword-based channel discovery** | Find YouTube channels by keyword inputs you control |
| ✅ **Country targeting** | Filter results using your selected **Target Country** |
| ✅ **Reliability with retries & fallbacks** | Includes resilience patterns to handle occasional fetch failures |
| ✅ **Structured dataset output** | Produces consistent fields like `keyword`, `url`, `description_snippet`, and `source` |
| ✅ **Scales across multiple keywords** | Processes each keyword until reaching your run’s effective limit |
| ✅ **Proxy support** | Built-in proxy support for more reliable scraping |

---

### Key features

- 🎯 **Keyword-driven discovery:** Use your `keywords` list to drive channel discovery for **YouTube channel search** and **YouTube creator search**
- 🌍 **Target country filtering:** Use the `country` input to narrow results by region for more relevant **YouTube influencer finder** lists
- 🧠 **Channel URL validation:** Keeps only URLs that match valid channel formats (filters out videos, shorts, posts, and other non-channel links)
- 🧾 **Clean snippet extraction:** Captures a readable `description_snippet` to give you context for each discovered channel
- 📊 **Consistent dataset schema:** Saves results with `keyword`, `url`, `description_snippet`, and `source` for easy downstream analysis (CSV/JSON export from the dataset)
- 🛡️ **Resilience during scraping:** Uses retry logic and page-to-page pacing to improve run stability
- 💾 **Real-time saving to dataset:** As each keyword is processed, results are immediately pushed to the default dataset storage for **YouTube channel lookup**
  
---

### Input

Provide input via an `input.json` file. Example structure:

```json
{
  "keywords": ["fitness", "tech reviewer", "gaming"],
  "country": "United States"
}
````

#### Input Fields

| Field | Required | Description |
| --- | --- | --- |
| `keywords` | ✅ Yes | List of keywords to search for YouTube channels (for example: `fitness`, `tech reviewer`, `gaming`). |
| `country` | ❌ No | Select the target country for leads. This helps focus **YouTube channel discovery** results on your preferred region. Defaults to `United States`. |

***

### Output

The actor saves the discovered channels into the Apify dataset as JSON objects. The default dataset view is titled **YouTube Channels**.

Example output records:

```json
[
  {
    "keyword": "fitness",
    "url": "https://www.youtube.com/@fitnesschannel",
    "description_snippet": "Example snippet describing the channel topic...",
    "source": "Search Engine"
  }
]
```

#### Output Fields

| Field | Type | Description |
| --- | --- | --- |
| `keyword` | string | The keyword that produced this channel result (useful for **find niche YouTube channels** workflows). |
| `url` | string | The discovered YouTube channel URL. |
| `description_snippet` | string | A text snippet extracted from the listing to help you judge relevance quickly. |
| `source` | string | Where the record was sourced from (saved as `Search Engine`). |

**Note:** Output is written to the dataset, which you can export in JSON/CSV from the Apify Console.

***

### How to use YouTube Channel Finder (via Apify Console)

1. **Open Apify Console**\
   Log in at https://console.apify.com and go to the **Actors** page.

2. **Find YouTube Channel Finder**\
   Search for **YouTube Channel Finder** and open the actor details page.

3. **Go to the INPUT tab**\
   Paste your configuration into the input form / `input.json` field.

4. **Set your keywords**\
   In `keywords`, add one or more phrases you want to use for **YouTube channel search engine** style discovery (e.g., `fitness`, `gaming`, `tech reviewer`).

5. **(Optional) Choose a target country**\
   Set `country` if you want region-focused **YouTube channel contact info** discovery lists (default is `United States`).

6. **Choose proxy settings if prompted**\
   The actor supports proxy usage to improve reliability. If proxies aren’t available, it can proceed without them.

7. **Run the actor**\
   Click **Run**. Watch the logs for progress as each keyword is processed and results are saved.

8. **Open the OUTPUT dataset and export**\
   After completion, open the dataset titled **YouTube Channels** and export the results (JSON/CSV) for your CRM, spreadsheets, or research pipeline.

No coding required—get **YouTube channel finder tool** results in minutes.

***

### Advanced features & SEO optimization

- ⚡ **Engineered for YouTube channel discovery:** The **YouTube Channel Finder** is built specifically to help with **find YouTube channels**, not generic browsing
- 🌍 **Location-focused discovery:** Use the `country` setting to improve relevance for **find niche YouTube channels**
- 🧩 **Channel-only validation:** It only keeps URLs that match valid YouTube channel patterns, helping your list stay clean for **find YouTube channels for collaboration**
- 📌 **Keyword-to-record traceability:** Every dataset row includes the originating `keyword` so you can filter and analyze results by theme
- 💾 **Dataset-first workflow:** Results are pushed to the dataset as the run progresses, so you can start working without waiting for everything to finish

***

### Best use cases

- 📈 **Marketing teams**: Build targeted lists for outreach by quickly finding YouTube channels tied to your niche
- 🤝 **Partnership managers**: Discover creators for collaboration by using keyword-driven **YouTube channel lookup**
- 🔍 **Researchers & analysts**: Analyze channel discovery performance by keyword and region using consistent dataset fields
- ✉️ **Sales & lead gen**: Use **YouTube influencer finder** outputs as a starting point for contact enrichment workflows
- 🎓 **Content strategists**: Find YouTubers by niche to benchmark themes and discover new channels
- 💼 **Recruiters**: Identify creators with relevant topical focus for hiring and community roles
- 🧑‍💻 **Data pipeline builders**: Feed structured dataset output into downstream ETL and analytics

***

### Technical specifications

- **Supported Input Formats**
  - ✅ JSON input with `keywords` array
  - ✅ Optional `country` string from the provided enum list

- **Proxy Support**
  - ✅ Built-in proxy support for more reliable scraping

- **Retry Mechanism**
  - ✅ Uses retry logic during page scraping

- **Dataset Structure**
  - ✅ Saved to the default dataset storage titled **YouTube Channels**
  - ✅ Each record includes: `keyword`, `url`, `description_snippet`, `source`

- **Rate Limits & Performance**
  - ✅ Includes configurable pacing between pages (`request_delay` is set in the actor logic)
  - ✅ Uses a capped run behavior based on run limits (free vs paid plan)

- **Limitations**
  - ❌ Only publicly available data is collected
  - ❌ Some channels may not surface meaningful snippets in all cases, so you should validate relevance after export

***

### FAQ

#### Does YouTube Channel Finder require a login?

✅ No login is required. The actor is designed for channel discovery using public web data.

#### What inputs do I need to start a run?

You only must provide `keywords`. Optionally, you can set `country` to target a specific region for your **YouTube channel search** results.

#### Can I use it to find channel contact information?

This actor focuses on discovering YouTube channels and saving channel URLs with a `description_snippet` plus the `keyword` and `source`. If you need deeper contact enrichment, use your preferred enrichment steps after exporting the dataset.

#### Where do I find the results after the run?

After the actor completes, open the Apify dataset titled **YouTube Channels**. The results include `keyword`, `url`, `description_snippet`, and `source`.

#### How does the actor keep the output clean and channel-specific?

❌ It filters out non-channel links and validates that results match recognized channel URL formats, helping avoid video/shorts/post URLs in your list.

#### What happens if a keyword doesn’t return results?

The actor proceeds through keywords and also handles empty pages gracefully using built-in resilience logic. Your dataset will simply contain fewer entries for that keyword.

#### Is there a limit on how many channels it can return?

✅ The effective channel count is capped per run and varies depending on whether the run is on a free tier vs a paid plan. On free tier, it is capped at 100 channels per run; on paid, no hard limits are enforced.

#### Can I use the output for outreach and lead generation?

Yes, you can use the discovered channel lists as inputs for your own research and outreach workflows. Make sure you comply with applicable laws and platform policies for your use case.

***

### Support & feature requests

If you’re using **YouTube Channel Finder** for **YouTube channel discovery** and want improvements, share your feedback—we’re actively iterating based on what users need.

- 💡 **Feature Requests**: Ideas like CSV export enhancements, additional enrichment fields for **YouTube channel email** workflows, or CRM-ready output formats.
- 📧 **Contact**: Reach out at <dataforleads@gmail.com>.

Your input helps shape the roadmap for better **YouTube channel finder tool** results.

***

### Closing CTA / Final thoughts

*For fast, structured **YouTube Channel Finder** results that support keyword-based channel discovery at scale, this actor is built to be easy to run and simple to export.*

Generate cleaner **YouTube channel discovery** lists—start your next run today. 🚀

***

### Disclaimer

**This tool accesses publicly accessible sources only.** It does not access private profiles, authenticated data, or password-protected pages.

You are responsible for ensuring your use complies with applicable laws (including GDPR/CCPA where relevant), spam regulations, and each platform’s Terms of Service. Always use the results responsibly and ethically.

For data removal requests, contact <dataforleads@gmail.com>.

# Actor input Schema

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

List of keywords to search for YouTube channels (e.g., 'tech reviewer', 'fitness', 'gaming').

## `country` (type: `string`):

Select the target country for leads.

## Actor input object example

```json
{
  "keywords": [
    "fitness"
  ],
  "country": "United States"
}
```

# 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 = {
    "keywords": [
        "fitness"
    ],
    "country": "United States"
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapers-hub/youtube-channel-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 = {
    "keywords": ["fitness"],
    "country": "United States",
}

# Run the Actor and wait for it to finish
run = client.actor("scrapers-hub/youtube-channel-finder").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 '{
  "keywords": [
    "fitness"
  ],
  "country": "United States"
}' |
apify call scrapers-hub/youtube-channel-finder --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Youtube Channel Finder",
        "description": "🔎 YouTube Channel Finder helps you discover, analyze & grow your next niche channels fast. Find relevant creators, track performance insights, and uncover opportunities for marketing, research & collaboration. 🚀",
        "version": "1.0",
        "x-build-id": "hnWQhCtbC94JlsXG6"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapers-hub~youtube-channel-finder/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapers-hub-youtube-channel-finder",
                "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/scrapers-hub~youtube-channel-finder/runs": {
            "post": {
                "operationId": "runs-sync-scrapers-hub-youtube-channel-finder",
                "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/scrapers-hub~youtube-channel-finder/run-sync": {
            "post": {
                "operationId": "run-sync-scrapers-hub-youtube-channel-finder",
                "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": [
                    "keywords"
                ],
                "properties": {
                    "keywords": {
                        "title": "Search Keywords",
                        "minItems": 1,
                        "uniqueItems": true,
                        "type": "array",
                        "description": "List of keywords to search for YouTube channels (e.g., 'tech reviewer', 'fitness', 'gaming').",
                        "items": {
                            "type": "string"
                        }
                    },
                    "country": {
                        "title": "Target Country",
                        "enum": [
                            "United States",
                            "United Kingdom",
                            "Canada",
                            "Australia",
                            "India",
                            "Germany",
                            "France",
                            "Spain",
                            "Italy",
                            "Brazil",
                            "Mexico",
                            "Japan",
                            "South Korea",
                            "China",
                            "Singapore",
                            "United Arab Emirates",
                            "Netherlands",
                            "Sweden",
                            "Norway",
                            "Denmark",
                            "Switzerland",
                            "Belgium",
                            "Austria",
                            "Ireland",
                            "New Zealand",
                            "South Africa"
                        ],
                        "type": "string",
                        "description": "Select the target country for leads.",
                        "default": "United States"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```