Generate Study Notes from Lecture Videos with AI

Most lecture videos on YouTube come with captions, but captions are not notes. They are a word-for-word dump with no structure, no emphasis on key concepts, and no separation between an important definition and a passing remark. Turning those raw captions into something a student can actually study from takes a pipeline: fetch the transcript cleanly, pass it to an LLM with a structured prompt, and preserve timestamp references so the notes link back to the video.

This tutorial walks through exactly that, with working code in Python.

Why Raw Captions Fall Short

Auto-generated YouTube captions are optimized for readability in the player, not for downstream processing. They contain:

• Repeated filler words and false starts ("um", "so, like", mid-sentence breaks)
• No paragraph or topic boundaries
• Timestamps on every short segment, which bloat token counts when fed directly to an LLM
• Inconsistent capitalization and no punctuation in auto-generated tracks

A student copying captions into a notes document gets a wall of text. An LLM given that wall without preprocessing spends part of its context on noise and produces noisier output.

The fix is to treat caption retrieval and note generation as two separate steps, with a cleaning pass in between.

Step 1: Fetch the Lecture Transcript

YouTube Transcriber returns transcripts as JSON with per-segment text and start times. One GET request, one Bearer token.

import requests

API_KEY = "YOUR_API_KEY"
VIDEO_URL = "https://www.youtube.com/watch?v=LECTURE_VIDEO_ID"

response = requests.get(
    "https://getyoutubetranscriber.com/api/v2/transcript",
    params={"video_url": VIDEO_URL},
    headers={"Authorization": f"Bearer {API_KEY}"},
)
response.raise_for_status()
data = response.json()
segments = data["transcript"]  # list of {text, start, duration}

Each segment looks roughly like this:

{
  "text": "so the key insight here is that gradient descent",
  "start": 142.56,
  "duration": 3.2
}

The start value is in seconds. You will need it later for timestamped references.

Step 2: Clean and Prepare the Text

Before sending to an LLM, merge segments into paragraphs and strip filler. A simple approach groups segments into chunks of roughly 30 seconds each, which tends to correspond to a single thought.

def build_chunks(segments, window_seconds=30):
    chunks = []
    current_text = []
    chunk_start = None

    for seg in segments:
        if chunk_start is None:
            chunk_start = seg["start"]
        current_text.append(seg["text"].strip())
        elapsed = seg["start"] - chunk_start
        if elapsed >= window_seconds:
            chunks.append({
                "start": chunk_start,
                "text": " ".join(current_text)
            })
            current_text = []
            chunk_start = None

    if current_text:
        chunks.append({
            "start": chunk_start or 0,
            "text": " ".join(current_text)
        })

    return chunks

chunks = build_chunks(segments)

You now have a list of text blocks, each with a start time, ready for LLM processing.

Step 3: Prompt the LLM for Structured Notes

The quality of your notes depends almost entirely on prompt structure. Open-ended prompts like "summarize this lecture" produce inconsistent results. Explicit output schemas produce consistent ones.

This prompt targets three outputs per chunk: a short topic heading, a bullet list of key points, and any defined terms with their definitions.

import openai

client = openai.OpenAI()

def notes_from_chunk(chunk):
    start_formatted = f"{int(chunk['start'] // 60):02d}:{int(chunk['start'] % 60):02d}"
    prompt = f"""You are a study-notes assistant. The following is a segment from a lecture transcript starting at {start_formatted}.

Transcript:
{chunk['text']}

Produce structured study notes in this exact format:
## [Topic Heading]
- Key point 1
- Key point 2
**Key Terms:**
- Term: Definition (if any terms were defined)

If no terms were defined, omit the Key Terms section. Be concise. Use the student's perspective."""

    response = client.chat.completions.create(
        model="gpt-4o-mini",
        messages=[{"role": "user", "content": prompt}],
        temperature=0.3,
    )
    return {
        "start": chunk["start"],
        "start_formatted": start_formatted,
        "notes": response.choices[0].message.content.strip()
    }

note_blocks = [notes_from_chunk(c) for c in chunks]

A lower temperature (0.2 to 0.4) keeps the output format stable across chunks. Higher values introduce creative variation you do not want in a notes generator.

Step 4: Add Timestamped References

Timestamps make the notes actionable. A student reviewing a concept can click directly to the moment in the lecture where it was introduced rather than scrubbing through the whole video.

Assemble the final document with YouTube deep-links:

VIDEO_ID = "LECTURE_VIDEO_ID"

def youtube_link(video_id, start_seconds):
    return f"https://www.youtube.com/watch?v={video_id}&t={int(start_seconds)}s"

output_lines = [f"# Study Notes: {VIDEO_URL}\n"]

for block in note_blocks:
    link = youtube_link(VIDEO_ID, block["start"])
    output_lines.append(f"[Jump to {block['start_formatted']}]({link})\n")
    output_lines.append(block["notes"])
    output_lines.append("\n---\n")

full_notes = "\n".join(output_lines)
print(full_notes)

The result is a Markdown document where each section links back to its source moment. You can render this in a web app, export it to Notion, or serve it as a PDF.

For applications that need to go beyond linear notes into conversational Q&A over the transcript, the approach in Build a YouTube Video Q&A Chatbot with Transcripts shows how to wire transcripts into a retrieval-augmented generation pipeline.

Gotcha: Handling Long Lectures and Token Limits

A 90-minute lecture transcript can easily run 15,000 to 20,000 words. That is manageable for models with large context windows (GPT-4o supports 128K tokens, Claude 3.5 Sonnet supports 200K), but sending the entire transcript as a single prompt has two problems:

1. Cost. Processing 20,000 words in a single call is expensive relative to chunked processing, especially when you only need focused notes per topic, not a global synthesis.
2. Quality degradation. LLMs attending over very long contexts tend to under-weight material in the middle. A study on lost-in-the-middle effects found that retrieval accuracy drops significantly for content in the middle of very long prompts.

The chunking approach from Step 2 addresses both. Process each 30-second window independently, then run one final summarization pass over the collected headings to produce a table of contents:

def generate_table_of_contents(note_blocks):
    headings = []
    for block in note_blocks:
        for line in block["notes"].split("\n"):
            if line.startswith("## "):
                headings.append(f"- [{line[3:]}](#{block['start_formatted']})")

    toc_prompt = f"""Here are the topic headings from a lecture, in order:
{chr(10).join(headings)}

Write a one-paragraph executive summary of what this lecture covers, suitable for a student deciding whether to review a specific section."""

    response = client.chat.completions.create(
        model="gpt-4o-mini",
        messages=[{"role": "user", "content": toc_prompt}],
        temperature=0.3,
    )
    return response.choices[0].message.content.strip()

toc = generate_table_of_contents(note_blocks)

For lectures with inconsistent structure (guest speakers, Q&A sections, tangents), you may want a larger window, 60 to 120 seconds per chunk, to give the model enough context to identify what is actually a topic boundary versus a short digression.

Handling Missing or Disabled Captions

Not every lecture video has captions available. Auto-generated captions depend on YouTube's speech recognition, which can be unavailable for newer uploads or disabled by the uploader. Build a fallback check:

if not segments:
    print(f"No transcript available for {VIDEO_URL}")
    # Queue for manual review, try a different language, or skip

The API returns a clear error response when captions are absent, so you can branch your pipeline logic cleanly rather than parsing an unexpected shape. For a deeper look at fallback strategies across caption types, Handle Missing YouTube Transcripts Gracefully covers the options including language fallback and manual caption prioritization.

Putting It Together: Full Pipeline

Here is the complete flow in one place:

import requests
import openai

API_KEY = "YOUR_TRANSCRIBER_KEY"
OPENAI_KEY = "YOUR_OPENAI_KEY"
VIDEO_URL = "https://www.youtube.com/watch?v=LECTURE_VIDEO_ID"
VIDEO_ID = VIDEO_URL.split("v=")[1]

# 1. Fetch transcript
segments = requests.get(
    "https://getyoutubetranscriber.com/api/v2/transcript",
    params={"video_url": VIDEO_URL},
    headers={"Authorization": f"Bearer {API_KEY}"},
).json()["transcript"]

# 2. Chunk into 30-second windows
chunks = build_chunks(segments, window_seconds=30)

# 3. Generate notes per chunk
client = openai.OpenAI(api_key=OPENAI_KEY)
note_blocks = [notes_from_chunk(c) for c in chunks]

# 4. Assemble with timestamps
output_lines = [f"# Study Notes\n"]
for block in note_blocks:
    link = youtube_link(VIDEO_ID, block["start"])
    output_lines.append(f"[{block['start_formatted']}]({link})\n")
    output_lines.append(block["notes"])
    output_lines.append("\n---\n")

print("\n".join(output_lines))

The pipeline works with any YouTube video that has captions. Swap the LLM call for Claude, Gemini, or a locally hosted model and the rest of the code stays unchanged. For teams building this into a content workflow rather than a student tool, the same transcript-to-LLM pattern applies to blog generation: Turn YouTube Podcasts into Blog Posts Automatically shows how to adapt the prompt layer for that output format.

Try It Free

YouTube Transcriber starts you with 100 free credits, no credit card required. You pay only for successful transcript calls, so a failed request (unavailable captions, network error) does not consume a credit. That makes it practical to prototype the full pipeline on a real lecture set before committing to anything.

The API docs cover authentication, all available endpoints, and the exact response schema. Start there, grab your key, and run the fetch step against a lecture you already know well. Seeing the JSON response for a familiar video is the fastest way to understand what the cleaning and prompting steps are working with.