# Youtube User Channel Scraper (`scraperoka/youtube-user-channel-scraper`) Actor

🔎 YouTube Channel Scraper extracts key channel data—subscribers, views, video stats, tags & links—quickly and accurately. 🚀 Perfect for market research, creator analysis, lead gen & competitive insights. 📈 Get more done, faster!

- **URL**: https://apify.com/scraperoka/youtube-user-channel-scraper.md
- **Developed by:** [Scraperoka](https://apify.com/scraperoka) (community)
- **Categories:** Social media, Lead generation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.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 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 User Channel Scraper 🚀

Manually visiting dozens (or hundreds) of YouTube channels to collect subscriber, video, view, and profile details wastes hours you can’t get back. **Youtube User Channel Scraper** automatically extracts YouTube user channel information using channel IDs or URLs—powered by a **Youtube User Channel Scraper** workflow for YouTube user channel scraper and YouTube channel scraper tool use cases. It’s ideal for marketers, recruiters, and growth teams who need channel data at speed; a single run can return many structured records in minutes.

***

### What You Get: Sample Output

Here's a sample record from a single run:

```json
{
  "channelId": "UCyBD3P9YOFWNIMTuDzqeObg",
  "avatar": "https://example.com/avatar.jpg",
  "banner": "https://example.com/banner.jpg",
  "title": "BBC News",
  "verified": 1,
  "hasbusinessEmail": 0,
  "joinDate": "2020-01-15",
  "country": "United Kingdom",
  "viewCount": 2891234567,
  "videoCount": 12345,
  "subscriberCount": 91234567,
  "description": "Latest news and updates.",
  "links": [
    { "title": "Website", "link": "example.com" }
  ],
  "indexUrl": "http://www.youtube.com/channel/UCyBD3P9YOFWNIMTuDzqeObg",
  "channelUrl": "https://www.youtube.com/channel/UCyBD3P9YOFWNIMTuDzqeObg"
}
```

| Field | Type | What It Tells You |
|---|---|---|
| `channelId` | string | The stable identifier you can join on across datasets |
| `avatar` | string | null | Profile image URL you can display or enrich downstream |
| `banner` | string | null | Channel banner image URL for branding/visual context |
| `title` | string | null | Channel name as shown on the channel page |
| `verified` | number | Whether the channel is marked verified (1) or not (0) |
| `hasbusinessEmail` | number | Whether the channel provides a business email (1) or not (0) |
| `joinDate` | string | null | “Joined” date extracted from the channel metadata |
| `country` | string | null | Country value provided in the channel info |
| `viewCount` | number | Total views count, parsed into a numeric value |
| `videoCount` | number | Total number of videos, parsed into a numeric value |
| `subscriberCount` | number | Subscriber count, parsed into a numeric value |
| `description` | string | null | Channel description text for brief summaries and filtering |
| `links` | array | null | Social links (title + link) found in the channel metadata |
| `indexUrl` | string | null | A canonical URL built from the channel ID (when available) |
| `channelUrl` | string | null | The full channel URL derived from the channel metadata |
| `error_message` | not present in output | The actor logs errors, but no `error_message` output field is pushed |

Export your dataset as JSON, CSV, or Excel — straight from the Apify dashboard.

***

### Why Youtube User Channel Scraper?

There are a lot of ways to pull data from YouTube—here’s what sets **Youtube User Channel Scraper** apart.

#### Channel IDs or URLs, no manual conversion

**Youtube User Channel Scraper** supports both `ids` (comma-separated YouTube Channel IDs) and `start_urls` (YouTube channel URLs). That makes it convenient for workflows that start from a list of channel IDs or from a discovery sheet of URLs, including “YouTube username to channel scraper” style inputs.

#### Full channel metadata in one structured record

Instead of piecemeal scraping, the actor returns a single JSON object per channel with key metadata like `subscriberCount`, `videoCount`, `viewCount`, `joinDate`, `country`, and `description`. This makes it a strong YouTube channel data scraper and YouTube channel metadata scraper for building clean channel datasets.

#### Built for resilience with retries

The actor includes retries and fallback behavior when fetching channel pages fails or when the expected data payload isn’t found. This helps when scraping at scale for YouTube user scraper and YouTube channel scraper tool use cases.

#### Built-In proxy support for reliable scraping

The actor uses proxy support to improve reliability for bulk runs. That’s especially useful when you’re extracting YouTube channel about info and YouTube channel contact scraper-related signals at larger volume.

***

### Configuring Your Run

Drop this into your `input.json` to get started:

```json
{
  "ids": "UCyBD3P9YOFWNIMTuDzqeObg,UCabcdEfGhIjKlMnOpQrStU",
  "start_urls": [
    { "url": "https://www.youtube.com/@BBCNews" }
  ]
}
```

| Parameter | Required | What It Does |
|---|---|---|
| `ids` | ⬜ | Comma-separated list of YouTube Channel IDs (example: `UCyBD3P9YOFWNIMTuDzqeObg`) |
| `start_urls` | ⬜ | List of YouTube channel URLs to scrape (for example: `https://www.youtube.com/@BBCNews`) |
| ↳ `start_urls[].url` | ✅ | A single YouTube channel URL to add to the run |

You can provide either `ids`, `start_urls`, or both; the actor processes `start_urls` first (in the order provided), then processes `ids`.

***

### Core Capabilities

#### Extracts YouTube channel subscribers, views, and videos

**Youtube User Channel Scraper** parses and returns numeric `subscriberCount`, `videoCount`, and `viewCount` as part of each channel record. That’s ideal when you’re scraping YouTube channel subscribers or comparing channel sizes across a prospect list.

#### Captures join date, country, and description for context

Each output record includes `joinDate`, `country`, and `description` from the channel metadata. This helps researchers and analysts understand channel history and positioning without manually opening every channel.

#### Pulls profile visuals and curated links

The actor extracts `avatar` and `banner` URLs and also returns `links` when available (as an array of `{ "title": ..., "link": ... }`). This supports downstream workflows like channel profiling and enrichment—useful for YouTube channel analytics scraper and YouTube channel URL scraper tasks.

#### Detects business email availability

The actor includes a numeric `hasbusinessEmail` field based on whether the channel provides business email information. This is a practical building block for YouTube channel email scraper and YouTube channel contact scraper workflows.

#### Produces structured, integration-ready output

The actor pushes one consistent JSON object per successfully scraped channel. You can export from the dataset tab or consume results via the Apify API for repeatable pipelines (including YouTube channel data scraper and YouTube channel metadata scraper use cases).

***

### Who Gets the Most Out of This

Here's how different teams put **Youtube User Channel Scraper** to work:

**Influencer marketing managers** use it to build and refresh channel shortlists by quickly extracting subscriberCount, viewCount, and videoCount, then adding joinDate and country context to prioritize creators that match campaign timelines.

**Sales development and partnerships teams** use this YouTube channel scraper tool output to standardize channel attributes before outreach, including verified status (`verified`) and whether business contact info appears to be available (`hasbusinessEmail`).

**Freelance researchers & data analysts** rely on YouTube user channel scraper results to assemble consistent datasets for channel benchmarking, trend analysis, and reporting—especially when needing clean numeric counts rather than raw text.

**Automation and data engineering specialists** integrate the YouTube channel URL scraper results into scheduled jobs and downstream enrichment systems using the actor’s dataset output as a structured source.

***

### Step-by-Step: How to Use It

No coding needed. Here's how to run **Youtube User Channel Scraper** from start to finish:

1. **Open the actor on Apify** — visit [console.apify.com](https://console.apify.com) and search for Youtube User Channel Scraper.
2. **Enter your inputs** — fill `start_urls` with channel URLs and/or provide `ids` as a comma-separated list of Channel IDs.
3. **Configure proxy settings** — keep proxy support enabled in the run for better reliability at scale.
4. **Hit Run and watch the live log** — monitor progress while each channel is fetched.
5. **View results in the dataset tab** — records appear as each channel finishes.
6. **Export as JSON, CSV, or Excel** — download directly from Apify or pull via the Apify API.

The whole process takes under 5 minutes to set up.

***

### Integrations & Export Options

Once your data is collected, **Youtube User Channel Scraper** plugs directly into your existing workflow.

You can export results as **JSON, CSV, or Excel** from the Apify dataset tab. This is convenient for analysts working in spreadsheets and for marketers who want to import channel lists into their tools.

For automation, you can connect the actor to the rest of your stack using **API access** and **webhooks** via Apify’s platform capabilities, and use no-code options like **Zapier** or **Make**. For deeper details, refer to the Apify developer documentation at [apify.com/docs/api](https://apify.com/docs/api).

***

### Pricing & Free Trial

Youtube User Channel Scraper runs on the Apify platform, which offers a **free tier** — no credit card required to get started.

You can start with a small test run to validate the YouTube user channel scraper output fields (like subscriberCount, viewCount, and joinDate). For production scale, pricing depends on Apify platform usage—check Apify’s pricing page for the most up-to-date plan details.

Start for free at [apify.com](https://apify.com) and scale when you're ready.

***

### Reliability & Performance

| What We Handle | How |
|---|---|
| Rate limits and unstable fetches | Includes retries to improve success rate |
| Scraping consistency at scale | Uses proxy support for more reliable runs |
| Missing or incomplete channel metadata | Outputs available fields and uses `null` where data isn’t present |
| Multi-input convenience | Handles both `start_urls` and `ids` in a single run |

**Limitations:** The actor relies on publicly available channel page data and can’t access login-gated or non-public information. If a channel’s metadata isn’t available in the expected payload, some fields may be missing (`null`) even though the run continues.

For enterprise-scale runs, contact us to discuss custom configurations.

***

### Frequently Asked Questions

#### Is there a free plan or trial?

Yes. Apify offers a free tier that you can use to run Youtube User Channel Scraper for testing before scaling up.

#### Do I need to log in to Youtube to use this?

No. Youtube User Channel Scraper is designed to scrape publicly available YouTube channel information without requiring a user login.

#### How accurate is the data?

Accuracy depends on what the channel owner publishes publicly. The actor extracts the channel fields it finds in the page data and returns them in structured output, including numeric parsing for subscriberCount, videoCount, and viewCount.

#### How many results can I get per run?

You can provide as many `start_urls` and/or Channel IDs in the inputs as you need for your use case. The actor processes the provided list in sequence and pushes a result per successfully scraped channel.

#### How often is the data updated / how fresh is it?

Data freshness depends on when you run the actor. Each run pulls the current publicly available channel metadata at the time of execution.

#### Is this legal? Does it comply with GDPR / CCPA?

The actor works with **publicly available data** that can be viewed without login. It’s your responsibility to ensure your usage, storage, and any downstream processing comply with GDPR, CCPA, and applicable laws.

#### Can I export results to Google Sheets or Excel?

Yes. You can export from the Apify dataset tab as JSON, CSV, or Excel, and then import into Google Sheets or other spreadsheet tools.

#### Can I run this on a schedule automatically?

Yes. With Apify scheduling capabilities, you can run Youtube User Channel Scraper automatically on a recurring schedule.

#### Can I access this via API?

Yes. You can access actor runs and retrieve results programmatically using the Apify API. See [apify.com/docs/api](https://apify.com/docs/api) for details.

#### What happens if the actor hits an error?

If a channel fetch fails after the configured retry attempts, the actor logs the failure and continues processing other channels in the run. For successfully scraped channels, it pushes the extracted metadata into the dataset.

***

### Need Help or Have a Request?

Got a question about Youtube User Channel Scraper or want a new feature added? Reach out at <dataforleads@gmail.com>. We’re happy to help with integration questions and feature requests—ideas like adding more channel fields and a webhook on completion are especially welcome.

***

### Disclaimer & Responsible Use

*Youtube User Channel Scraper is the fastest, most reliable way to extract YouTube channel information from public profiles—start your free run today.*

This actor collects **publicly available data** and does not access private accounts, login-gated content, or password-protected pages. You are responsible for complying with GDPR, CCPA, platform Terms of Service, and applicable regulations for your use of the data. For data-removal requests, contact <dataforleads@gmail.com>. Use responsibly, ethically, and only for lawful purposes.

# Actor input Schema

## `ids` (type: `string`):

Comma-separated list of YouTube Channel IDs (e.g. UCyBD3P9YOFWNIMTuDzqeObg)

## `start_urls` (type: `array`):

List of YouTube channel URLs to scrape.

## Actor input object example

```json
{
  "ids": "UCyBD3P9YOFWNIMTuDzqeObg",
  "start_urls": [
    {
      "url": "https://www.youtube.com/@BBCNews"
    }
  ]
}
```

# 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 = {
    "ids": "UCyBD3P9YOFWNIMTuDzqeObg",
    "start_urls": [
        {
            "url": "https://www.youtube.com/@BBCNews"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("scraperoka/youtube-user-channel-scraper").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 = {
    "ids": "UCyBD3P9YOFWNIMTuDzqeObg",
    "start_urls": [{ "url": "https://www.youtube.com/@BBCNews" }],
}

# Run the Actor and wait for it to finish
run = client.actor("scraperoka/youtube-user-channel-scraper").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 '{
  "ids": "UCyBD3P9YOFWNIMTuDzqeObg",
  "start_urls": [
    {
      "url": "https://www.youtube.com/@BBCNews"
    }
  ]
}' |
apify call scraperoka/youtube-user-channel-scraper --silent --output-dataset

```

## MCP server setup

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

```

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/IhMK6NXYe5CEWOxfN/builds/fht0dtd2FkFA67QYc/openapi.json