Pricing

$19.99/month + usage

🔍 YouTube Channel Finder

Find the best YouTube channels by keyword, niche, or topic with ease 🔍📺 Extract channel names, URLs, subscriber counts, video stats, and more. Perfect for influencer discovery, competitor research, outreach, and content planning. Discover top creators faster 🚀

Pricing

$19.99/month + usage

Rating

0.0

(0)

Developer

ScrapeMesh

Actor stats

Bookmarked

Total users

Monthly active users

3 days ago

Last modified

Categories

Social media

Lead generation

Videos

You can access the 🔍 YouTube Channel Finder programmatically from your own applications by using the Apify API. You can also choose the language preference from below. To use the Apify API, you’ll need an Apify account and your API token, found in Integrations settings in Apify Console.

Python

JavaScript

CLI

OpenAPI

HTTP

MCP

{
  "openapi": "3.0.1",
  "info": {
    "version": "0.0",
    "x-build-id": "Pew2MKUhAm64ckwXe"
  },
  "servers": [
    {
      "url": "https://api.apify.com/v2"
    }
  ],
  "paths": {
    "/acts/scrapemesh~youtube-channel-finder/run-sync-get-dataset-items": {
      "post": {
        "operationId": "run-sync-get-dataset-items-scrapemesh-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/scrapemesh~youtube-channel-finder/runs": {
      "post": {
        "operationId": "runs-sync-scrapemesh-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/scrapemesh~youtube-channel-finder/run-sync": {
      "post": {
        "operationId": "run-sync-scrapemesh-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",
        "properties": {
          "keywords": {
            "title": "Search Keywords",
            "type": "array",
            "description": "Search terms to find YouTube channels (e.g. \"cooking tutorials\", \"tech reviews\"). The actor uses YouTube search and returns matching channels. Add one keyword per line. Combine with \"Channels per keyword\" to control how many channels to fetch per term.",
            "items": {
              "type": "string"
            }
          },
          "channelCount": {
            "title": "Max channels per search term",
            "minimum": 1,
            "maximum": 5000,
            "type": "integer",
            "description": "Maximum number of channels to extract for each search keyword (1–50). Higher values return more results but take longer.",
            "default": 10
          },
          "searchRegion": {
            "title": "Search Region",
            "enum": [
              "US",
              "GB",
              "CA",
              "AU",
              "IN",
              "DE",
              "FR",
              "JP",
              "BR",
              "MX",
              "ES",
              "IT",
              "NL",
              "PL",
              "RU",
              "KR",
              "TW"
            ],
            "type": "string",
            "description": "YouTube search region (country code). Affects which channels appear in search results.",
            "default": "US"
          },
          "language": {
            "title": "Language",
            "enum": [
              "en",
              "es",
              "de",
              "fr",
              "pt",
              "ja",
              "hi",
              "zh",
              "ko",
              "ar",
              "ru"
            ],
            "type": "string",
            "description": "Interface and result language code (e.g. en for English).",
            "default": "en"
          },
          "fromDate": {
            "title": "From Date (Joined After)",
            "pattern": "^(\\d{4})-(0[1-9]|1[0-2])-(0[1-9]|[12]\\d|3[01])$",
            "type": "string",
            "description": "Only include channels that joined on or after this date (YYYY-MM-DD). Leave empty for no filter."
          },
          "toDate": {
            "title": "To Date (Joined Before)",
            "pattern": "^(\\d{4})-(0[1-9]|1[0-2])-(0[1-9]|[12]\\d|3[01])$",
            "type": "string",
            "description": "Only include channels that joined on or before this date (YYYY-MM-DD). Leave empty for no filter."
          },
          "urls": {
            "title": "YouTube URL",
            "type": "array",
            "description": "Discover channels from specific YouTube URLs directly (channel or video URLs).",
            "items": {
              "type": "string"
            }
          },
          "proxyConfiguration": {
            "title": "🌐 Proxy configuration",
            "type": "object",
            "description": "Optional. By default the actor runs without a proxy. Enable Apify Proxy here for higher volume or to reduce blocks. If the chosen proxy gets blocked, the actor automatically falls back to Residential proxy and continues."
          }
        }
      },
      "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
                  }
                }
              }
            }
          }
        }
      }
    }
  }
}

🔍 YouTube Channel Finder OpenAPI definition

OpenAPI is a standard for designing and describing RESTful APIs, allowing developers to define API structure, endpoints, and data formats in a machine-readable way. It simplifies API development, integration, and documentation.

OpenAPI is effective when used with AI agents and GPTs by standardizing how these systems interact with various APIs, for reliable integrations and efficient communication.

By defining machine-readable API specifications, OpenAPI allows AI models like GPTs to understand and use varied data sources, improving accuracy. This accelerates development, reduces errors, and provides context-aware responses, making OpenAPI a core component for AI applications.

You can download the OpenAPI definitions for 🔍 YouTube Channel Finder from the options below:

OpenAPI.json

If you’d like to learn more about how OpenAPI powers GPTs, read our blog post.

You can also check out our other API clients:

🔍 YouTube Channel Finder API in Python

🔍 YouTube Channel Finder API in JavaScript

🔍 YouTube Channel Finder API through CLI

🔍 YouTube Channel Finder API

Youtube Channel Finder

scrapier/youtube-channel-finder

Find and analyze YouTube channels with the YouTube Channel Finder Scraper. Search by keyword or niche to extract channel names, IDs, stats, and descriptions. Ideal for influencer discovery, market research, and competitor analysis. Fast, accurate, and easy to use at scale.

Scrapier

Youtube Channel Scraper

scrapapi/youtube-channel-scraper

Extract detailed data from YouTube channels using the YouTube Channel Scraper. Collect channel names, descriptions, subscriber counts, video counts, social links, and channel URLs automatically. Ideal for influencer discovery, marketing research, and creator outreach.

ScrapAPI

Youtube Channel Finder

scrapio/youtube-channel-finder

Finds YouTube channels based on keywords or niches, capturing channel names, IDs, URLs, subscriber counts, descriptions, categories, and engagement metrics. Ideal for influencer discovery, competitor research, niche analysis, and automated channel prospecting

Scrapio

🔍 YouTube Channel Finder — Discover channels by keyword or URL

scrapebase/youtube-channel-finder

✨ YouTube Channel Finder to discover relevant channels based on keywords and niches quickly. Extract channel names, links, subscribers, and metadata with ease. Ideal for research, outreach, and competitor analysis. Features: ⚡ fast discovery • 📊 clean data • 🔍 insights • 🌍 scalable automation

ScrapeBase

Youtube Channel Finder

scraper-engine/youtube-channel-finder

YouTube Channel Finder Scraper helps discover YouTube channels based on keywords, topics, or niches. It extracts channel details like name, URL, subscriber count, and description. Perfect for influencer outreach, market research, or tracking niche creators to support targeted marketing strategies.

Scraper Engine

Youtube Channel Finder

simpleapi/youtube-channel-finder

YouTube Channel Finder locates and returns detailed channel profiles from YouTube by username, keyword, or URL. Returns channel ID, title, description, subscriber counts, uploads, thumbnails, links, and stats. Perfect for discovery, competitive research, influencer outreach, and automated workflows

SimpleAPI

Youtube Niche Channel Finder

badruddeen/youtube-niche-channel-finder

Discover top YouTube channels in any niche instantly. Enter a keyword and your YouTube API key — this Actor fetches channel info like subscribers, views, videos, country, and description. Perfect for influencer research, competitor analysis, and market insights.

Badruddeen Naseem

Youtube Channel Lead Scraper

scraper-engine/youtube-channel-lead-scraper

Extract valuable leads from YouTube channels with the YouTube Channel Lead Scraper. Collect channel names, emails, social links, subscriber counts, and video metrics. Perfect for influencer outreach, marketing campaigns, and building targeted prospect lists.

Scraper Engine