16.0.1 Error: Request to https://www.youtube.com/youtubei/v1/get_transcript?prettyPrint=false&alt=json failed with status 400

[gr0go]

Steps to reproduce

1. Call info.getTranscript(); in nodejs server

try {
    const yt = await Innertube.create({
      generate_session_locally: true,
      lang: language,
      cookie: COOKIE
    });

    const info = await yt.getInfo(video_url);

    title = info.primary_info?.title ? info.primary_info?.title.toString() : '';

    const defaultTranscriptInfo = await info.getTranscript();

console.log(defaultTranscriptInfo)

} catch(e) {
console.log(e)
}

Failure Logs

Error: Request to https://www.youtube.com/youtubei/v1/get_transcript?prettyPrint=false&alt=json failed with status 400

Expected behavior

it supposed to return the transcript

Current behavior

It returns that error since last week , sometimes it works after a couple of tries like 10+ tries in BOTH production and development

Version

Default

Anything else?

No response

Checklist

• I am running the latest version.
• I checked the documentation and found no answer.
• I have searched the existing issues and made sure this is not a duplicate.
• I have provided sufficient information.

[perinst]

I'm just the same as you

[edmund-io]

Same here @LuanRT

Logs:

[shanefully-done]

Same here.

[hatemmezlini]

same here. This is due to new Youtube bot detection rules. Over the past 4 or 5 days, they were blocking 1/2 session when retrieving transcripts, most likely they were A/B testing. Now they went 100% block

[david8z]

same here. This is due to new Youtube bot detection rules. Over the past 4 or 5 days, they were blocking 1/2 session when retrieving transcripts, most likely they were A/B testing. Now they went 100% block

¿Have you find any alternative on how to approach it?

[izakfilmalter]

You can get around this by doing the following:

const info = await client.getBasicInfo(videoId)

// 2. Check for caption tracks
const captionTracks = info.captions?.caption_tracks
if (!captionTracks || captionTracks.length === 0) {
  throw new Error('No caption tracks found')
}

// 3. Find English caption track (prefer non-ASR if available)
const englishTrack =
  captionTracks.find((t) => t.language_code === 'en' && t.kind !== 'asr') ||
  captionTracks.find((t) => t.language_code?.startsWith('en')) ||
  captionTracks[0]

if (!englishTrack?.base_url) {
  throw new Error('No valid caption track URL found')
}

// 4. Fetch timedtext XML
const xml = await fetchTimedTextXml(englishTrack.base_url, proxyUrl)

// 5. Parse XML to segments
const segments = parseTimedTextXml(xml)

if (segments.length === 0) {
  throw new Error('Failed to parse any transcript segments from XML')
}

I told Caude to make a test file and try several ideas, and this one worked.

[edmund-io]

You can get around this by doing the following:

const info = await client.getBasicInfo(videoId)

// 2. Check for caption tracks
const captionTracks = info.captions?.caption_tracks
if (!captionTracks || captionTracks.length === 0) {
throw new Error('No caption tracks found')
}

// 3. Find English caption track (prefer non-ASR if available)
const englishTrack =
captionTracks.find((t) => t.language_code === 'en' && t.kind !== 'asr') ||
captionTracks.find((t) => t.language_code?.startsWith('en')) ||
captionTracks[0]

if (!englishTrack?.base_url) {
throw new Error('No valid caption track URL found')
}

// 4. Fetch timedtext XML
const xml = await fetchTimedTextXml(englishTrack.base_url, proxyUrl)

// 5. Parse XML to segments
const segments = parseTimedTextXml(xml)

if (segments.length === 0) {
throw new Error('Failed to parse any transcript segments from XML')
}
I told Caude to make a test file and try several ideas, and this one worked.

Works initially, but susceptible to getting rate limited quickly

[izakfilmalter]

@edmund-io Ya, you need to proxy, and rotate when you get rate limited.

[KaranLala]

Thanks @edmund-io. When I try to fetch the captions it returns 200 with an empty response. Is it still working for you? Could you share the fetchTimeTextXML function? (maybe just the core without the proxy stuff)?

[izakfilmalter]

@KaranLala here is my current setup:

/**
 * Parsed transcript segment from timedtext XML
 */
type TranscriptSegment = {
  durationMs: number
  startMs: number
  text: string
}

/**
 * Fetch transcript XML from timedtext API
 *
 * @param captionUrl - The timedtext URL from caption tracks
 * @param proxyUrl - The proxy URL to use for the request
 * @param videoId - The video ID for error context
 */
const fetchTimedTextXml = (captionUrl: string, proxyUrl: string, videoId: string) =>
  Effect.gen(function* () {
    const response = yield* Effect.tryPromise({
      catch: (cause) =>
        new InnertubeTimedTextFetchError({
          cause,
          url: captionUrl,
          videoId,
        }),
      try: () =>
        fetch(captionUrl, {
          headers: {
            'Accept-Language': 'en-US,en;q=0.9',
            'User-Agent':
              'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
          },
          proxy: proxyUrl,
        } as RequestInit),
    })

    if (!response.ok) {
      return yield* Effect.fail(
        new InnertubeTimedTextFetchError({
          status: response.status,
          url: captionUrl,
          videoId,
        }),
      )
    }

    const xml = yield* Effect.tryPromise({
      catch: (cause) =>
        new InnertubeTimedTextFetchError({
          cause,
          url: captionUrl,
          videoId,
        }),
      try: () => response.text(),
    })

    if (!xml || xml.length === 0) {
      return yield* Effect.fail(
        new InnertubeTimedTextFetchError({
          url: captionUrl,
          videoId,
        }),
      )
    }

    return xml
  })

/**
 * Parse <p t="ms" d="ms">text</p> format (Android client)
 */
const parsePTagFormat = (xml: string): Array<TranscriptSegment> => {
  const segments: Array<TranscriptSegment> = []
  const pTagRegex = /<p\s+t="(\d+)"\s+d="(\d+)"[^>]*>([\s\S]*?)<\/p>/g

  let match = pTagRegex.exec(xml)
  while (match !== null) {
    const [, startMsStr, durationMsStr, rawText] = match
    if (startMsStr && durationMsStr && rawText) {
      const text = decodeHtmlEntities(rawText.replace(/<[^>]+>/g, '')).trim()
      if (text) {
        segments.push({
          durationMs: Number.parseInt(durationMsStr, 10),
          startMs: Number.parseInt(startMsStr, 10),
          text,
        })
      }
    }
    match = pTagRegex.exec(xml)
  }
  return segments
}

/**
 * Parse <text start="sec" dur="sec">text</text> format (alternative format)
 */
const parseTextTagFormat = (xml: string): Array<TranscriptSegment> => {
  const segments: Array<TranscriptSegment> = []
  const textTagRegex = /<text\s+start="([\d.]+)"\s+dur="([\d.]+)"[^>]*>([\s\S]*?)<\/text>/g

  let match = textTagRegex.exec(xml)
  while (match !== null) {
    const [, startStr, durStr, rawText] = match
    if (startStr && durStr && rawText) {
      const text = decodeHtmlEntities(rawText.replace(/<[^>]+>/g, '')).trim()
      if (text) {
        segments.push({
          durationMs: Math.round(Number.parseFloat(durStr) * 1000),
          startMs: Math.round(Number.parseFloat(startStr) * 1000),
          text,
        })
      }
    }
    match = textTagRegex.exec(xml)
  }
  return segments
}

/**
 * Parse timedtext XML into transcript segments
 * Supports both <p> format (Android) and <text> format (alternative)
 */
const parseTimedTextXml = (xml: string): Array<TranscriptSegment> => {
  // Try <p> tag format first (Android client format)
  const pSegments = parsePTagFormat(xml)
  if (pSegments.length > 0) {
    return pSegments
  }
  // Fall back to <text> tag format
  return parseTextTagFormat(xml)
}

/**
 * Decode common HTML entities in transcript text
 */
const decodeHtmlEntities = (text: string): string =>
  text
    .replace(/&#39;/g, "'")
    .replace(/&quot;/g, '"')
    .replace(/&amp;/g, '&')
    .replace(/&lt;/g, '<')
    .replace(/&gt;/g, '>')
    .replace(/&nbsp;/g, ' ')
    .replace(/&#(\d+);/g, (_, num) => globalThis.String.fromCharCode(Number.parseInt(num, 10)))

/**
 * Convert parsed transcript segments to youtubei.js TranscriptSegmentList format
 */
const convertToYouTubeSegments = (
  segments: Array<TranscriptSegment>,
): YTNodes.TranscriptSegmentList['initial_segments'] => {
  const converted = segments.map((segment) => ({
    end_ms: globalThis.String(segment.startMs + segment.durationMs),
    snippet: {
      text: segment.text,
    },
    start_ms: globalThis.String(segment.startMs),
    start_time_text: {
      text: formatTimestamp(segment.startMs),
    },
  }))

  return converted as unknown as YTNodes.TranscriptSegmentList['initial_segments']
}

/**
 * Format milliseconds as a timestamp string (e.g., "1:23" or "1:23:45")
 */
const formatTimestamp = (ms: number): string => {
  const totalSeconds = Math.floor(ms / 1000)
  const hours = Math.floor(totalSeconds / 3600)
  const minutes = Math.floor((totalSeconds % 3600) / 60)
  const seconds = totalSeconds % 60

  if (hours > 0) {
    return `${hours}:${minutes.toString().padStart(2, '0')}:${seconds.toString().padStart(2, '0')}`
  }
  return `${minutes}:${seconds.toString().padStart(2, '0')}`
}

/**
 * Fetch transcript using Innertube's getBasicInfo to get caption URLs
 * This approach doesn't require a YouTube API key - it uses the standard
 * Innertube WEB client to get caption track URLs, then fetches timedtext directly.
 *
 * @param videoId - Raw YouTube video ID (without video_ prefix)
 * @param proxyUrl - The proxy URL to use for requests
 */
const fetchTranscriptViaInnertube = (
  videoId: string,
  proxyUrl: string,
): Effect.Effect<
  YTNodes.TranscriptSegmentList['initial_segments'],
  InnertubeTranscriptFetchError
> =>
  Effect.gen(function* () {
    // 1. Create Innertube client
    const client = yield* Effect.tryPromise({
      catch: (cause) => new InnertubeClientCreateError({ cause, videoId }),
      try: () =>
        Innertubejs.create({
          fetch: (async (input: RequestInfo | URL, init?: RequestInit) => {
            const response = await fetch(input, {
              ...init,
              proxy: proxyUrl,
            })
            return response
          }) as typeof fetch,
          generate_session_locally: true,
          lang: 'en',
          location: 'US',
          retrieve_player: false,
        }),
    })

    // 2. Get basic info (includes caption tracks)
    const info = yield* Effect.tryPromise({
      catch: (cause) => new InnertubeBasicInfoError({ cause, videoId }),
      try: () => client.getBasicInfo(videoId),
    })

    // 3. Check for caption tracks
    const captionTracks = info.captions?.caption_tracks
    if (!captionTracks || captionTracks.length === 0) {
      return yield* Effect.fail(new InnertubeNoCaptionTracksError({ videoId }))
    }

    // 4. Find English caption track (prefer non-ASR if available)
    const englishTrack =
      captionTracks.find((t) => t.language_code === 'en' && t.kind !== 'asr') ||
      captionTracks.find((t) => t.language_code?.startsWith('en')) ||
      captionTracks[0]

    if (!englishTrack?.base_url) {
      return yield* Effect.fail(
        new InnertubeNoValidCaptionUrlError({
          availableLanguages: captionTracks.map((t) => t.language_code ?? 'unknown'),
          videoId,
        }),
      )
    }

    // 5. Fetch timedtext XML
    const xml = yield* fetchTimedTextXml(englishTrack.base_url, proxyUrl, videoId)

    // 6. Parse XML to segments
    const segments = parseTimedTextXml(xml)

    if (segments.length === 0) {
      return yield* Effect.fail(new InnertubeTranscriptParseError({ videoId }))
    }

    // 7. Convert to YouTube.js format
    return convertToYouTubeSegments(segments)
  })

[BelNaruto]

@KaranLala here is my current setup:

/**

• Parsed transcript segment from timedtext XML
  */
  type TranscriptSegment = {
  durationMs: number
  startMs: number
  text: string
  }

/**

• Fetch transcript XML from timedtext API

• @param captionUrl - The timedtext URL from caption tracks

• @param proxyUrl - The proxy URL to use for the request

• @param videoId - The video ID for error context
  /
  const fetchTimedTextXml = (captionUrl: string, proxyUrl: string, videoId: string) =>
  Effect.gen(function () {
  const response = yield* Effect.tryPromise({
  catch: (cause) =>
  new InnertubeTimedTextFetchError({
  cause,
  url: captionUrl,
  videoId,
  }),
  try: () =>
  fetch(captionUrl, {
  headers: {
  'Accept-Language': 'en-US,en;q=0.9',
  'User-Agent':
  'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
  },
  proxy: proxyUrl,
  } as RequestInit),
  })

  if (!response.ok) {
  return yield* Effect.fail(
  new InnertubeTimedTextFetchError({
  status: response.status,
  url: captionUrl,
  videoId,
  }),
  )
  }

  const xml = yield* Effect.tryPromise({
  catch: (cause) =>
  new InnertubeTimedTextFetchError({
  cause,
  url: captionUrl,
  videoId,
  }),
  try: () => response.text(),
  })

  if (!xml || xml.length === 0) {
  return yield* Effect.fail(
  new InnertubeTimedTextFetchError({
  url: captionUrl,
  videoId,
  }),
  )
  }

  return xml
  })

/**

• Parse

  text

  format (Android client)
  /
  const parsePTagFormat = (xml: string): Array => {
  const segments: Array = []
  const pTagRegex = /<p\s+t="(\d+)"\s+d="(\d+)"[^>]>([\s\S]*?)</p>/g

let match = pTagRegex.exec(xml)
while (match !== null) {
const [, startMsStr, durationMsStr, rawText] = match
if (startMsStr && durationMsStr && rawText) {
const text = decodeHtmlEntities(rawText.replace(/<[^>]+>/g, '')).trim()
if (text) {
segments.push({
durationMs: Number.parseInt(durationMsStr, 10),
startMs: Number.parseInt(startMsStr, 10),
text,
})
}
}
match = pTagRegex.exec(xml)
}
return segments
}

/**

• Parse text format (alternative format)
  /
  const parseTextTagFormat = (xml: string): Array => {
  const segments: Array = []
  const textTagRegex = /<text\s+start="([\d.]+)"\s+dur="([\d.]+)"[^>]>([\s\S]*?)</text>/g

let match = textTagRegex.exec(xml)
while (match !== null) {
const [, startStr, durStr, rawText] = match
if (startStr && durStr && rawText) {
const text = decodeHtmlEntities(rawText.replace(/<[^>]+>/g, '')).trim()
if (text) {
segments.push({
durationMs: Math.round(Number.parseFloat(durStr) * 1000),
startMs: Math.round(Number.parseFloat(startStr) * 1000),
text,
})
}
}
match = textTagRegex.exec(xml)
}
return segments
}

/**

• Parse timedtext XML into transcript segments
• Supports both

  format (Android) and format (alternative)
  */
  const parseTimedTextXml = (xml: string): Array => {
  // Try

  tag format first (Android client format)
  const pSegments = parsePTagFormat(xml)
  if (pSegments.length > 0) {
  return pSegments
  }
  // Fall back to tag format
  return parseTextTagFormat(xml)
  }

/**

• Decode common HTML entities in transcript text
  */
  const decodeHtmlEntities = (text: string): string =>
  text
  .replace(/'/g, "'")
  .replace(/"/g, '"')
  .replace(/&/g, '&')
  .replace(/</g, '<')
  .replace(/>/g, '>')
  .replace(/ /g, ' ')
  .replace(/&#(\d+);/g, (_, num) => globalThis.String.fromCharCode(Number.parseInt(num, 10)))

/**

• Convert parsed transcript segments to youtubei.js TranscriptSegmentList format
  */
  const convertToYouTubeSegments = (
  segments: Array,
  ): YTNodes.TranscriptSegmentList['initial_segments'] => {
  const converted = segments.map((segment) => ({
  end_ms: globalThis.String(segment.startMs + segment.durationMs),
  snippet: {
  text: segment.text,
  },
  start_ms: globalThis.String(segment.startMs),
  start_time_text: {
  text: formatTimestamp(segment.startMs),
  },
  }))

return converted as unknown as YTNodes.TranscriptSegmentList['initial_segments']
}

/**

• Format milliseconds as a timestamp string (e.g., "1:23" or "1:23:45")
  */
  const formatTimestamp = (ms: number): string => {
  const totalSeconds = Math.floor(ms / 1000)
  const hours = Math.floor(totalSeconds / 3600)
  const minutes = Math.floor((totalSeconds % 3600) / 60)
  const seconds = totalSeconds % 60

if (hours > 0) {
return ${hours}:${minutes.toString().padStart(2, '0')}:${seconds.toString().padStart(2, '0')}
}
return ${minutes}:${seconds.toString().padStart(2, '0')}
}

/**

• Fetch transcript using Innertube's getBasicInfo to get caption URLs
• This approach doesn't require a YouTube API key - it uses the standard
• Innertube WEB client to get caption track URLs, then fetches timedtext directly.
• @param videoId - Raw YouTube video ID (without video_ prefix)
• @param proxyUrl - The proxy URL to use for requests
  */
  const fetchTranscriptViaInnertube = (
  videoId: string,
  proxyUrl: string,
  ): Effect.Effect<
  YTNodes.TranscriptSegmentList['initial_segments'],
  InnertubeTranscriptFetchError

=>
Effect.gen(function* () {
// 1. Create Innertube client
const client = yield* Effect.tryPromise({
catch: (cause) => new InnertubeClientCreateError({ cause, videoId }),
try: () =>
Innertubejs.create({
fetch: (async (input: RequestInfo | URL, init?: RequestInit) => {
const response = await fetch(input, {
...init,
proxy: proxyUrl,
})
return response
}) as typeof fetch,
generate_session_locally: true,
lang: 'en',
location: 'US',
retrieve_player: false,
}),
})

// 2. Get basic info (includes caption tracks)
const info = yield* Effect.tryPromise({
  catch: (cause) => new InnertubeBasicInfoError({ cause, videoId }),
  try: () => client.getBasicInfo(videoId),
})

// 3. Check for caption tracks
const captionTracks = info.captions?.caption_tracks
if (!captionTracks || captionTracks.length === 0) {
  return yield* Effect.fail(new InnertubeNoCaptionTracksError({ videoId }))
}

// 4. Find English caption track (prefer non-ASR if available)
const englishTrack =
  captionTracks.find((t) => t.language_code === 'en' && t.kind !== 'asr') ||
  captionTracks.find((t) => t.language_code?.startsWith('en')) ||
  captionTracks[0]

if (!englishTrack?.base_url) {
  return yield* Effect.fail(
    new InnertubeNoValidCaptionUrlError({
      availableLanguages: captionTracks.map((t) => t.language_code ?? 'unknown'),
      videoId,
    }),
  )
}

// 5. Fetch timedtext XML
const xml = yield* fetchTimedTextXml(englishTrack.base_url, proxyUrl, videoId)

// 6. Parse XML to segments
const segments = parseTimedTextXml(xml)

if (segments.length === 0) {
  return yield* Effect.fail(new InnertubeTranscriptParseError({ videoId }))
}

// 7. Convert to YouTube.js format
return convertToYouTubeSegments(segments)

})

Only works locally but it doesn't work after deployment.

[izakfilmalter]

@BelNaruto, you need to use a proxy. Most of YouTube.js doesn't work when deployed without a proxy. It's worth picking out a proxy that you can rotate the IP by changing the url. I initially set my URL based off of the video ID that I'm working with. And then I append to that video ID an integer based off of how many retries.

[izakfilmalter]

@BelNaruto I would heavily suggest using something like Cluster from Effect. Making Entities, which is their version of the Actor model for videos, transcripts, channels, playlists. Then creating a service for YouTube.js. This will let you set up a flow where you can easily rotate the proxy, handle the errors, and enforce all the retry logic that your heart desires.

The benefit of using the entities for things like transcripts is that all requests will flow through that entity and get merged together. You can then have caching on these entities by persisting them inside of the storage layer.

This sets you up for a world where the only failure that should happen is if YouTube implements a new way of bot blocking. It might take 1 second, it might take 10 seconds, but you will get the transcript, guaranteed.

[BelNaruto]

Thanks for

@BelNaruto I would heavily suggest using something like Cluster from Effect. Making Entities, which is their version of the Actor model for videos, transcripts, channels, playlists. Then creating a service for YouTube.js. This will let you set up a flow where you can easily rotate the proxy, handle the errors, and enforce all the retry logic that your heart desires.

The benefit of using the entities for things like transcripts is that all requests will flow through that entity and get merged together. You can then have caching on these entities by persisting them inside of the storage layer.

This sets you up for a world where the only failure that should happen is if YouTube implements a new way of bot blocking. It might take 1 second, it might take 10 seconds, but you will get the transcript, guaranteed.

I added many logs to check where the error is originating... So I found its here:
const captionTracks = info.captions?.caption_tracks
if (!captionTracks || captionTracks.length === 0) {
throw new Error('No caption tracks found')
}

It always returns 'No caption tracks found', and I tried to log also the entire 'info' and it had a reason: 'Sign in to confirm you’re not a bot', which means it's not returning the captionUrl to make the request.

If you don't mind me asking, what server provider are you using?