Chat With Any YouTube Channel in Claude (Cited, No Code)
Ask Claude to pull every transcript from a channel with the YouTube Transcript Scraper Pro Actor. Have it split the transcripts into labelled passages of up to 512 tokens with the Markdown RAG Chunker, then add the result to a Claude Project or a Cowork folder. Each passage begins with its video title and a timestamp link, so every answer can cite the exact moment in the video. It needs no code, and 50 captioned videos cost well under $1 in Apify usage.
Some creators have hundreds of hours of useful video and no searchable record of what they said. "What did they say about pricing?" usually means scrubbing through ten videos. This guide turns a channel into a knowledge base you can question in plain language, where every answer names the video and the minute it came from.
Paste this and let Claude set it up
If you have Claude Cowork and an Apify account, paste the prompt below. Claude interviews you, runs a small paid test and shows you what it cost, then builds the knowledge base. It asks before every step that costs money or writes files. The rest of this post explains what it is doing, so you can also follow the steps by hand.
Claude asks what you need, tests on 3 videos and shows the cost, then builds timestamped, chunked knowledge files in a folder you choose.
- Asks for the channel, how many videos, the language and the folder, one question at a time
- Checks the Apify connector is connected, and explains how to add it if not
- Runs a 3-video test and reports the Apify cost
- Pulls the transcripts, writes timestamped Markdown, chunks it and saves the knowledge files
- Writes the Project instructions that make Claude cite video and timestamp
Help me turn a YouTube channel into a knowledge base I can chat with, where
every answer cites the video title and a timestamp link. Work step by step and
ask me before anything that costs money or writes files.
1. Ask me these questions, ONE at a time, waiting for each answer:
a. The channel URL (for example https://www.youtube.com/@channelname).
b. How many of the newest videos to include (suggest 25 to start).
c. The caption language(s), in order of preference (default: en).
d. Whether to transcribe videos that have no captions with AI. This costs
extra per minute of video, so default to no.
e. Which folder to save the knowledge files in.
2. Check that the Apify connector is available by looking for its tools
(search-actors, fetch-actor-details, call-actor, get-dataset-items). If they
are missing, stop and tell me how to add it: Customize > Connectors > Add
custom connector, URL https://mcp.apify.com, then sign in to Apify.
3. Use fetch-actor-details on codepoetry/youtube-transcript-ai-scraper and
codepoetry/markdown-rag-chunker and tell me their current prices per event.
4. Test run (ask me first): call codepoetry/youtube-transcript-ai-scraper with
startUrls = [the channel URL], maxResults = 3, my languages,
outputFormats = ["json", "llm"], enableAiFallback as I chose, and
maxAiMinutes = 30. Read the results with get-dataset-items. Show me each
video's title, whether captions were found, any error_code, and the total
cost of the run.
5. Full run (ask me first, with an estimated cost): same input with my chosen
maxResults. List any videos that returned an error_code and why.
6. For each video, write a Markdown section:
# <video title> (<upload date as YYYY-MM-DD>)
Source: https://youtu.be/<video id>
## <mm:ss> https://youtu.be/<video id>?t=<seconds>
<the transcript text spoken in that 2-minute window>
Build the 2-minute windows from transcript_json start times. If a video has
no transcript_json, use transcript_llm under a single "## 00:00" heading.
Put 10 to 20 videos in each Markdown document.
7. Chunk each document (ask me first): call codepoetry/markdown-rag-chunker
with markdown_text = the document, source_id = "<channel URL> batch <n>",
headers_to_split_on = ["#", "##"] and max_chunk_tokens = 512.
Read the chunks with get-dataset-items.
8. Save one file per batch in my folder (ask me first), named
<channel>-knowledge-<n>.md. Write each chunk's embedding_text, separated by
a line containing only ---. Then tell me the total token_count across all
chunks and the total Apify cost.
9. Finally, write the instructions I should paste into a Claude Project that
holds these files: answer only from the files, cite every claim as
"<video title>, <mm:ss> <timestamp link>", and say so plainly when the
videos don't cover a question.
Claude asks before each change it makes. Read each step before you approve it.
How the workflow fits together
Three pieces do the work, and you only interact with the last one.
| Step | Tool | What it adds |
|---|---|---|
| 1. Get the words | codepoetry/youtube-transcript-ai-scraper | Every transcript from the channel, with timestamps. It uses the video's own captions first and falls back to paid AI transcription only if you turn it on. |
| 2. Label and size them | codepoetry/markdown-rag-chunker | Splits the transcripts into passages of up to 512 tokens. Each passage carries its header path (video title and timestamp) and an exact token count. |
| 3. Ask questions | A Claude Project or a Cowork folder | Claude answers from the passages and cites the label each one carries. |
Claude drives both Actors through Apify's MCP server, using the call-actor and get-dataset-items tools. You never open the Apify Console, though you can check every run there afterwards.
Step 1: pull the channel's transcripts
The YouTube Transcript Scraper Pro accepts a single video, a playlist or a channel URL such as youtube.com/@channelname. It reads channels newest first, and these are the inputs that matter here:
| Input | Set it to | Why |
|---|---|---|
startUrls | the channel URL | Channels and playlists expand into their videos. |
maxResults | 25 to start | The default is 10. One run transcribes at most 500 videos. |
languages | ["en"] or your list | The first match on each video wins. en also matches en-US. |
outputFormats | ["json", "llm"] | json gives the timestamped segments you need for citations. llm strips [Music] and filler tokens. |
enableAiFallback | false at first | Off by default. Turn it on only for channels with uncaptioned videos. |
maxAiMinutes | 30 (the default) | Hard cap on AI minutes per run, if you do turn the fallback on. |
Each result is one video, with metadata (title, URL, upload date, duration, channel), transcript_json (segments with start, end and text) and transcript_llm. A video that fails becomes an item with an error_code such as NO_CAPTIONS_AVAILABLE or CAPTIONS_NOT_READY, the run carries on, and error items are not charged.
A detail that matters for citations: for very long videos, the Actor drops per-word timings first and then the timestamped segments, so that each item stays under Apify's size limit, while the text formats are always kept. The setup prompt handles this by putting that video under a single 00:00 heading. The citation still names the right video, only without a precise minute.
If you want the transcript step on its own, with the trade-offs between the caption and AI routes, see how to extract YouTube transcripts without the YouTube API.
Step 2: write timestamped Markdown
This is the step that makes the citations work. Claude rewrites each video as a Markdown section, with a heading every two minutes that holds a timestamp link:
# There's never been a better time to go into math (2026-10-16)
Source: https://youtu.be/LKrwhjOI8Nc
## 00:00 https://youtu.be/LKrwhjOI8Nc?t=0
Well, let's talk about it. It feels like the whole math world is on fire
talking about AI in math. I have been thinking about this for a very long time...
## 02:00 https://youtu.be/LKrwhjOI8Nc?t=120
faith effort at trying to think that through and bring you along with me...
Real output from a test run on 2026-10-21 on two 3Blue1Brown videos, trimmed. The text is the captions exactly as delivered.
Why two minutes? It keeps most passages close to the chunker's 512-token cap with one timestamp each. A shorter window gives more precise citations but more chunks to pay for. In the test above, a fast speaker (about 218 words a minute) produced 47 two-minute windows across 92 minutes of video. The chunker kept 40 of them whole and split the other 7 in two. With one small chunk per video for the title and source line, that made 56 chunks in total. A split passage keeps its window's timestamp, so its citation still points to the right two minutes.
Step 3: chunk it with the Markdown RAG Chunker
The Markdown RAG Chunker splits a document on its headings first, then breaks any section longer than max_chunk_tokens on paragraph, sentence and word boundaries with 10% overlap. It takes one document per run, either a URL or pasted Markdown, so Claude sends it 10 to 20 videos at a time in markdown_text.
The settings used here:
headers_to_split_on: ["#", "##"]: a new chunk at each video and at each timestamp heading.max_chunk_tokens: 512: the default, measured with thecl100k_basetokenizer.source_id: a stable name for the batch, so chunk IDs stay the same if you re-run it.
Each chunk comes back with content, header_path, chunk_index, chunk_total, token_count, chunk_id and an embedding_text field that joins the header path and the passage text:
{
"header_path": "There's never been a better time to go into math (2026-10-16) > 04:00 https://youtu.be/LKrwhjOI8Nc?t=240",
"chunk_index": 5,
"chunk_total": 56,
"token_count": 477,
"embedding_text": "There's never been a better time to go into math (2026-10-16) > 04:00 https://youtu.be/LKrwhjOI8Nc?t=240\n\nquestions are worth asking. But we actually wanna get out of it is like a broad understanding of of what's really going on here. You know, when Descartes introduced Cartesian coordinates..."
}
Real output from a test run on 2026-10-21, trimmed to the fields that matter here.
embedding_text is the field to save. Every passage then begins with "which video, which minute", so the label stays attached however Claude later retrieves the passage.
Do you need the chunker for a small channel? Not strictly. If 20 or 30 videos are all you will ever add, the timestamped Markdown from step 2 already works in a Project. The chunker earns its place in three situations:
- The channel is big enough to push a Project into retrieval mode (see below).
- You want the token count to know where you stand.
- You may move the same chunks into a vector database later. The
chunk_idandembedding_textfields are built for that.
Step 4: put it in a Claude Project or a Cowork folder
A Claude Project is the simplest place to chat with the result. Upload the knowledge files and paste the instructions Claude wrote in the last step of the setup prompt. According to Anthropic's RAG for Projects article, on paid plans (Pro, Max, Team and Enterprise) a Project switches to retrieval automatically as its knowledge approaches the context window limit. That raises its capacity by up to 10x, and a visual indicator shows when it is active. Below that size, Claude reads all the files at once. Above it, Claude retrieves the relevant passages, which is exactly when self-labelled chunks pay off.
The total token_count from the chunker tells you which side you are on. In our test, 92 minutes of video came to 22,382 tokens, about 240 per minute of speech, which is a useful rule of thumb for sizing a channel before you run anything. Treat it as an estimate: the chunker counts with an OpenAI tokenizer, not Claude's.
A Cowork folder works too. Cowork can read, edit and create files in folders you give it access to, so you can ask it questions against the folder it just wrote. Use a Project when you want a permanent "ask this channel" space, and the folder when the knowledge base is one input to a bigger task, such as drafting a course outline from it.
Either way, the instruction that matters is the citation rule. Here it is on its own, to paste into a Project:
Paste into the Project's instructions field once the knowledge files are uploaded.
Answer only from the files in this project. They are chunked transcripts of a
YouTube channel. Every chunk starts with its video title and a timestamp link.
- Cite every claim as: <video title>, <mm:ss> <timestamp link>.
- If several videos disagree, show each view with its citation and the
video's upload date, newest first.
- If the files don't cover the question, say "The videos don't cover this"
and stop. Do not answer from general knowledge.
- Quote the creator's exact words when the wording matters.
What it costs
Both Actors charge per event, with no separate server-time charge, and higher Apify plans pay less per event. These are Free-plan prices as listed on the Actor pages in October 2026. Check them again before a big run; the setup prompt has Claude read them for you.
| Event | Free-plan price |
|---|---|
| Transcript from captions | $0.001 per video |
| AI transcription (only if enabled) | $0.012 per minute of video, billed on the full length |
| Transcript Actor run start | $0.0025 per run |
| Chunk | $0.0008 per chunk |
| Chunker run start | $0.001 per run |
Our test run (2026-10-21): two videos totalling 92 minutes, one transcript run and one chunker run.
- Transcripts: 2 × $0.001 + $0.0025 start = $0.0045.
- Chunks: 56 × $0.0008 + $0.001 start = $0.0458.
- Total at Free-plan prices: about $0.05.
Scaled up, an estimate: the test produced about 0.6 chunks per minute of video. For 50 captioned videos of about 15 minutes each, that is around 450 chunks.
- Transcripts: 50 × $0.001 = $0.05.
- Chunks: about 450 × $0.0008 = $0.36.
- Run starts: a few cents.
That comes to roughly $0.45, which the Apify free plan's monthly credit covers. Turning on the AI fallback changes the maths quickly: ten uncaptioned 15-minute videos add 150 minutes × $0.012 = $1.80. That is why it is off by default and capped by maxAiMinutes.
The Apify cost is the small part. Claude re-reads and rewrites every transcript in steps 2 and 3, so a large channel uses a meaningful share of your Claude plan's usage. Work in batches of 20 to 25 videos.
Limits worth knowing
- Auto-generated captions mishear names. Most videos only have YouTube's machine captions, and they often misspell people, products and jargon. Claude will cite a misspelled name faithfully. For a channel full of technical terms, spot-check a few transcripts first. Expect small glitches too: our test transcripts repeated a word or two where caption lines meet ("academic. academic math"). Claude reads past these, but don't present a quote as verbatim without checking the video.
- It is a snapshot. A Project does not update itself. Re-run the setup prompt for new uploads (set
maxResultsto the number of new videos) and add the new file. - Timestamps are approximate. For native captions, segment end times are estimated, and a two-minute window points to where a topic starts, not the exact sentence.
- Use it for your own research. Transcripts are the creator's work. Quoting with a link back, as this setup does, is the respectful pattern. Republishing whole transcripts is not.
When a different tool fits better
- The chatbot is for your audience, not for you. A public "ask my videos" widget on your site is a different job. See connecting YouTube to Chatbase.
- You want a docs site, not a channel. Crawling documentation into Claude is covered in scraping docs to Markdown for Claude.
- You are building an app. For LangChain, LlamaIndex and a vector database, follow YouTube transcripts for LLM and RAG pipelines, then production RAG architecture. The chunks from this workflow load straight into it.
The same transcript Actor powers two other workflows: finding outlier videos in your niche reads the first 30 seconds of the videos that beat their channel's median, and voice of customer analysis mines review and comparison videos for why people switch. For more prompts like these by role, see Claude prompts that use live web data.
Not as a channel-wide knowledge base. Claude works from text, so the reliable route is to pull each video's transcript with a scraper such as YouTube Transcript Scraper Pro, then give Claude those transcripts as project knowledge with timestamps attached.
Anthropic does not publish a video count. A Project holds as much text as fits Claude's context window; on paid plans it switches to retrieval automatically as it approaches that limit, expanding capacity by up to 10x. The chunker's total token_count tells you roughly where a channel lands.
They come back with the error code NO_CAPTIONS_AVAILABLE and are not charged. Turn on enableAiFallback to transcribe their audio, billed per minute of video length, and set maxAiMinutes to cap the cost.
No. Claude calls both Apify Actors through the Apify MCP connector and writes the Markdown and knowledge files itself. You paste one setup prompt and answer its questions.