DEV Community: Faisal Ashfaq

How to Get a Transcript of Any YouTube Video (4 Free Methods)

Faisal Ashfaq — Fri, 23 Oct 2026 04:25:26 +0000

Sometimes you don't want to watch a video, you want to read it. Maybe you need to quote a conference talk accurately, skim a 90-minute lecture for the one part that matters, or paste a tutorial's steps into your notes.

Almost every way of getting a YouTube transcript relies on the same thing: the video's caption track. YouTube automatically generates captions for most uploads in supported languages, and many creators upload their own. If a video has a caption track, you can get its text for free. If it doesn't, no "transcript tool" can pull text out of thin air. At that point you need actual speech-to-text, which is a different (and usually paid or compute-heavy) job.

With that in mind, here are four free methods, from zero-setup to fully scriptable.

Method 1: YouTube's built-in transcript panel

YouTube has a transcript viewer built in, and plenty of people don't know it exists.

On desktop:

Open the video on youtube.com.
Click the description under the video to expand it (the "...more" link).
Scroll to the bottom of the description and click Show transcript.
A transcript panel opens next to the video, with a timestamp beside every line.

You can click any line to jump to that moment. The panel's menu lets you toggle timestamps off, and a language selector appears if the video has more than one caption track.

On mobile: open the video, tap the description, and look for Show transcript in the same place.

Good for: quickly reading or searching a single video with no extra tools.

Limitations: the text lives inside a scrolling panel. You can select and copy it, but long transcripts are awkward to copy cleanly, timestamps get mixed into the text, and there's no download button. If you just need to find one quote, it's perfect. If you need a file, read on.

Method 2: A free web tool (YouTubeScribe)

If you want a downloadable file, a web-based transcript tool saves you the copy-paste work. I'll use YouTubeScribe as the example here. Full disclosure: I work on it, so I'll stick to what it actually does.

Copy the video URL. Regular watch links, Shorts, youtu.be short links and embed URLs all work.
Paste it into the box on the homepage and click Get transcript.
Read the timestamped transcript, toggle timestamps on or off, then copy it or download it as TXT or SRT.

What's happening under the hood is the same as Method 1: it reads the caption track YouTube already has (auto-generated or uploaded) and formats it. That means:

It works on public and unlisted videos that have captions, in any language the video has a track for (125+ languages are supported).
Private and members-only videos won't work, and neither will videos with no caption track. You get a clear "no transcript" result instead of invented text.
TXT and SRT downloads are free, and you don't need an account for your first transcript.

If you specifically need the caption file with its timing intact, for example to re-upload subtitles or load them into a video editor, the subtitle downloader saves it as SRT or VTT.

Good for: getting a clean file in a few seconds without installing anything.

Other honest options: there are several similar free web tools (DownSub, Tactiq's YouTube transcript page, YouTubeToTranscript and others). They all read the same caption track, so the text will be identical. The differences are in formats, limits and how much the interface gets in your way. Try a couple and keep the one you like.

Method 3: YouTube Studio (for your own videos)

If the video is yours, you already have direct access to the caption files.

Go to YouTube Studio.
Open Subtitles from the left menu and choose the video.
Next to the language track you want, open the options menu and download the file. You'll usually get a choice of formats such as .srt, .vtt or .sbv.

This is also the best place to fix auto-generated captions. Edit them in Studio and every later transcript (from any method in this article) will reflect your corrections.

Good for: creators repurposing their own content into blog posts, show notes or newsletters.

Limitations: only works for videos on channels you manage.

Method 4: Command-line and code (for developers)

If you need transcripts for many videos, or want them inside a script or pipeline, use the open-source tools.

yt-dlp

yt-dlp is the well-known open-source downloader, and it can fetch just the subtitles:

yt-dlp --skip-download --write-subs --write-auto-subs \
  --sub-langs "en.*" --convert-subs srt \
  "https://www.youtube.com/watch?v=VIDEO_ID"

--write-subs grabs uploaded (human) captions; --write-auto-subs grabs auto-generated ones.
--convert-subs srt needs ffmpeg installed.
It also works on playlists, which is handy for a whole lecture series.

youtube-transcript-api (Python)

For Python projects, youtube-transcript-api returns the transcript as data:

from youtube_transcript_api import YouTubeTranscriptApi
from youtube_transcript_api.formatters import SRTFormatter

ytt_api = YouTubeTranscriptApi()
transcript = ytt_api.fetch("VIDEO_ID", languages=["en"])

for snippet in transcript:
    print(f"{snippet.start:7.1f}s  {snippet.text}")

with open("video.srt", "w", encoding="utf-8") as f:
    f.write(SRTFormatter().format_transcript(transcript))

Good for: batch jobs, research datasets and anything you want to automate.

Limitations: YouTube may rate-limit or block requests, especially from cloud servers and data-centre IPs. Please respect YouTube's Terms of Service and creators' rights. Fetching captions for personal notes or research is very different from republishing someone's content wholesale.

Which method should you use?

You want to…	Use
Read or search one video right now	YouTube's transcript panel
Get a TXT or SRT file without installing anything	A web tool like YouTubeScribe
Export or fix captions on your own videos	YouTube Studio
Process dozens or hundreds of videos	yt-dlp or youtube-transcript-api

A note on accuracy

Auto-generated captions are good, but they're not perfect. They struggle with names, jargon, heavy accents, crosstalk and music. Before you quote someone in an article, paper or social post, click back to the timestamp and listen to make sure the words are right. A transcript is a fantastic index into a video, but it doesn't replace the video itself.

And if a video has no captions at all, none of the above will help. You'd need a speech-to-text model (for example, running OpenAI's open-source Whisper locally on audio you have the right to use).

Happy reading, and enjoy getting your evenings back from 90-minute videos.

How to Use Grok Models in Claude Code, Cline, Aider and opencode via an OpenAI-Compatible Endpoint

Faisal Ashfaq — Sun, 18 Oct 2026 05:12:03 +0000

Disclosure: I build Grokified, the gateway used as the worked example here. The patterns below work with any OpenAI-compatible endpoint. Swap in your own base URL, key and model id.

Most AI coding agents let you bring your own model provider now. The settings screens look different, but under the hood nearly all of them ask the same three questions:

Base URL: where should requests go?
API key: what goes in the Authorization: Bearer header?
Model id: what string goes in the model field?

Once you can answer those three, you can point Cline, Aider, opencode and (with one extra step) Claude Code at almost any OpenAI-compatible backend. This post walks through each tool with real values, then covers the one case that doesn't fit the pattern.

My examples use these values from the Grokified docs:

Field	Value
Base URL	`https://api.grokified.com/v1`
Key	`gk_live_...` (production) or `gk_test_...` (test)
Model	`grok-4.7`

Step 0: Prove the endpoint works before touching any agent

Don't debug three layers at once. Before configuring an editor, send the smallest possible request with cURL:

curl https://api.grokified.com/v1/chat/completions \
  -H "Authorization: Bearer $GROKIFIED_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "grok-4.7",
    "messages": [{"role": "user", "content": "Hello"}]
  }'

If that returns 200, your key, base URL and model id are all good, so any later failure is the agent's config. If it doesn't, the status code tells you where to look:

401: wrong or revoked key, or a missing Bearer prefix
402: balance or billing on the account
403: environment or permission mismatch (e.g. a test key against production)
400/404 on the model: the model id isn't current
429/5xx: the only codes worth retrying

That last point matters for agents. Retrying a 401 in a loop just wastes time. Fix the config first.

The same check in Python, using the OpenAI SDK unchanged except for the host:

from openai import OpenAI

client = OpenAI(
    api_key="gk_live_...",
    base_url="https://api.grokified.com/v1",
)

The point of "OpenAI-compatible" is that the request shape stays the same. Only the host line moves.

Cline (and Roo Code / Kilo Code)

Cline is a VS Code agent extension, so the config lives in its own settings panel rather than a file. Pick the OpenAI-compatible provider and fill in four fields:

API Provider: OpenAI Compatible
Base URL: https://api.grokified.com/v1
API Key: gk_live_...
Model ID: grok-4.7

Roo Code and Kilo Code have the same "custom provider" slot with the same fields.

Two practical notes:

Model availability can depend on your plan. With Grokified, grok-4.7 needs the Basic plan or above, and the docs suggest grok-4.6 otherwise. Other providers have similar gating, so if the model returns an error and cURL with a different id works, this is probably why.
The key goes into VS Code's encrypted key storage, not a plaintext file in your repo. That's the right place for it.

Aider

Aider reads the standard OpenAI environment variables, and the openai/ prefix on the model name tells it to use the OpenAI-compatible client:

export OPENAI_API_BASE=https://api.grokified.com/v1
export OPENAI_API_KEY=gk_live_...
aider --model openai/grok-4.7

If you'd rather not export a key into every shell, Aider also reads ~/.aider.conf.yml. Keep the key itself in an environment variable rather than the YAML file, especially if you sync dotfiles.

opencode

opencode is an open-source terminal agent that supports custom compatible providers. Its config lives at ~/.config/opencode/opencode.json. You register a provider with the base URL, read the key from an environment variable, and add grok-4.7 as a model. Check opencode's own provider docs for the exact JSON schema, since it changes between versions. The three values are the same as everywhere else.

Claude Code: the one that's different

Claude Code speaks Anthropic's Messages protocol, not OpenAI's chat completions. Setting a base URL alone won't work against an OpenAI-shaped endpoint, because the request bodies are different.

You have two options:

Use a provider that exposes an Anthropic-shaped endpoint directly.
Run a small local translator that accepts Anthropic-format requests and forwards OpenAI-format ones.

Grokified takes the second approach. Its CLI starts a local relay on 127.0.0.1:4111, and Claude Code's ~/.claude/settings.json points there. The key is held by the relay process rather than written into the settings file. You can manage the relay directly:

grokified relay status
grokified relay stop

If something else is already on port 4111, those two commands are your first stop.

Doing all of the above in one command

Hand-editing four configs is fine once. Doing it on every new machine gets old, which is why I built a CLI for it. It's specific to Grokified, but here's what it does:

npm install -g grokified
grokified login      # browser sign-in; or: grokified login --key gk_live_... for headless
grokified setup      # opens a picker of tools it can configure
grokified doctor     # checks key, balance, relay, and what's wired up

You can also target one tool at a time:

grokified setup claude
grokified setup aider
grokified setup opencode
grokified setup vscode-agents   # Cline / Roo Code / Kilo Code

The design choice I care most about is that the key is never copied into any tool's own config file. It's stored once in ~/.grokified/credentials, and tools get it as an environment variable at launch (opencode, Aider), through the relay (Claude Code), or through the extension's encrypted storage (Cline). That means your dotfiles repo, screen shares and grep -r of your home directory don't leak it.

The CLI page lists every config file it touches.

Troubleshooting notes from the docs that apply to most npm-installed CLIs:

command not found after install usually means npm's global bin isn't on your PATH: export PATH="$(npm config get prefix)/bin:$PATH"
The CLI needs Node 18.17 or newer. The shell installer (curl -fsSL https://grokified.com/install.sh | bash) sets up a private copy of Node if yours is older.

What this can't reach

Be honest about the limits. Some tools can't be pointed at a custom endpoint at all:

Gemini CLI only speaks Google's generateContent format. Changing its base URL changes where requests go, not what they look like.
GitHub Copilot has no custom connection setting for this.
Cursor's built-in model picker is closed for this flow, but extensions like Cline running inside Cursor can still use a custom provider.

A note on cost

I won't pretend there's no commercial angle: Grokified bills Grok usage at a discount to list price, and the details are on the pricing page. The more general lesson is that agents resend a lot of context on every turn, so prompt caching matters more than headline per-token prices for agent workloads. Whatever provider you use, check whether repeated prefixes are cached automatically or need opting in.

Recap

Verify the endpoint with one cURL call before configuring anything.
Cline, Aider and opencode each need just a base URL, a key and a model id.
Claude Code needs an Anthropic-shaped endpoint or a local relay.
Keep keys out of config files: use env vars or encrypted storage.

If you try this with another OpenAI-compatible provider and hit a quirk, I'd like to hear about it in the comments.

Building a council-level dataset of UK ECO home energy upgrades

Faisal Ashfaq — Fri, 09 Oct 2026 20:46:04 +0000

Official UK statistics are often published as multi-sheet Excel workbooks. This post covers how I turned the DESNZ ECO tables into one clean CSV with a row per council, and what it shows.

Repo: https://github.com/imfaisii/eco-measures-by-council-gb

Source and licence

Department for Energy Security and Net Zero (DESNZ), Household Energy Efficiency Statistics, headline release June 2026 (published 25 June 2026): Table 3.4 (ECO measures by administrative area), Table 3.5 (Affordable Warmth measures via flexible eligibility) and Table 4.4 (households in receipt of ECO measures). Contains public sector information licensed under the Open Government Licence v3.0. Underlying data (c) Crown copyright.

Cleaning and joining

Read the three tables with pandas and joined them on the ONS/GSS area code (E06, E07, E08, E09, W06, S12).
Dropped the county and Inner/Outer London sub-total rows to avoid double counting. The county is kept in its own column.
Kept values as published. Nothing was adjusted or estimated.
Kept DESNZ suppression markers: # means 1 to 4 withheld, ^ means 5 or more withheld. The value is left blank and the marker goes in a flag column.
Check: the 350 council rows sum exactly to the published GB totals (4,453,004 measures, 2,595,218 households).

Columns

Column	Meaning
`council`	Local authority name as published
`area_code`	ONS/GSS code
`county_or_met_county`	County, metropolitan county or London sub-area; blank for unitary authorities
`region_or_nation`	English region, Wales or Scotland
`eco_measures_jan2013_mar2026`	All ECO phases, Jan 2013 to Mar 2026
`measures_per_1000_households`	DESNZ published rate
`households_helped_jan2013_mar2026`	Households with at least one measure
`eco3_interim_eco4_flex_measures`	Flexible eligibility measures since April 2022; may be blank
`flex_suppressed_flag`	`#` or `^` where withheld

Findings

Compare councils by rate, not totals. Birmingham has the most measures (195,919), but Bradford has the highest rate at 578.4 per 1,000 households, just ahead of Ceredigion (577.7).
By region, the North West leads at 243.2 per 1,000 households, while London (73.4) and the South East (76.8) are under half the GB rate of 156.7.

Caveats: one household can get several measures, the totals cover every ECO phase since 2013, and the figures are provisional.

Full table

The full table with methodology is at ECO measures by council.