# YouTube Channel Scraper — Videos, Shorts & Search (`insight.solutions/youtube-channel-api`) Actor

Scrape any YouTube channel's uploads as data: one row per video with title, view count, duration, publish date and thumbnail, plus a profile row with subscriber count, exact total views and join date. Also searches YouTube for videos, channels or playlists. Residential proxy included. No API key.

- **URL**: https://apify.com/insight.solutions/youtube-channel-api.md
- **Developed by:** [Insight Solutions](https://apify.com/insight.solutions) (community)
- **Categories:** Videos, Social media, For creators
- **Features:** Limited permissions
- **Stats:** 1 total users, 0 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.60 / 1,000 result returneds

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?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

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

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## YouTube Channel Scraper — Videos, Shorts & Search

**Get a YouTube channel's uploads as data.** Give this Actor a handle — `@TED` — and get back one row per video: title, view count, duration, when it went up, the thumbnail, the link. Ahead of them comes one profile row for the channel itself: subscribers, exact lifetime views, the day it was created, the country, the description, the uploader's own links. Switch a field and you get the Shorts grid or the live-streams tab instead. Add a search query and you get YouTube search results in the same shape.

No API key. No login. No cookies to paste. No YouTube Data API quota. **$1.00 per 1,000 rows, residential proxy included**, channels that do not exist are free, and a run that returns nothing costs nothing at all.

### Try it in 30 seconds

**Input** — this is the Store prefill; paste it and run:

```json
{
  "channels": ["@TED"],
  "tab": "videos",
  "maxVideosPerChannel": 30,
  "includeChannelProfile": true
}
```

A handle, a channel URL, a `/channel/UC…` URL or a bare `UC…` ID — all four work, and so do the old `/c/` and `/user/` links.

**Output** — one row per video; the fields you will use most are `title`, `videoId`, `viewCount`, `publishedTimeText` and `durationSec` (full list under *Output reference*). Anything that could not be read comes back as a free diagnostic row (`ok: false`, `errorType`, `error`) instead of a charge.

**Price** — $1.00 per 1,000 rows on the FREE tier (+ $0.001 per run, charged only after the first result); volume tiers are Scale $0.80 and Business $0.60 per 1,000, and a handle that does not exist, an empty tab, a search that matched nothing, an entry the run never reached and a page YouTube blocked are all free. Pay-per-event, no API key, no browser, limited permissions — works over the Apify MCP server (`mcp.apify.com`) and with agentic (x402) payments.

**From code** — `client.actor("insight.solutions/youtube-channel-api").call(run_input={…})` with `apify-client`, or `POST https://api.apify.com/v2/acts/insight.solutions~youtube-channel-api/run-sync-get-dataset-items`.

### What comes back

```jsonc
{
  "ok": true,
  "rowType": "video",                // "video" | "channel" | "playlist" | "diagnostic"

  "input": "@TED",
  "tab": "videos",                   // channel mode
  "query": null,                     // search mode
  "position": 2,                     // 1-based, per channel or per query

  "videoId": "1r2fqbD0KZ4",
  "url": "https://www.youtube.com/watch?v=1r2fqbD0KZ4",
  "title": "The Secret to Deeper Conversations | TED Intersections",

  "channelId": "UCAuUUnT6oDeKwE6v1NGQxug",
  "channelName": "TED",
  "channelUrl": "https://www.youtube.com/channel/UCAuUUnT6oDeKwE6v1NGQxug",
  "handle": "@TED",

  "viewCount": 51000,                // expanded from "51K views" — approximate above 1,000
  "viewCountText": "51K views",      // the string YouTube actually rendered
  "publishedTimeText": "23 hours ago",
  "publishedAtApprox": "2026-09-08T13:00:00.000Z",
  "durationSec": 1687,
  "durationText": "28:07",

  "isLive": false,
  "isShort": false,
  "isUpcoming": false,
  "isVerified": true,                // the uploader's verification tick
  "thumbnailUrl": "https://i.ytimg.com/vi/1r2fqbD0KZ4/hq720_custom_3.jpg",
  "badges": [],

  "error": null,
  "errorType": null,
  "scrapedAt": "2026-09-09T12:00:00.000Z",
  "source": "youtube.com",
  "sourceUrl": "https://www.youtube.com/@TED/videos"
}
```

The channel row that comes first carries the same columns with the channel ones filled in:

```jsonc
{
  "ok": true,
  "rowType": "channel",
  "channelId": "UCAuUUnT6oDeKwE6v1NGQxug",
  "title": "TED",
  "handle": "@TED",
  "subscriberCount": 27800000,       // from "27.8M subscribers" — approximate, as YouTube publishes it
  "videoCount": 5800,                // exact, from the About panel ("5,800 videos")
  "viewCount": 3224922765,           // exact lifetime views — the one number YouTube does not round
  "joinedAt": "2006-12-06",          // a real date, not an approximation
  "country": "United States",
  "keywords": ["TED", "talks", "TED Conferences", "…"],
  "links": [{ "title": "TED.com", "url": "https://www.ted.com" }],
  "avatarUrl": "https://yt3.googleusercontent.com/…=s900-c-k-c0x00ffffff-no-rj",
  "bannerUrl": "https://yt3.googleusercontent.com/…=w2560-fcrop64=1,00005a57ffffa5a8"
}
```

Every row in the dataset has the same keys, so it loads into a table without a schema fight.

### Use cases

- **Competitor and category tracking** — every upload from a set of channels, with views and dates, refreshed on a schedule. Diff two runs and you have "what they published this week and how it performed".
- **Content research and topic mining** — a channel's whole back catalogue as titles plus view counts is the cheapest signal there is for what an audience actually watches.
- **Creator discovery and outreach lists** — search `channels` for a niche and get handle, subscriber count and description snippet per row, ready to score and filter.
- **Sponsorship and influencer vetting** — subscriber count, upload cadence, view distribution and the join date, in one place, for a list of candidates.
- **Trend monitoring** — a video search with `uploadDate: "week"` on a schedule surfaces what is new on a topic before it is obvious.
- **Feeding an index or a RAG pipeline** — video IDs and titles from a channel, handed to the [YouTube Transcript API](https://apify.com/insight.solutions/youtube-transcript-api) for the words.

### How it works, and why it keeps working

YouTube's public Data API needs a Google Cloud project and an API key, spends quota per call, and caps a channel walk at what your quota allows. This Actor reads the same pages the browser reads, through the private InnerTube endpoints the YouTube web client itself calls.

| Step | Request | What it gets |
|---|---|---|
| 1 | `navigation/resolve_url` with the handle | The `UC…` channel ID. **Skipped entirely** when you pass a `UC…` ID |
| 2 | `browse` with `{browseId, params}` | The channel document: profile header, and the first thirty uploads of the chosen tab |
| 2b | The public channel page, only if step 2 returns no grid | The same tree from `ytInitialData`; survives some API-level refusals |
| 3 | `browse` with the About continuation | Exact view count, join date, country, links — only when `includeChannelProfile` is on |
| 4… | `browse` with each next token | Thirty more uploads each time, until your cap, your budget, or the end of the grid |
| S | `search` with `{query, params}` | Twenty results, plus the token for the page after |

Two details in there are the difference between rows and empty output:

- **The channel grid is `lockupViewModel`, not `gridVideoRenderer`.** YouTube moved the channel tabs to view models; scrapers written against the old renderer return nothing on a modern channel page. Shorts use a third shape again (`shortsLockupViewModel`) with no duration and no date in it at all.
- **A metadata row is a bag, not a tuple.** "51K views" and "23 hours ago" arrive as an unordered list of parts, and a collaboration quietly adds a "TED and 2 more" part in front of them. This Actor classifies each part by what it says, so a collaboration does not become the view count.

Underneath: **Apify residential proxy**, one pinned session per parallel worker. When YouTube refuses an exit IP — HTTP 429, HTTP 403, an empty body, or a body that is not JSON — that session is retired and **the same page is asked for once more from a different residential address**. Retrying on an address that was just refused only deepens the block, so it is never done. If the second address is refused too, the walk stops, **keeps every row it already delivered**, and files one free `blocked` row saying where it stopped.

Pages of the same channel are spaced 250–600 ms apart. Nothing forces that; it is the difference between reading a channel and hammering one.

### How it compares

- **No API key, no quota.** The YouTube Data API needs a Google Cloud project and spends quota per call. This needs a handle.
- **The exact numbers, where exact numbers exist.** Most scrapers report "27.8M subscribers" and stop. This one also fetches the About panel, so `viewCount` is the real lifetime figure, `videoCount` is "5,800" rather than "5.8K", and `joinedAt` is a date rather than a guess.
- **One shape for channels and for search.** The same 44 columns whether the row is a video from a channel tab, a video from a search, a channel result or a playlist. Null where a field does not apply, never a missing key.
- **Residential proxy is in the price.** YouTube blocks datacenter IPs wholesale, so a channel scraper without residential egress does not work from a cloud host at all. There is no separate proxy line on your bill for this Actor.
- **Failures are free and legible.** A handle that does not exist, an empty tab, a search with no matches or a block produce a diagnostic row with an `errorType` you can branch on — and no charge. A run whose entries were all usable but produced nothing — a handle that does not exist, an empty tab, a search with no matches — finishes **SUCCEEDED with zero results**, a status message that says so, and a free diagnostic row per entry telling you why; nothing is charged, start fee included. A run finishes **FAILED** only when there was nothing usable to attempt, or the Actor itself hit an error.
- **A partial walk is kept, not thrown away.** Hit `maxRunSecs` or your charge ceiling on page 8 and you keep pages 1–7.

### Input reference

| Field | Type | Default | What it does |
|---|---|---|---|
| `channels` | array of strings | prefilled with `@TED` | Handles, channel URLs, `/c/` and `/user/` URLs, or bare `UC…` IDs. Duplicates are read, and billed, once |
| `tab` | `videos` | `shorts` | `live` | `videos` | Which upload grid to read, newest first |
| `maxVideosPerChannel` | integer | `100` | Videos per channel. YouTube serves thirty at a time (about fifty for Shorts), so the walk stops on the page that reaches your number. `0` = the whole tab |
| `includeChannelProfile` | boolean | `true` | Write the `channel` row. Costs one extra request and bills as one row |
| `searchQueries` | array of strings | `[]` | Optional. One entry per YouTube search. Both modes can run in one job |
| `searchType` | `videos` | `channels` | `playlists` | `videos` | Which of YouTube's own result filters to apply |
| `uploadDate` | `any` | `hour` | `today` | `week` | `month` | `year` | `any` | YouTube's upload-date filter. Applies to a video search only, exactly as on the site |
| `maxResultsPerQuery` | integer | `50` | Results per query. YouTube serves twenty per page |
| `maxConcurrency` | integer | `3` | Channels and queries in parallel. Each worker keeps its own proxy session. Pages within one target cannot be parallelised |
| `maxRunSecs` | integer | `240` | Whole-run wall-clock budget. When it runs out the Actor keeps what it has and files a free diagnostic row for each entry it never reached |
| `proxyConfiguration` | object | Apify residential | Leave it alone. Clearing it sends requests from the run's datacenter address, which YouTube will block |

### Output reference

Every row carries the same keys. `ok: true` is a result; `ok: false` is a free diagnostic row.

| Field | What it is |
|---|---|
| `rowType` | `video`, `channel`, `playlist` or `diagnostic` |
| `input`, `query`, `tab`, `position` | Which entry produced this row, and where it fell in that entry's order |
| `videoId`, `playlistId`, `channelId`, `url` | The IDs, and the canonical public link |
| `title`, `channelName`, `channelUrl`, `handle` | What it is called and whose it is |
| `description`, `descriptionSnippet`, `keywords`, `links` | The channel's own text (channel rows) and the snippet YouTube shows under a search result |
| `viewCount`, `viewCountText` | Views as an integer, and as YouTube rendered them |
| `subscriberCount`, `subscriberCountText`, `videoCount`, `videoCountText` | Channel and playlist sizes, both ways |
| `publishedTimeText`, `publishedAtApprox` | When it went up, as YouTube says it and as a sortable instant |
| `joinedAt`, `country` | Channel rows: the day the channel was created, and the country the uploader declared |
| `durationSec`, `durationText` | Video length, both ways |
| `isLive`, `isShort`, `isUpcoming`, `isVerified` | Live right now; a Short; a scheduled premiere; the channel's verification tick |
| `thumbnailUrl`, `avatarUrl`, `bannerUrl`, `badges` | The images, and the labels YouTube prints on the result |
| `estimatedResults` | Search rows: how many results YouTube claims for the query |
| `ok`, `error`, `errorType` | Whether this row is a result, and if not, why not |
| `scrapedAt`, `source`, `sourceUrl` | When, and from which public page |

`errorType` on a diagnostic row is one of:

| Value | Meaning | Charged? |
|---|---|---|
| `not-found` | No such handle or channel — YouTube said so | No |
| `no-results` | The tab is empty, or the search matched nothing of the requested type | No |
| `unavailable` | The channel could not be read at all: terminated, region-blocked, or a shape we do not recognise | No |
| `blocked` | YouTube refused our requests from two different residential exits. Rows already returned for that channel are kept | No |
| `invalid-input` | The entry was not a channel reference or a usable query | No |
| `timeout` | The run's `maxRunSecs` budget ran out before this entry was reached | No |

### Pricing

**$1.00 per 1,000 rows.** Pay-per-event, with the residential proxy already inside that number — there is no separate proxy line on your bill for this Actor.

| Event | What triggers it | FREE | Starter | Scale | Business |
|---|---|---|---|---|---|
| **Result returned** *(primary)* | One video, channel or playlist row written to your dataset | $0.001 | $0.001 | $0.0008 | $0.0006 |
| Run started | Once per run, after the first result | $0.001 | $0.001 | $0.001 | $0.001 |

**Worked example.** 20 channels at 100 videos each, with profile rows, of which 2 handles no longer exist:

- 18 channels × (100 videos + 1 profile row) × $0.001 = **$1.818**
- 1 run start = **$0.001**
- 2 handles that do not exist = **$0.00**
- **Total: $1.82**

What you are never charged for: a handle that does not exist, an empty tab, a search that matched nothing, an entry that was not a channel, an entry the run never reached before `maxRunSecs`, or a page YouTube blocked. If a whole run comes back empty it finishes SUCCEEDED with zero results and a status message that says why ("0 results. N diagnostic row(s) explain why …"), and bills **nothing at all**, start fee included.

Set `ACTOR_MAX_TOTAL_CHARGE_USD` on a run and the Actor stops walking once the ceiling is in sight, rather than handing you rows it cannot bill or billing you for rows it cannot hand over. It finishes SUCCEEDED with the ceiling named in its status message, and everything already delivered is yours.

### Limits, and the ones that might bite

**View counts on a channel grid are approximate; on a search result they are exact.** That is YouTube's doing, not ours: the channel grid renders "51K views" and publishes nothing more precise, while a search result carries "1,117,768 views" next to its abbreviated form. Both arrive in `viewCount`, and `viewCountText` always shows which one you got. Below 1,000 both are exact.

**Subscriber counts are always approximate.** "27.8M subscribers" is the entire truth available over any interface, this Actor's included. The About panel does not publish an exact one either. `viewCount` and `videoCount` on a channel row *are* exact, because the About panel publishes those.

**Upload dates are relative.** A grid publishes "23 hours ago" and a search result "4 years ago"; there is no absolute timestamp behind either. `publishedAtApprox` resolves the phrase against `scrapedAt`, stepping the calendar for months and years rather than multiplying by an average length — but "1 year ago" still covers twelve months of possible dates. Use it to sort and bucket, not to timestamp an event. `joinedAt` on a channel row is the exception: that one is a real date.

**Shorts carry less.** The Shorts grid publishes a title and a view count and nothing else — no duration, no date. Those columns are null, rather than guessed.

**Search will not page forever.** `estimatedResults` says two million; YouTube stops handing out continuation tokens long before that, usually a few hundred results in. Ask for what you will actually read.

**No members-only or private content.** This Actor does not log in, does not accept cookies and does not take a session token, and it never will — that is a deliberate line, not a missing feature. Unlisted videos never appear in a channel tab, and neither do videos removed for the region the proxy exits from.

**One tab per run.** `tab` picks one of `videos`, `shorts` and `live`. Run the Actor three times, or three schedules, if you want all three — they are three different grids and three different walks.

**YouTube may change the format.** This reads private endpoints that YouTube changes without notice — that is true of every tool that reads YouTube channels, including the ones that do not say so. When a shape changes, rows stop arriving and you get free `blocked` or `unavailable` diagnostic rows rather than quietly wrong data, and a run that returns nothing bills nothing.

**Rate and reliability.** Requests go out through residential addresses with per-worker sessions, one rotation per block, and a 250–600 ms pause between pages of the same target. Three targets in parallel is the default because it is where throughput and block rate balance; raising `maxConcurrency` speeds a long list up and makes blocks more likely.

### Use it from an AI agent, or from code

One JSON object in, one flat array out — the shape agent runtimes want. The Actor runs with **limited permissions**, uses **pay-per-event** pricing and never enters Standby, so it works over the Apify MCP server and with x402 agentic payments. The **Integrations** tab pushes results to Slack, a webhook, Zapier, Make, Google Sheets, Snowflake or BigQuery.

```bash
curl -X POST "https://api.apify.com/v2/acts/insight.solutions~youtube-channel-api/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"channels":["@TED","@NASA"],"tab":"videos","maxVideosPerChannel":50}'
```

```python
## pip install apify-client
from apify_client import ApifyClient

client = ApifyClient("<APIFY_TOKEN>")
run = client.actor("insight.solutions/youtube-channel-api").call(run_input={
    "channels": ["@TED"],
    "tab": "videos",
    "maxVideosPerChannel": 200,
    "includeChannelProfile": True,
    "searchQueries": ["machine learning tutorial"],
    "searchType": "videos",
    "uploadDate": "month",
    "maxResultsPerQuery": 40,
})

for row in client.dataset(run["defaultDatasetId"]).iterate_items():
    if not row.get("ok"):
        print("skipped:", row["input"], row["errorType"])
    elif row["rowType"] == "channel":
        print(f'{row["title"]}: {row["subscriberCount"]:,} subs, {row["viewCount"]:,} views since {row["joinedAt"]}')
    else:
        print(f'{row["position"]:>3}. {row["title"][:60]} — {row["viewCountText"]}, {row["publishedTimeText"]}')
```

### FAQ

**How do I get every video a channel ever published?**
Set `maxVideosPerChannel: 0` and raise `maxRunSecs`. A channel with 5,800 uploads is about 195 sequential page requests with a pause between each — plan for minutes, not seconds, and bound it with `ACTOR_MAX_TOTAL_CHARGE_USD` if you are not sure what you are asking for.

**Why is the profile row charged?**
Because it is a row, and it costs an extra request: the exact view count, join date, country and links live in the About panel, which is a separate continuation. Turn `includeChannelProfile` off and you pay for videos only.

**Does the order match the channel page?**
Yes — newest first, which is YouTube's default for all three tabs. `position` records the order this run read them in.

**Can I get a channel's playlists, community posts or podcasts?**
Not yet. `playlist` rows come from a playlist *search*. The channel's own Playlists, Posts and Podcasts tabs are different shapes again.

**Why do some rows have no duration?**
They are Shorts, or a stream that was live when it was read. YouTube publishes no duration for either.

**Do I need my own proxy or an API key?**
Neither. Apify residential proxy is configured by default and its cost is inside the per-row price. No Google Cloud project, no YouTube Data API key, no quota.

**What happens if one channel fails?**
The others still run. The failed one produces a free diagnostic row and the run finishes `SUCCEEDED`. If *every* entry fails, the run still finishes `SUCCEEDED`, with zero results, a status message that says so and nothing billed at all. Only an input with no usable channel or query in it finishes `FAILED`.

**Is the data fresh?**
Live. Every run reads YouTube at that moment; nothing is cached.

### Legal and data-protection notes

- **Public pages only.** Every source is a public channel page or a public search results page. The Actor never logs in, never accepts cookies or session tokens, never takes an API key belonging to anyone else, and never touches private, unlisted or members-only content.
- **Channel data can be personal data.** A channel row carries a name, a handle, an avatar and sometimes a country, and for an individual creator that is personal data about an identifiable person under the GDPR and similar laws. You are the controller of whatever you collect: have a lawful basis, keep only what you need, honour deletion requests, and remember that a channel deleted on YouTube stays in your dataset until you remove it.
- **Titles and descriptions are their authors' words.** Republishing them, or training on them, is your call and your responsibility, subject to YouTube's terms and to the law where you operate. Aggregation, ranking and analysis are the ordinary uses and are what this is built for.
- **Not affiliated with YouTube, Google LLC, or with any channel or creator whose content you retrieve.** All product names and trademarks belong to their respective owners and are used only to describe which public endpoints this Actor reads.

### Our other Actors

Every Insight Solutions Actor is pay-per-result with no browser, no login and no API key, and every one of them returns free diagnostic rows instead of billing for failures. Prices are per 1,000 results.

**Video, audio & social**

- [YouTube Transcript Scraper & API — Captions to Text, SRT & VTT](https://apify.com/insight.solutions/youtube-transcript-api) — captions as timed segments, text, SRT or VTT, with language fallback and translation.
- [YouTube Comments Scraper — Comments & Replies with Likes](https://apify.com/insight.solutions/youtube-comments-api) — comments and replies with likes, pinned and hearted flags, newest or top sort.
- [Podcast Search, Episodes & Charts API](https://apify.com/insight.solutions/podcast-api) — Apple Podcasts search, charts and full episode feeds.
- [Bluesky Scraper](https://apify.com/insight.solutions/bluesky-scraper) — profiles, posts, followers and follows from the public AT Protocol API.
- [Telegram Channel Scraper — Posts, Views & Stats](https://apify.com/insight.solutions/telegram-channel-scraper) — posts, views and channel stats from public Telegram channels.
- [Substack Scraper](https://apify.com/insight.solutions/substack-scraper) — posts with full free text, comments and publication profiles.
- [Sponsor & Advertiser Finder — YouTube, Podcasts & Newsletters](https://apify.com/insight.solutions/sponsorship-intelligence-api) — which brands sponsor which YouTube channels, podcasts and Substack newsletters, with promo codes, offers and sponsor links, company-level only.
- [Google Ads Transparency Center API — Advertisers & Ads](https://apify.com/insight.solutions/google-ads-transparency-api) — every ad a verified advertiser runs on Google, from the Ads Transparency Center, by brand name, AR id or domain: format, first and last shown, days shown and preview links, individuals excluded.
- [Hacker News API](https://apify.com/insight.solutions/hacker-news-api) — stories, comments, users, front page and a structured "Who is hiring?" parser from the official HN APIs.
- [GitHub Trending & Repo Scraper — Stars, Releases & Search](https://apify.com/insight.solutions/github-repos-api) — repository facts, trending lists, releases and search, no token needed for small runs.
- [Discourse Forum Scraper — Topics, Posts & Categories](https://apify.com/insight.solutions/discourse-forum-api) — topics, posts and categories from any Discourse community via its own JSON endpoints, usernames only.

**News, documents & the web**

- [Google News Scraper — Search, Topics & Real Article URLs](https://apify.com/insight.solutions/google-news-api) — news search and topic feeds with the publisher's real URL decoded.
- [Website to Markdown Converter & API — for LLMs & RAG](https://apify.com/insight.solutions/website-content-extractor) — any site as clean Markdown, text and heading-aware chunks.
- [WordPress Scraper — Posts & Pages from Any WP Site, No Login](https://apify.com/insight.solutions/wordpress-posts-api) — posts and pages from any WordPress site as clean text or Markdown, with categories, tags and images.
- [Website Metadata Extractor — Schema.org, Open Graph & JSON-LD](https://apify.com/insight.solutions/website-metadata-api) — any URL's meta tags, Open Graph, Twitter cards, hreflang, feeds, JSON-LD and microdata, with normalised Product, Article, Event and FAQ entities.
- [Subdomain Finder — Certificate Logs & DNS, No API Key](https://apify.com/insight.solutions/subdomain-finder-api) — every subdomain of a domain from certificate-transparency logs, resolved over DNS, with an optional live HTTP check.
- [Internet Archive Scraper & API — Search, Metadata & Files](https://apify.com/insight.solutions/internet-archive-api) — archive.org search, item metadata, files and reviews.
- [Wayback Machine Scraper — Archived URLs, Snapshots & Diffs](https://apify.com/insight.solutions/wayback-toolkit) — archived URL inventories, snapshots and text diffs between dates.
- [Website Technology Detector — Tech Stack Checker & Lookup](https://apify.com/insight.solutions/website-tech-detector) — the tech stack behind any site, with the evidence for each detection.
- [Domain Lookup API — DNS, WHOIS/RDAP, SSL & Providers](https://apify.com/insight.solutions/domain-intelligence-api) — DNS, RDAP registration, TLS certificate and HTTP facts in one row per domain.
- [SEO Audit Tool — Sitemap Crawl & On-Page Checker](https://apify.com/insight.solutions/seo-page-audit) — sitemap crawl with on-page checks, structured data and broken-link reports.
- [Keyword Suggestions Tool & API — Google, Bing & Amazon](https://apify.com/insight.solutions/keyword-suggestions-api) — Google, YouTube, Bing, Amazon and eBay autocomplete with alphabet and question expansions.
- [Website Contact Scraper — Email, Phone & Socials Extractor](https://apify.com/insight.solutions/website-contact-extractor) — emails, phone numbers and social profiles from any list of websites.
- [Company Email Finder — Published Emails & Phones by Name](https://apify.com/insight.solutions/company-contact-finder) — company names in, each one's verified website with its business emails, phone numbers and social profiles out.
- [Web Search Results API](https://apify.com/insight.solutions/web-search-api) — Bing and DuckDuckGo organic results with snippets, no key, no browser.
- [Company Enrichment API](https://apify.com/insight.solutions/company-enrichment-api) — a domain in, a company profile out: firmographics, contacts, tech stack, DNS and hiring signal.
- [Company Dossier API](https://apify.com/insight.solutions/company-dossier-api) — one company in, twelve sections out: profile, tech, contacts, DNS, open roles, news, SEC filings, federal awards, recalls, YC batch and apps.
- [Press Release Scraper — GlobeNewswire, PR Newswire & More](https://apify.com/insight.solutions/press-releases-api) — GlobeNewswire and PR Newswire releases plus any newsroom feed, by keyword, company, ticker or subject.
- [Federal Register API](https://apify.com/insight.solutions/federal-register-api) — rules, proposed rules, notices and the Public Inspection desk with dockets, comment deadlines and CFR references.
- [Academic Papers Search API](https://apify.com/insight.solutions/academic-papers-api) — OpenAlex, Crossref, arXiv and PubMed in one row per paper: abstract, citations, open-access PDF, authors and venue.
- [RSS & Atom Feed Monitor](https://apify.com/insight.solutions/rss-feed-monitor) — any RSS, Atom or JSON feed (or an OPML file) in, only the new items out, with keyword filters and a webhook.
- [Website Change Monitor](https://apify.com/insight.solutions/website-change-monitor) — watch any pages, diff the text between runs, get change rows with added/removed lines, keyword alerts and a webhook.
- [Wikipedia & Wikidata API](https://apify.com/insight.solutions/wikipedia-api) — article text, search, daily pageviews and Wikidata entity facts, any language edition.

**Business, finance & jobs**

- [Congress Trades Tracker API — STOCK Act PTRs + SEC Form 4](https://apify.com/insight.solutions/congress-insider-trades-api) — STOCK Act periodic transaction reports and SEC Form 4 insider trades in one schema.
- [Federal Contracts, Grants & Lobbying API](https://apify.com/insight.solutions/federal-contracts-grants-api) — SAM.gov opportunities, USAspending awards, Grants.gov notices and Senate lobbying filings in one schema.
- [SEC EDGAR API](https://apify.com/insight.solutions/sec-edgar-api) — filings, XBRL financials and full-text search by ticker or CIK.
- [Litigation Signals API — Lawsuits, Settlements & Investigations](https://apify.com/insight.solutions/litigation-signals-api) — lawsuits, settlements and investigations per public company from SEC 10-K, 10-Q and 8-K disclosures, press wires and SEC, FTC and DOJ notices, company-level only.
- [Startup Funding Rounds API — SEC Form D, Wires & News](https://apify.com/insight.solutions/funding-signals-api) — who just raised money: one row per funding round from SEC Form D filings, press wires and Google News, with amount, round, investors, industry and state, company-level only.
- [Clinical Trials & FDA API](https://apify.com/insight.solutions/clinical-trials-fda-api) — ClinicalTrials.gov studies plus openFDA recalls, labels, approvals, 510(k)s and adverse-event reports.
- [Product & Vehicle Recalls API](https://apify.com/insight.solutions/product-recalls-api) — CPSC, NHTSA, FDA and USDA recalls, vehicle complaints and ratings, plus a VIN decoder.
- [YC Companies List & Directory Scraper — Batches & Founders](https://apify.com/insight.solutions/yc-companies-directory) — the YC directory with founders and social links, filterable by batch, industry and hiring status.
- [Job Scraper for Greenhouse, Lever, Ashby & 10+ ATS Career Sites](https://apify.com/insight.solutions/ats-jobs-api) — jobs straight from Greenhouse, Lever, Ashby, Workable and 10+ other ATS career sites.
- [Workday Jobs Scraper — All Postings from Any Workday Site](https://apify.com/insight.solutions/workday-jobs-api) — every posting on any Workday career site, with facets, search, posted dates and full descriptions.
- [Job Postings Monitor — New & Closed Roles, Hiring Alerts](https://apify.com/insight.solutions/job-postings-monitor) — new, closed and changed postings on the career sites you watch.
- [Hiring Signals API — Open Roles & Hiring Surge by Company](https://apify.com/insight.solutions/hiring-signals-api) — one row per company per run: open roles, what opened and closed, department and seniority breakdowns, and a hiring-surge flag.
- [Careers Page Scraper — Open Roles from Any Company's Site](https://apify.com/insight.solutions/careers-page-jobs-api) — open roles from any company's own careers site: domain in, the platform recognised (Eightfold, Phenom, Jibe, iCIMS, Google, Amazon, 14 ATSs) or the site's structured data read, one row per job.
- [Wellfound Jobs Scraper — Startup Roles, Salary & Equity](https://apify.com/insight.solutions/wellfound-jobs-api) — startup jobs from Wellfound's role listings, by role and city or remote: salary and equity as shown, remote policy, experience, and each startup's size, stage and badges, no recruiter contacts.
- [Remote Jobs API](https://apify.com/insight.solutions/remote-jobs-api) — RemoteOK, Remotive, We Work Remotely, Himalayas, Jobicy and more in one schema, deduplicated.
- [Shopify Products Scraper — Catalogue, Prices & Stock](https://apify.com/insight.solutions/shopify-products-api) — any Shopify store's catalogue, variants, prices and stock signals.
- [WooCommerce Products Scraper — Prices, Variants & Stock](https://apify.com/insight.solutions/woocommerce-products-api) — any WooCommerce store's catalogue, prices, variants and stock through its public Store API.
- [Price Tracker & Monitor — Any Retailer's Prices & Stock](https://apify.com/insight.solutions/price-tracker-api) — price, stock, list price and discount from any product URL, read from the page's structured data, with price-drop and restock rows between runs.
- [Rightmove Scraper — UK Listings for Sale & Rent by Area](https://apify.com/insight.solutions/rightmove-property-api) — UK property for sale and to rent by area from Rightmove's own search API: price, bedrooms, type, tenure, size, coordinates, photos, status and the agent branch, one row per listing.
- [Shopify App Store Scraper — Apps, Pricing, Ratings & Reviews](https://apify.com/insight.solutions/shopify-app-store-api) — Shopify App Store listings by category, collection or developer: pricing plans, ratings and merchant reviews.
- [Luma Events Scraper — Events by City, Category & Calendar](https://apify.com/insight.solutions/luma-events-api) — upcoming Luma events by city, category or calendar: dates, venue, price, capacity and organiser calendar, no host names.
- [Eventbrite Scraper — Events by City, Category & Organizers](https://apify.com/insight.solutions/eventbrite-events-api) — upcoming Eventbrite events by city, category, online or organiser, with the organising companies behind them: dates, venue, price, ticket status, followers and website, no browser, individuals never named.
- [Meetup Scraper — Upcoming Events & Group Stats](https://apify.com/insight.solutions/meetup-events-api) — upcoming events of the Meetup groups you name, and the groups themselves: dates, venue, RSVPs, fee, member count, topics and ratings, no member data.
- [Shopify Store Monitor](https://apify.com/insight.solutions/shopify-store-monitor) — price drops, sales, restocks, sell-outs and new products on any Shopify store, one row per change.
- [Shopify Store Finder — Discover & Verify Stores by Niche](https://apify.com/insight.solutions/shopify-store-finder) — Shopify stores by niche and country, each verified on its own storefront, with product count, currency, country, price range and sample products.
- [Public Tenders API](https://apify.com/insight.solutions/public-tenders-api) — EU TED, UK Find a Tender and Contracts Finder notices by keyword, CPV code, country, stage and deadline.
- [Nonprofit Lookup & IRS 990 API — EIN, Financials, NTEE](https://apify.com/insight.solutions/nonprofit-990-api) — search US nonprofits and get EIN, NTEE code and multi-year Form 990 financials.
- [OpenStreetMap Places API](https://apify.com/insight.solutions/osm-places-api) — businesses and points of interest by category and area from OpenStreetMap: name, address, coordinates, website, phone, opening hours.

**Apps & games**

- [App Store & Google Play Reviews Scraper — Ratings & Replies](https://apify.com/insight.solutions/app-reviews-api) — reviews from both stores with ratings, versions and developer replies.
- [App Store Top Charts & App Search API](https://apify.com/insight.solutions/app-charts-api) — Apple top charts by country and genre, plus app search and details.
- [App Store Keyword Rank Tracker](https://apify.com/insight.solutions/app-store-keyword-rank-tracker) — where any app ranks for any keyword on the App Store and Google Play, with rank changes and ASO suggestions.
- [Steam Reviews Scraper — Reviews & Game Details](https://apify.com/insight.solutions/steam-reviews-api) — Steam reviews with playtime, helpfulness and game details.
- [Steam Game Data API](https://apify.com/insight.solutions/steam-store-stats-api) — prices, tags, review scores, live player counts and top charts.
- [Sports Scores & Schedules API](https://apify.com/insight.solutions/sports-scores-api) — scores, schedules, standings, teams and headlines for the NFL, NBA, MLB, NHL, soccer and more, no key.
- [App Store Monitor](https://apify.com/insight.solutions/app-store-monitor) — App Store and Google Play listings watched between runs: new versions with release notes, price, rating and listing changes, one row per change.

# Actor input Schema

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

One entry per channel. A handle (`@TED`), a channel URL (`https://www.youtube.com/@TED`, with or without `/videos` on the end), a `/channel/UC…` URL, a legacy `/c/` or `/user/` URL, or a bare `UC…` channel ID. A bare word is read as a handle. `UC…` IDs skip the lookup request; everything else costs one extra request to resolve. Duplicates are read, and billed, once.

## `tab` (type: `string`):

Which of the channel's three video tabs to read, newest first. `videos` is the ordinary upload grid. `shorts` is the Shorts grid — those rows carry a view count and a title but no duration and no date, because YouTube publishes none for a Short. `live` is the past-and-current streams tab, where the dates read "Streamed 4 months ago".

## `maxVideosPerChannel` (type: `integer`):

How many uploads to return for each channel. YouTube serves the grid thirty at a time (about fifty for Shorts), so the walk stops on the page that reaches your number — you may get a few fewer than a round figure if the channel runs out of uploads first. Set 0 for the whole tab, which on a channel with thousands of uploads means a run bounded only by your time and charge budgets.

## `includeChannelProfile` (type: `boolean`):

Write one `channel` row per channel before its videos: subscriber count, video count, exact lifetime view count, join date, country, description, keywords, avatar, banner and the uploader's own links. It costs one extra request — the About panel is a separate continuation — and it bills as one result row.

## `searchType` (type: `string`):

Which of YouTube's own result filters to apply. `videos` returns video rows, `channels` returns channel rows (title, handle, subscriber count, description snippet — YouTube publishes no video count on a channel result), `playlists` returns playlist rows. Only applies to `searchQueries`.

## `searchQueries` (type: `array`):

Optional. One entry per search, exactly as you would type it into YouTube's own search box. Leave empty to run in channel mode only; fill both fields to do both in one run. Queries are deduped case-insensitively.

## `uploadDate` (type: `string`):

Restrict a video search to what was uploaded inside this window. This is YouTube's own filter, and like YouTube it applies to a video search only — it is ignored for channels and playlists, which have no such filter.

## `maxResultsPerQuery` (type: `integer`):

How many results to return for each search query. YouTube serves twenty per page, so the walk stops on the page that reaches your number. Set 0 for everything YouTube will page through, which is far fewer than the `estimatedResults` figure it advertises.

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

How many channels or queries are walked at once. Each parallel worker keeps its own residential proxy session, so a target that gets blocked burns only its own exit IP. Pages *within* one target cannot be parallelised — each page hands over the token for the next — so this is the only lever on speed. Three is the balance that holds up in practice.

## `maxRunSecs` (type: `integer`):

Wall-clock budget for the whole run. When it is reached the Actor stops walking, keeps and bills for every row it already wrote, and files a free diagnostic row for each entry it never reached. A channel stopped part-way keeps its rows and is not marked as failed. Nothing is charged for work that did not happen.

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

YouTube blocks datacenter IP ranges wholesale, which is why this Actor is built around Apify's residential proxy and why the proxy cost is already inside the per-row price. Leave this on the default. Sessions rotate automatically when an exit IP is refused. Clearing it sends requests from the run's own datacenter address, which YouTube will almost certainly block.

## Actor input object example

```json
{
  "channels": [
    "@TED",
    "https://www.youtube.com/@NASA/videos",
    "UCAuUUnT6oDeKwE6v1NGQxug"
  ],
  "tab": "videos",
  "maxVideosPerChannel": 30,
  "includeChannelProfile": true,
  "searchType": "videos",
  "searchQueries": [
    "machine learning tutorial",
    "nasa artemis"
  ],
  "uploadDate": "any",
  "maxResultsPerQuery": 50,
  "maxConcurrency": 3,
  "maxRunSecs": 240,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

## `results` (type: `string`):

One row per video, plus one profile row per channel and one row per search result. Channels and queries that could not be read get a free diagnostic row saying why. Delivered as JSON items in the default dataset.

# 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": [
        "@TED"
    ],
    "tab": "videos",
    "maxVideosPerChannel": 30,
    "includeChannelProfile": true,
    "searchType": "videos",
    "searchQueries": [],
    "uploadDate": "any",
    "maxResultsPerQuery": 50,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("insight.solutions/youtube-channel-api").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": ["@TED"],
    "tab": "videos",
    "maxVideosPerChannel": 30,
    "includeChannelProfile": True,
    "searchType": "videos",
    "searchQueries": [],
    "uploadDate": "any",
    "maxResultsPerQuery": 50,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("insight.solutions/youtube-channel-api").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": [
    "@TED"
  ],
  "tab": "videos",
  "maxVideosPerChannel": 30,
  "includeChannelProfile": true,
  "searchType": "videos",
  "searchQueries": [],
  "uploadDate": "any",
  "maxResultsPerQuery": 50,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call insight.solutions/youtube-channel-api --silent --output-dataset

```

## MCP server setup

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

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/DtAfnMdbTaeavlDew/builds/SGnPp0GtoRwNnKFsI/openapi.json