# YouTube Channel Scraper — Stats & Recent Videos (`accountable_eel/youtube-channel-lookup`) Actor

Look up any YouTube channel by handle, custom URL, or channel ID: subscribers, total views, video count, country, join date, avatar/banner images, every About-tab link, and recent uploads. Reads the channel's live public pages, no API key needed. Charged once per channel found.

- **URL**: https://apify.com/accountable\_eel/youtube-channel-lookup.md
- **Developed by:** [Adrian Voss](https://apify.com/accountable_eel) (community)
- **Categories:** Social media, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 1,000 successful lookups

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/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## YouTube Channel Lookup: subscriber count, views & recent videos from $2/1k

You give this actor a list of YouTube channels (handles, custom URLs, `/channel/` IDs, whatever
you have) and for each one it returns subscriber count, total views, video count, country, join
date, avatar and banner images, every link listed in the About tab, and its most recent uploads
(video ID, title, view count, duration). Every field is read from the channel's own live public
pages at request time, in English regardless of where the request runs from. No third-party
database sits between you and the channel, and no API key is required.

### Who it's for

Anyone qualifying, monitoring, or reporting on YouTube creators without opening a browser tab per
channel: agencies building an influencer shortlist, marketers tracking a competitor's channel
growth, and analysts who need channel stats in a spreadsheet or a Clay/n8n workflow instead of a
YouTube tab. Pricing is pay-per-event and per-channel: a few tenths of a cent for a channel that
was actually found, and nothing for a miss, so a list that includes a typo'd handle or a channel
that got deleted costs you nothing extra. No seat license, no monthly minimum, no credit system to
decode.

### Why this one

- **Reads the channel's own live pages, not a stale database snapshot.** Every run fetches the
  channel's `/about` page (and its `/videos` tab, if you want recent uploads) fresh, so a channel
  that gained a million subscribers an hour ago shows the new number, not a cached one.
- **English output regardless of where the request runs.** The request pins `hl=en&gl=US`, so
  fields like subscriber count and join date come back in a consistent, parseable format instead
  of whatever language the request's network happens to geolocate to.
- **Never charged for a miss.** A handle that doesn't resolve to a channel, or a channel page that
  fails to load, still gets a row explaining why, and costs nothing. See "Price" below for the
  found-row rate.
- **Recent uploads are optional and free to skip.** "How many recent uploads to include" defaults
  to 10 but can be set to 0, which skips the extra request per channel entirely when you only need
  the channel-level stats.
- **No proxies to configure, no headless browser needed.** This is a plain HTTP fetch; YouTube's
  channel pages are fully server-rendered, so no JavaScript execution is required to read them.

### What you get

Every row starts with the same five fields, then the channel fields, then (if you asked for any)
one set of video fields per recent upload.

| Field | Type | Description |
|---|---|---|
| `query` | text | The channel you submitted, echoed back |
| `found` | boolean | `true` if the channel was found |
| `status` | text | `OK` on a match; `NOT_FOUND`, `BLOCKED`, `BAD_FORMAT`, or `REQUEST_FAILED` on a miss |
| `message` | text | Plain-English reason for a miss, only present when `found` is `false` |
| `scrapedAt` | ISO 8601 datetime | When the page was fetched |
| `channelId` | text | The channel's stable `UC...` ID |
| `handle` | text | The channel's `@handle`, if it has one |
| `title` | text | The channel's display name |
| `description` | text | The channel's About-tab description |
| `subscriberCount` | number | Subscriber count (YouTube's own rounded figure, e.g. 2,500,000 for "2.5M") |
| `videoCount` | number | Total videos published |
| `viewCount` | number | Total channel views, all-time |
| `country` | text | The channel's declared country, if set |
| `joinedDate` | date | When the channel joined YouTube (`YYYY-MM-DD`) |
| `avatarUrl` | link | The channel's avatar image, largest size available |
| `bannerUrl` | link | The channel's banner image, largest size available |
| `links` | array | Every external link in the About tab, as `{"title": "...", "url": "..."}` objects, with tracking redirects resolved to the real destination |
| `recentVideos` | array | The N most recent uploads, as `{"videoId", "videoTitle", "videoPublishedText", "videoViewCount", "videoDurationText"}` objects (grouped-row mode) |
| `videoId` | text | One recent video's ID (one-row-per-video mode) |
| `videoTitle` | text | That video's title (one-row-per-video mode) |
| `videoPublishedText` | text | How long ago it was published, as YouTube displays it (e.g. "3 days ago") |
| `videoViewCount` | number | That video's view count |
| `videoDurationText` | text | That video's duration, `MM:SS` or `H:MM:SS` |

Deselect any field in the Input tab's column picker to drop it from every row: `query`, `found`,
`status`, `message`, and `scrapedAt` always stay. Turn on "One row per video" to get one row per
recent upload instead of one grouped row per channel; you're still charged once per channel either
way.

### Price

$2 per 1,000 channels, plus a $0.00005 start fee. Misses (`found:false`) are never charged.

1,000 channels through this actor: **~$2** if every one is found, less if some aren't and less
again on a paid Apify plan. A channel that doesn't exist, or a request that gets blocked, is never
billed; you only pay for a channel you actually got data back for.

### How to use

1. **In the Apify Console.** Open the actor page and click **Start** — the `channels` field is already pre-filled with a working example. Results land in the run's dataset as soon as each item is found.
2. **Via the API.** Call it directly with a POST request — no Console needed once you have an API token:
   ```bash
   curl "https://api.apify.com/v2/acts/accountable_eel~youtube-channel-lookup/run-sync-get-dataset-items?token=<YOUR_TOKEN>" \
     -X POST \
     -H "Content-Type: application/json" \
     -d '{"channels":["@MrBeast"]}'
   ```
3. **On a schedule.** Save this actor as an Apify **Task** with the input you want, then add a **Schedule** (hourly, daily, weekly) so it runs on its own — no server of your own required.

1) Open the Input tab and paste your list of channels into "YouTube channels to look up": one
   per line, as a handle (`@MrBeast`), a full URL, or a `/channel/UC.../` ID.
2) Leave "Try it first" on for your first run; it caps the run at 5 channels so you can see the
   output shape before spending on the full list.
3) Set "How many recent uploads to include" to 0 if you only need channel-level stats; that skips
   the extra request per channel.
4) Turn on "One row per video" if you're loading results into a table you plan to filter or sort
   by individual upload; leave it off to keep each channel's recent uploads grouped in one row.
5) Turn "Try it first" off and press Start to run the full list.

Typical uses: building a shortlist of channels for an influencer campaign, tracking a competitor
channel's subscriber and view growth over time with a scheduled run, or pulling a channel's recent
upload cadence and view counts into a content-strategy spreadsheet.

### Input

```json
{
  "channels": [
    "@MrBeast"
  ]
}
```

One per line. Accepted formats: @MrBeast, https://www.youtube.com/@MrBeast, channel/UCX6OQ3DkcsbYNE6H8uQQuVA.

### Sample output

By default you get **one row per channel**, with recent uploads grouped into a `recentVideos`
array (turn on "One row per video" to get one row per upload instead):

| query | found | status | channelId | handle | title | description | subscriberCount | videoCount | viewCount | country | joinedDate | avatarUrl | bannerUrl | links | recentVideos | newVideoCount | videoId | videoTitle | videoPublishedText | videoViewCount | videoDurationText | isNew | firstSeenAt | scrapedAt |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| @MrBeast | true | OK | UCX6OQ3DkcsbYNE6H8uQQuVA | @MrBeast | MrBeast | SUBSCRIBE FOR A COOKIE!
New MrBeast or MrBeast Gaming video every single Saturday at noon eastern time!
Accomplishments:

- Raised $20,000,000 To Plant 20,000,000 Trees
- Removed 30,000,000 pounds of trash from the ocean
- Helped 2,000 people walk again
- Helped 1,000 blind people see
- Helped 1,000 deaf people hear
- Built wells in Africa
- Built and gave away 100 houses
- Adopted every dog in a shelter (twice)
- Given millions to charity
- Started my own snack company Feastables
- Started my own software company Viewstats
- Gave away a private island (twice)
- Gave away 1 million meals
- I counted to 100k
- Ran a marathon in the world's largest shoes
- Survived 50 hours in Antarctica
- Recreated Squid Game in real life
- Created the largest competition show with 1000 people (Beast Games)
- Gave $5,000,000 to one person
- Raised $40,000,000 To Bring Clean Water To Millions Of People
- Granted 100+ Dream Wishes for Kids Fighting Cancer
- Gave Away Another $5,000,000 On Beast Games S2
  | 516000000 | 1000 | 139730525794 | United States | 2012-02-19 | https://yt3.googleusercontent.com/nxYrc\_1\_2f77DoBadyxMTmv7ZpRZapHR5jbuYe7PlPd5cIRJxtNNEYyOC0ZsxaDyJJzXrnJiuDE=s900-c-k-c0x00ffffff-no-rj | https://yt3.googleusercontent.com/mHMO\_eEMp0dPvh0ADwXhPXNYb\_GnjSVsLI8biqF1CpxT8OPl7izhNQsDPD3JHhd5y5Mg9GrP=w2560-fcrop64=1,00005a57ffffa5a8-k-c0xffffffff-no-nd-rj | \[{"title":"$1,000,000 Contest","url":"https://www.themostdangerousgames.com/"},{"title":"Follow","url":"https://www.instagram.com/mrbeast/"},{"title":"Twitter","url":"https://twitter.com/MrBeast"},{"title":"Facebook","url":"https://facebook.com/mrbeast/"}] | \[{"videoId":"gTKS8SAwUzE","videoTitle":"I Survived The Most Extreme Places On Earth","videoPublishedText":"5 days ago","videoViewCount":75000000,"videoDurationText":"23:28","isNew":null,"firstSeenAt":null},{"videoId":"Qtl8lJwbd4g","videoTitle":"Escape 100 Cops, Win $500,000","videoPublishedText":"2 weeks ago","videoViewCount":99000000,"videoDurationText":"20:29","isNew":null,"firstSeenAt":null},{"videoId":"Af6i6ChAVTw","videoTitle":"Last To Leave Mansion, Keeps It","videoPublishedText":"1 month ago","videoViewCount":111000000,"videoDurationText":"57:51","isNew":null,"firstSeenAt":null},{"videoId":"lVylRtlPOIE","videoTitle":"I Granted 100 Kids Their Biggest Wish!","videoPublishedText":"1 month ago","videoViewCount":61000000,"videoDurationText":"14:35","isNew":null,"firstSeenAt":null},{"videoId":"iYlODtkyw\_I","videoTitle":"Survive 30 Days Chained To A Stranger, Win $250,000","videoPublishedText":"2 months ago","videoViewCount":94000000,"videoDurationText":"35:05","isNew":null,"firstSeenAt":null},{"videoId":"\_\_fmDj0ZJ1Q","videoTitle":"50 YouTube Legends Fight For $1,000,000","videoPublishedText":"2 months ago","videoViewCount":84000000,"videoDurationText":"32:08","isNew":null,"firstSeenAt":null},{"videoId":"GpQSUjNsNm0","videoTitle":"7 Days Stranded in The Arctic","videoPublishedText":"3 months ago","videoViewCount":126000000,"videoDurationText":"32:15","isNew":null,"firstSeenAt":null},{"videoId":"AaMdXZMvT3w","videoTitle":"Survive 30 Days On An Island With Your Ex, Win $250,000","videoPublishedText":"3 months ago","videoViewCount":106000000,"videoDurationText":"39:09","isNew":null,"firstSeenAt":null},{"videoId":"6Zy5VLcEbZc","videoTitle":"I Stranded 100 People In The Wilderness For $250,000","videoPublishedText":"4 months ago","videoViewCount":168000000,"videoDurationText":"37:00","isNew":null,"firstSeenAt":null},{"videoId":"zRtGL0-5rg4","videoTitle":"Last To Leave Grocery Store, Wins $250,000","videoPublishedText":"4 months ago","videoViewCount":192000000,"videoDurationText":"42:57","isNew":null,"firstSeenAt":null}] |  | <video id> | <video title> | <video published> | <video views> | <video duration> |  |  | 2026-09-11T07:00:42.145Z |

A handle that doesn't resolve to any channel gets a row with `found: false` and a `status`/
`message` explaining why, and is never charged.

### Monitoring: only new videos

Turn on **Only return videos that are new since the last run** and this actor becomes an upload alert. Each channel's recent uploads are checked against the video IDs your previous run already delivered, and anything you have seen is dropped from the list. Every channel is still looked up and billed once, as usual, and its stats row always comes back, so a quiet channel shows `newVideoCount: 0` instead of vanishing. Each run logs a count like `1 new of 10 fetched`.

The first run has nothing to compare against, so it returns every recent upload and remembers it. From the second run on you get only videos posted since.

To turn that into an alert:

1. Save your channel list as a task with the checkbox on, plus "One row per video".
2. Add a **Schedule** to that task, hourly or daily.
3. Add a webhook on **Run succeeded**, pointing at Slack, n8n, Make or Zapier.

Memory lives in a named key-value store, `youtube-channel-lookup-delta`, one record per channel, holding the last 5,000 video IDs per watchlist. Leave the checkbox off but fill in **Watchlist name** and every upload comes back stamped with `isNew` and `firstSeenAt`.

### Use it from Clay, n8n, Make, or an AI agent

This actor runs synchronously over plain HTTP — call it directly from a script, a workflow tool, or an AI agent, no Apify Console needed once you have an API token.

```bash
curl "https://api.apify.com/v2/acts/accountable_eel~youtube-channel-lookup/run-sync-get-dataset-items?token=<YOUR_TOKEN>" \
  -X POST \
  -H "Content-Type: application/json" \
  -d '{"channels":["@MrBeast"]}'
```

**n8n.** Add an HTTP Request node: Method `POST`, URL `https://api.apify.com/v2/acts/accountable_eel~youtube-channel-lookup/run-sync-get-dataset-items?token=<YOUR_TOKEN>`, Body Content Type `JSON`, JSON Body `{"channels":["@MrBeast"]}` (swap in an expression from an earlier node for a real value).

**Clay.** Add an "HTTP API" column: Method `POST`, URL `https://api.apify.com/v2/acts/accountable_eel~youtube-channel-lookup/run-sync-get-dataset-items?token=<YOUR_TOKEN>`, Body `{"channels":["{{channel}}"]}`, mapping the row's channel into the `channels` array.

**MCP.** In Claude, Cursor, or any MCP client with the Apify MCP server, ask for "YouTube Channel Scraper API | Apify" — the agent will find and run this actor.

### Tips

- Set "How many recent uploads to include" to 0 for a pure stats run (subscribers, views, country,
  join date): it skips the second request per channel and returns faster.
- A `BLOCKED` status means the request got a 403, 429, or 503 back; lowering "Max concurrency"
  sometimes helps on a large list. A channel that's genuinely gone will keep coming back
  `NOT_FOUND` regardless.
- `subscriberCount` and `videoViewCount` are YouTube's own rounded, abbreviated figures (e.g. "2.5M"
  becomes 2,500,000): they're the same numbers a visitor sees on the page, not an exact live
  count. `viewCount` (total channel views) is YouTube's exact, comma-formatted figure.
- Turn on "One row per video" when you're loading results into a table you plan to filter or sort
  by individual upload: it's easier to query `videoViewCount > 1000000` across many rows than to
  parse a nested `recentVideos` array per channel.
- `links` resolves YouTube's tracking-redirect wrapper down to the real destination URL, so you get
  `instagram.com/mrbeast`'s actual link, not a `youtube.com/redirect?...` URL.

### vs. alternatives

| | What it costs | What you get | Trade-off |
|---|---|---|---|
| **This actor** (`youtube-channel-lookup`) | $2 per 1,000 found channels (FREE tier, less on paid tiers), nothing for a miss | One row per channel: subscribers, views, country, join date, avatar/banner, About-tab links, and recent uploads, read live from the channel's own pages | No historical trend data. This is a live snapshot each time you run it, not a time series. Run it on a schedule if you want growth over time. |
| **streamers/youtube-channel-scraper** | $1.30 per 1,000 results | Channel stats plus deeper video-list pagination options | Broader video-history controls; this actor trades that for a simpler two-request design (stats + N recent uploads) and a lower per-channel floor when you only need the basics. |
| **Social Blade** (manual) | Free for basic stats, subscription for API/historical access | Historical subscriber/view charts, estimated earnings | Built for trend-watching one channel at a time in a browser; this actor is built for looking up a list of channels programmatically, not for historical charting. |
| Doing it yourself | Your time plus parsing YouTube's internal page JSON, handling redirects and blocked responses, and re-testing as YouTube's markup changes | The same data | This actor's parsing, miss-classification (blocked vs. not-found), and the two-request stats+videos design are the maintenance burden it absorbs. |

Prices for third-party tools are their published figures as of September 2026 and are not tracked
here; check the vendor before relying on the comparison.

### FAQ

**Why is a row empty, or why does `found` say `false`?**
Either the input doesn't resolve to any channel (`status: NOT_FOUND`), the request got blocked
(`status: BLOCKED`, usually HTTP 403/429/503), or the request failed after retries
(`status: REQUEST_FAILED`). Check the `message` column for the specific reason. None of these are
billed.

**Am I charged for a miss?**
No. `Actor.charge()` only fires when the channel actually resolves and its metadata is returned. A
blocked request or a bad handle produces a row (unless you turn on "Hide rows with no result") and
costs nothing.

**Is this a live check or a stored database?**
Live. Every run fetches the channel's current `/about` page (and `/videos` tab, if you asked for
recent uploads); there's no cached snapshot behind it. Run it on a schedule if you want to track a
channel's growth over time.

**Why are `subscriberCount` and `videoViewCount` rounded?**
Because that's what YouTube itself displays on the page ("2.5M subscribers"). This actor parses
that same abbreviated figure rather than calling an internal, unpublished endpoint for an exact
count. `viewCount` (total channel views) is YouTube's own exact, comma-formatted number, not
abbreviated.

**Do I need to configure proxies?**
No. The actor uses Apify's default proxy configuration out of the box; there's nothing to set up
unless you want to supply your own proxy group.

**Is this GDPR-relevant?**
The data returned is a channel's own public, self-published information (subscriber count, videos,
links the channel owner chose to list), not private personal data about an individual.

**What happens if a channel has no `@handle`?**
`handle` comes back `null`. Older channels that were never migrated to the handle system, or that
only ever had a `/channel/UC.../` URL, don't have one; every other field is unaffected.

**Can I schedule this to track a channel's growth over time?**
Yes. Set up an Apify Task with a schedule (daily, weekly, whatever cadence fits) and point it at
this actor with a saved input. Each run is a fresh fetch, so a scheduled task combined with your
own storage is how you'd build a subscriber-growth chart.

**Can an AI agent call this directly?**
Yes. It's registered on the Apify MCP server; an agent in Claude, Cursor, or another MCP client
can find and run it by name ("YouTube Channel Scraper API | Apify"), or you can call the REST
endpoint shown above from any script or workflow tool.

### Related actors

- [Podcast Lookup](https://apify.com/accountable_eel/podcast-lookup): the same show-plus-episodes
  pattern, for Apple Podcasts shows instead of YouTube channels.
- [Tech Stack Lookup](https://apify.com/accountable_eel/tech-stack-lookup): once you've qualified
  a creator's brand deals or sponsor page, check what platform their storefront runs on.

# Actor input Schema

## `channels` (type: `array`):

One per line. Accepted formats: @MrBeast, https://www.youtube.com/@MrBeast, channel/UCX6OQ3DkcsbYNE6H8uQQuVA. You're only charged for the ones we actually find — a miss costs nothing.

## `testRun` (type: `boolean`):

Turn this on to test your input on a small sample before running the full list. Turn it off to process everything.

## `onlyFound` (type: `boolean`):

Only keep rows where something was actually found. Misses are always free, whether or not you show them here.

## `includeKeywords` (type: `array`):

Optional. Only keep results that mention at least one of these words (e.g. a job title, a city, a product name). Leave empty to keep everything.

## `excludeKeywords` (type: `array`):

Optional. Drop any result that mentions one of these words. Leave empty to skip nothing.

## `maxResults` (type: `integer`):

Optional. Stop the run once this many results have been found — useful for a quick, cheap sample. Leave blank for no limit.

## `deltaMode` (type: `boolean`):

Turns this actor into an upload monitor. A video counts as new when its YouTube video ID has not been returned for that channel by a previous run of the same watchlist. Already-seen uploads are dropped from the list, so your Slack or n8n step only ever sees fresh videos. Each channel is still looked up and billed once, exactly as with this off, and its stats row always comes back (with an empty upload list when nothing was posted). The first run has nothing to compare against, so it returns every recent upload and remembers it. Only the uploads inside 'How many recent uploads to include' are compared, so keep that at 10 or more for channels that post several times a day.

## `deltaName` (type: `string`):

Leave empty and we derive one from your channel list, so two schedules watching different channels keep separate memories. Editing the list then starts a fresh watchlist that re-announces each channel's recent uploads once; type your own name to keep one memory across list edits. Naming a watchlist with the checkbox above off returns every upload but still stamps each one with 'Is this video new?' and 'First seen', so you can filter them yourself in Sheets, n8n or Make.

## `columns` (type: `array`):

Choose which pieces of information to include in each result row. All are included by default.

## `expandRows` (type: `boolean`):

When on, each video found gets its own row instead of being grouped under its channel. You're still only charged once per channel, no matter how many rows it produces.

## `includeRecentVideos` (type: `integer`):

Each channel's row includes its N most recent uploads (video ID, title, views, duration). Set to 0 to skip the extra request entirely and get channel stats only.

## `maxConcurrency` (type: `integer`):

Parallel requests. Keep conservative — this target has no browser fallback, so getting blocked costs more than slow-and-steady.

## `proxyConfiguration` (type: `object`):

Apify Proxy config. Residential recommended for anti-bot-sensitive targets.

## Actor input object example

```json
{
  "channels": [
    "@MrBeast"
  ],
  "testRun": false,
  "onlyFound": false,
  "includeKeywords": [],
  "excludeKeywords": [],
  "deltaMode": false,
  "deltaName": "",
  "columns": [
    "channelId",
    "handle",
    "title",
    "description",
    "subscriberCount",
    "videoCount",
    "viewCount",
    "country",
    "joinedDate",
    "avatarUrl",
    "bannerUrl",
    "links",
    "recentVideos",
    "newVideoCount",
    "videoId",
    "videoTitle",
    "videoPublishedText",
    "videoViewCount",
    "videoDurationText",
    "isNew",
    "firstSeenAt"
  ],
  "expandRows": false,
  "includeRecentVideos": 10,
  "maxConcurrency": 5,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# 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 = {
    "channels": [
        "@MrBeast"
    ],
    "includeKeywords": [],
    "excludeKeywords": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("accountable_eel/youtube-channel-lookup").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 = {
    "channels": ["@MrBeast"],
    "includeKeywords": [],
    "excludeKeywords": [],
}

# Run the Actor and wait for it to finish
run = client.actor("accountable_eel/youtube-channel-lookup").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 '{
  "channels": [
    "@MrBeast"
  ],
  "includeKeywords": [],
  "excludeKeywords": []
}' |
apify call accountable_eel/youtube-channel-lookup --silent --output-dataset

```

## MCP server setup

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

```

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/JjwKQzk8FxY1bfBOd/builds/UxjU0yhzuMQ2XbkCB/openapi.json