Transcripts fix that. This guide covers a simple workflow I use for research and technical notes:

1. Get the transcript as SRT (timed) and/or TXT (plain).
2. Turn it into notes you'll actually reuse.
3. Quote accurately, with timestamp links back to the source.
4. Make a growing collection of transcripts searchable.

Everything here uses plain files, Python's standard library and SQLite. No services required.

1. SRT vs TXT: pick the right format

Most transcript tools give you two formats, and they're good at different things.

SRT keeps timing. Each "cue" has a number, a start and end time, and the text:

42
00:12:03,480 --> 00:12:07,120
so the trick is to invalidate on write
not on read

Use SRT when time matters: quoting, linking to moments, aligning with slides, or building a search index that jumps to the right second.

TXT is just the words. It's easier to read, paste into a doc, or feed into a summariser.

My rule: always keep the SRT as the source of truth, and generate TXT from it when you need reading copy. You can always throw timing away, but you can't get it back.

For getting the files: YouTube's own transcript panel (under the description, "Show transcript") is fine for reading. For downloads, a free web tool such as YouTubeScribe gives you TXT and SRT from the video's existing caption track. Developers can script it with yt-dlp or the youtube-transcript-api Python package. Whatever you use, remember that these all read the captions the video already has. No captions means no transcript.

2. Parse SRT in a few lines of Python

You don't need a library for basic SRT parsing. This yields (start_seconds, text) for each cue:

import re
from pathlib import Path

CUE = re.compile(
    r"(\d+)\s*\n(\d{2}):(\d{2}):(\d{2}),(\d{3}) --> [^\n]+\n(.*?)(?:\n\n|\Z)",
    re.S,
)

def parse_srt(path):
    text = Path(path).read_text(encoding="utf-8").replace("\r\n", "\n")
    for m in CUE.finditer(text):
        h, mnt, s = int(m[2]), int(m[3]), int(m[4])
        yield h * 3600 + mnt * 60 + s, " ".join(m[6].split())

(If your files get messy, the srt package on PyPI is a solid, tolerant parser.)

Converting to readable TXT is then trivial. Group cues into paragraphs every 60 seconds or so, since auto-captions often lack reliable sentence punctuation:

def to_paragraphs(cues, every=60):
    para, bucket = [], None
    for start, text in cues:
        if bucket is None or start - bucket >= every:
            if para:
                yield bucket, " ".join(para)
            para, bucket = [], start
        para.append(text)
    if para:
        yield bucket, " ".join(para)

3. Notes you'll actually reuse

A raw transcript isn't a note. It's source material. What's worked for me is one Markdown file per video, with three sections:

# Talk title — Speaker (Conference, 2025)
Source: https://www.youtube.com/watch?v=VIDEO_ID

## Summary (my words, 3–5 bullets)
- ...

## Key moments
- [12:03](https://www.youtube.com/watch?v=VIDEO_ID&t=723s) Invalidate on write, not read
- [31:40](https://www.youtube.com/watch?v=VIDEO_ID&t=1900s) Benchmark numbers

## Transcript
(paragraphed TXT, with a timestamp at the start of each paragraph)

A few habits make a big difference:

• Write the summary yourself. AI summaries are fine for triage, but writing it in your own words is what makes you remember it. It also catches errors in the captions.
• Timestamp links are your citations. YouTube accepts &t=<seconds>s on a watch URL, so every key moment is one click from the source.
• Keep the full transcript at the bottom so full-text search in Obsidian, Logseq, VS Code or plain ripgrep finds it later.

Generating that timestamp link from a parsed cue is one line:

def ts_link(video_id, seconds):
    m, s = divmod(int(seconds), 60)
    h, m = divmod(m, 60)
    label = f"{h}:{m:02d}:{s:02d}" if h else f"{m}:{s:02d}"
    return f"[{label}](https://www.youtube.com/watch?v={video_id}&t={int(seconds)}s)"

4. Quoting accurately

Transcripts make quoting easy, and also make it easy to quote wrongly. Auto-generated captions mishear names, technical terms and numbers ("Kubernetes" becomes "cooper Nettie's", "15%" becomes "50%").

Before a quote goes into a paper, blog post or slide:

1. Find it in the transcript (search is instant).
2. Click the timestamp and listen to the original few seconds.
3. Fix the wording to match what was actually said. Use [brackets] for anything you add, and an ellipsis for anything you cut.
4. Cite the video and the time. For example, in APA style:

Speaker, A. (2025, March 4). Title of the talk [Video]. YouTube. https://www.youtube.com/watch?v=VIDEO_ID

and give the timestamp in the in-text citation, e.g. (Speaker, 2025, 12:03).

If a video has human-uploaded captions, they're usually more reliable than auto-generated ones. Many tools (and yt-dlp's --write-subs) let you prefer them.

5. Search across all your transcripts with SQLite FTS5

Once you have more than a handful of videos, you want to ask "which talk mentioned vector clocks, and when?" SQLite's built-in full-text search (FTS5) does this with no server:

import sqlite3
from pathlib import Path

db = sqlite3.connect("transcripts.db")
db.execute(
    "CREATE VIRTUAL TABLE IF NOT EXISTS cues "
    "USING fts5(video_id, start UNINDEXED, text)"
)

# Index every SRT in a folder; name files <video_id>.srt
for srt in Path("transcripts").glob("*.srt"):
    rows = [(srt.stem, start, text) for start, text in parse_srt(srt)]
    db.executemany("INSERT INTO cues VALUES (?, ?, ?)", rows)
db.commit()

def search(q, limit=10):
    sql = ("SELECT video_id, start, snippet(cues, 2, '[', ']', '…', 12) "
           "FROM cues WHERE cues MATCH ? ORDER BY rank LIMIT ?")
    for vid, start, snip in db.execute(sql, (q, limit)):
        print(f"https://www.youtube.com/watch?v={vid}&t={start}s  {snip}")

search('"vector clocks"')
search("cache NEAR(invalidate, 10)")

Every hit is a link that opens the video at the right second. FTS5 supports phrase queries, NEAR, prefix search (invalid*) and boolean operators, which is plenty for a personal research library.

One tip: because a single cue is only a few words long, phrases can straddle two cues. If you miss results, index overlapping windows instead (for example, each row holds cue n plus cue n+1).

6. Ethics and practicalities

• Respect the source. Transcripts for personal notes, study and research are one thing. Republishing someone's whole talk as your blog post is another. Quote, link and credit.
• Check the licence if you plan to share a transcript dataset.
• Mind rate limits if you script downloads. Fetch slowly and cache everything locally.
• No captions, no transcript. For videos without a caption track, you'd need speech-to-text (e.g. running Whisper locally on audio you have the right to use).

Wrapping up

The whole workflow fits in one small script: keep SRT as the source of truth, generate readable TXT and Markdown notes from it, link every quote back to its timestamp, and drop everything into an FTS5 index. After a few weeks you end up with a searchable personal library of every talk and lecture you've learned from, and every claim in it is one click from the original video.

The source

The data comes from DESNZ's Household Energy Efficiency Statistics headline release (June 2026): Table 3.4 (ECO measures by area), Table 3.5 (flexible eligibility measures) and Table 4.4 (households helped). Three tables, three slightly different layouts.

Problems worth knowing about

1. Mixed hierarchy. The sheets contain councils, counties, Inner and Outer London sub-totals and regions in the same column. If you sum everything you double count. The fix was to keep only single-tier and district councils (by ONS code prefixes E06, E07, E08, E09, W06 and S12) and move the county into its own column.

2. Bilingual names. Welsh councils appear as "Ceredigion / Ceredigion"-style strings. The published names are kept, so join on the ONS area code instead of the name.

3. Suppressed values. DESNZ withholds small numbers: "#" means a value of 1 to 4 and "^" means 5 or more, withheld for privacy. Casting these to zero would silently bias the data, so they become blank cells with a separate flag column. In the file, 30 councils have a suppressed flex value.

4. Different time windows. The main measures column covers January 2013 to March 2026 across every ECO phase. The flexible eligibility figures only start in April 2022. Mixing these in one chart is misleading, so each column is labelled with its window.

A validation step worth copying

After cleaning, check that the 350 council rows add up exactly to the published Great Britain totals: 4,453,004 measures and 2,595,218 households. If a council is dropped or a county subtotal sneaks in, the check fails immediately. It is cheap to write and catches most structural mistakes.

A caution on interpretation

Raw totals favour big cities. Birmingham has the most measures (195,919), but Bradford has the highest rate at 578.4 per 1,000 households. Use the per-household rate to compare areas. Also, DESNZ does not publish an ECO4-only total by council, so this data should not be read as "ECO4 only".

import pandas as pd
df = pd.read_csv("eco_measures_by_council_gb.csv")
top = df.sort_values("measures_per_1000_households", ascending=False).head(10)
print(top[["council", "measures_per_1000_households"]])

Get the data

The cleaned CSV, column dictionary and methodology are on the ECO measures by council data page. It is released under the Open Government Licence v3.0, and the figures are provisional, as published by DESNZ. If you spot a problem, let us know and we will fix it.