diff --git a/docs/es-modules/subtitles-and-captions.html b/docs/es-modules/subtitles-and-captions.html
index 5c255318f..4b2f482c6 100644
--- a/docs/es-modules/subtitles-and-captions.html
+++ b/docs/es-modules/subtitles-and-captions.html
@@ -124,7 +124,6 @@ <h4 class="mt-4 mb-2">Translated Transcript</h4>
     <script type="module">
       import { videoPlayer } from 'cloudinary-video-player';
       import 'cloudinary-video-player/playlist';
-      import 'cloudinary-video-player/srt-text-tracks';
 
       import 'cloudinary-video-player/cld-video-player.min.css';
 
diff --git a/src/index.all.js b/src/index.all.js
index 5ebcb71a4..197791261 100644
--- a/src/index.all.js
+++ b/src/index.all.js
@@ -15,7 +15,7 @@ export * from './plugins/ima/ima.js';
 export * from './plugins/playlist/playlist.js';
 export * from './plugins/interaction-areas/interaction-areas.service.js';
 export * from './plugins/visual-search/visual-search.js';
-export * from './plugins/srt-text-tracks/srt-text-tracks.js';
+export * from './plugins/text-tracks-manager/index.js';
 export * from './plugins/share/share.js';
 export * from './components/shoppable-bar/shoppable-widget.js';
 export * from './components/recommendations-overlay/recommendations-overlay.js';
diff --git a/src/plugins/index.js b/src/plugins/index.js
index 0de4b3b0a..f370a57c2 100644
--- a/src/plugins/index.js
+++ b/src/plugins/index.js
@@ -7,7 +7,6 @@ import cloudinary from './cloudinary';
 import cloudinaryAnalytics from './cloudinary-analytics';
 import contextMenu from './context-menu';
 import floatingPlayer from './floating-player';
-import pacedTranscript from './paced-transcript';
 import styledTextTracks from './styled-text-tracks';
 import vttThumbnails from './vtt-thumbnails';
 
@@ -18,10 +17,10 @@ import imaPlugin from './ima';
 import interactionAreas from './interaction-areas';
 import playlist from './playlist';
 import shoppable from './shoppable-plugin';
-import srtTextTracks from './srt-text-tracks';
 import visualSearch from './visual-search';
 import share from './share';
 import adaptiveStreaming from './adaptive-streaming';
+import textTracksManager from './text-tracks-manager';
 
 const plugins = {
   aiHighlightsGraph,
@@ -31,7 +30,6 @@ const plugins = {
   cloudinaryAnalytics,
   contextMenu,
   floatingPlayer,
-  pacedTranscript,
   styledTextTracks,
   vttThumbnails,
 
@@ -41,11 +39,11 @@ const plugins = {
   imaPlugin,
   playlist,
   shoppable,
-  srtTextTracks,
   interactionAreas,
   visualSearch,
   share,
-  adaptiveStreaming
+  adaptiveStreaming,
+  textTracksManager,
 };
 
 export default plugins;
diff --git a/src/plugins/paced-transcript/index.js b/src/plugins/paced-transcript/index.js
deleted file mode 100644
index 3d78c1a69..000000000
--- a/src/plugins/paced-transcript/index.js
+++ /dev/null
@@ -1,148 +0,0 @@
-import { getCloudinaryUrlPrefix } from '../cloudinary/common';
-import { utf8ToBase64 } from '../../utils/utf8Base64';
-
-const fallbackFetch = async (url, fallback) => {
-  try {
-    const response = await fetch(url);
-    if (!response.ok) {
-      throw new Error(`Failed fetching from ${url} with status code ${response.status}`);
-    }
-    return response;
-  } catch (error) {
-    console.error(error);
-    if (fallback) {
-      return fallbackFetch(fallback);
-    }
-  }
-};
-
-function pacedTranscript(config) {
-  const player = this;
-
-  const options = {
-    kind: config.kind || 'captions',
-    label: config.label || 'Captions',
-    default: config.default,
-    srclang: config.srclang,
-    src: config.src,
-    maxWords: config.maxWords,
-    wordHighlight: config.wordHighlight,
-    timeOffset: config.timeOffset || 0
-  };
-
-  const classNames = player.textTrackDisplay.el().classList;
-  classNames.add('cld-paced-text-tracks');
-
-  const getTranscriptionFileUrl = (urlPrefix, deliveryType, publicId, languageCode = null) =>
-    `${urlPrefix}/_applet_/video_service/transcription/${deliveryType}/${languageCode ? `${languageCode}/` : ''}${utf8ToBase64(publicId)}.transcript`;
-
-  // Load the transcription file
-  const initTranscript = async () => {
-
-    let transcriptResponse;
-    if (options.src) {
-      // Fetch from src, if explicitly provided
-      transcriptResponse = await fallbackFetch(options.src);
-    } else {
-      // If not, and provided language, try fetching translated transcript, fallback to base transcript
-      const source = player.cloudinary.source();
-      const sourcePublicId = source.publicId();
-      const sourceDeliveryType = source.resourceConfig().type;
-      const urlPrefix = getCloudinaryUrlPrefix(player.cloudinary.cloudinaryConfig());
-      const transcriptionFileUrl = getTranscriptionFileUrl(urlPrefix, sourceDeliveryType, sourcePublicId);
-
-      if (options.srclang) {
-        const transcriptionTranslationFileUrl = getTranscriptionFileUrl(urlPrefix, sourceDeliveryType, sourcePublicId, options.srclang);
-        transcriptResponse = await fallbackFetch(transcriptionTranslationFileUrl, transcriptionFileUrl);
-      } else {
-        transcriptResponse = await fallbackFetch(transcriptionFileUrl);
-      }
-    }
-    if (!transcriptResponse?.ok) return;
-    const transcriptData = await transcriptResponse.json();
-    const captions = parseTranscript(transcriptData);
-
-    const captionsTrack = player.addRemoteTextTrack({
-      kind: options.kind,
-      label: options.label,
-      srclang: options.srclang,
-      default: options.default,
-      mode: options.default ? 'showing' : 'disabled'
-    });
-
-    captions.forEach(caption => {
-      captionsTrack.track.addCue(new VTTCue(caption.startTime, caption.endTime, caption.text));
-    });
-  };
-
-  // Generate captions from the transcription data
-  const parseTranscript = transcriptionData => {
-    const captions = [];
-
-    const addCaption = ({ startTime, endTime, text }) => {
-      captions.push({
-        startTime: startTime + options.timeOffset,
-        endTime: endTime + options.timeOffset,
-        text
-      });
-    };
-
-    transcriptionData.forEach(segment => {
-      const words = segment.words;
-
-      if (words) {
-        const maxWords = options.maxWords || words.length;
-        for (let i = 0; i < words.length; i += maxWords) {
-          if (options.wordHighlight) {
-            // Create a caption for every word, in which the current word is highlighted
-            words.slice(i, Math.min(i + maxWords, words.length)).forEach((word, idx) => {
-              addCaption({
-                startTime: word.start_time,
-                endTime: word.end_time,
-                text: words
-                  .slice(i, i + maxWords)
-                  .map(w => (w === word ? `<b>${w.word}</b>` : w.word))
-                  .join(' ')
-              });
-
-              // if we haven't reached the end of the words array, and there's a gap between the current word end_time and the next word start_time, add a non-highlighted caption to fill the gap
-              if (words[idx + 1] && word.end_time < words[idx + 1].start_time) {
-                addCaption({
-                  startTime: word.end_time,
-                  endTime: words[idx + 1].start_time,
-                  text: words
-                    .slice(i, i + maxWords)
-                    .map(word => word.word)
-                    .join(' ')
-                });
-              }
-            });
-          } else {
-            captions.push({
-              startTime: words[i].start_time,
-              endTime: words[Math.min(i + maxWords - 1, words.length - 1)].end_time,
-              text: words
-                .slice(i, i + maxWords)
-                .map(word => word.word)
-                .join(' ')
-            });
-          }
-        }
-      } else {
-        addCaption({
-          startTime: segment.start_time,
-          endTime: segment.end_time,
-          text: segment.transcript
-        });
-      }
-    });
-
-    return captions;
-  };
-
-  player.one('loadedmetadata', () => {
-    initTranscript();
-  });
-}
-
-export default pacedTranscript;
diff --git a/src/plugins/srt-text-tracks/index.js b/src/plugins/srt-text-tracks/index.js
deleted file mode 100644
index 8b6569767..000000000
--- a/src/plugins/srt-text-tracks/index.js
+++ /dev/null
@@ -1,9 +0,0 @@
-export default async function lazySrtTextTracksPlugin(config) {
-  const player = this;
-  try {
-    const { default: srtTextTracks } = await import(/* webpackChunkName: "srt-text-tracks" */ './srt-text-tracks');
-    player.ready(() => srtTextTracks(config, player));
-  } catch (error) {
-    console.error('Failed to load srt-text-tracks plugin:', error);
-  }
-}
diff --git a/src/plugins/srt-text-tracks/srt-text-tracks.js b/src/plugins/srt-text-tracks/srt-text-tracks.js
deleted file mode 100644
index 648d9face..000000000
--- a/src/plugins/srt-text-tracks/srt-text-tracks.js
+++ /dev/null
@@ -1,56 +0,0 @@
-import srtParser2 from 'srt-parser-2';
-
-function srtTextTracks(config, player) {
-  // Load the SRT file and convert it to WebVTT
-  const initSRT = async () => {
-    let srtResponse;
-    if (config.src) {
-      try {
-        srtResponse = await fetch(config.src);
-        if (!srtResponse.ok) {
-          throw new Error(`Failed fetching from ${config.src} with status code ${srtResponse.status}`);
-        }
-      } catch (error) {
-        console.error(error);
-      }
-    }
-    if (!srtResponse.ok) return;
-
-    const srtData = await srtResponse.text();
-    const webvttCues = srt2webvtt(srtData); // Get the array of cues
-
-    const srtTrack = player.addRemoteTextTrack({
-      kind: config.kind || 'subtitles',
-      label: config.label || 'Subtitles',
-      srclang: config.srclang,
-      default: config.default,
-      mode: config.default ? 'showing' : 'disabled'
-    });
-
-    // Add the WebVTT data to the track
-    webvttCues.forEach(cue => {
-      if (cue) {
-        srtTrack.track.addCue(new VTTCue(cue.startTime, cue.endTime, cue.text));
-      }
-    });
-  };
-
-  player.one('loadedmetadata', () => {
-    initSRT();
-  });
-}
-
-// SRT parser
-const srt2webvtt = data => {
-  const SRTParser = new srtParser2();
-
-  const cues = SRTParser.fromSrt(data);
-
-  return cues.map(cue => ({
-    startTime: cue.startSeconds,
-    endTime: cue.endSeconds,
-    text: cue.text
-  }));
-};
-
-export default srtTextTracks;
diff --git a/src/plugins/text-tracks-manager/index.js b/src/plugins/text-tracks-manager/index.js
new file mode 100644
index 000000000..c7479cd3e
--- /dev/null
+++ b/src/plugins/text-tracks-manager/index.js
@@ -0,0 +1,198 @@
+import { utf8ToBase64 } from '../../utils/utf8Base64';
+import { getCloudinaryUrlPrefix } from '../cloudinary/common';
+import { transcriptParser } from './parsers/transcriptParser';
+import { srtParser } from './parsers/srtParser';
+import { vttParser } from './parsers/vttParser';
+import { addNotificationCue, addTextTrackCues, fetchFileContent, refreshTextTrack, removeAllTextTrackCues } from './utils';
+
+const getTranscriptionFileUrl = (urlPrefix, deliveryType, publicId, languageCode = null) =>
+  `${urlPrefix}/_applet_/video_service/transcription/${deliveryType}/${languageCode ? `${languageCode}/` : ''}${utf8ToBase64(publicId)}.transcript`;
+
+function textTracksManager() {
+  const player = this;
+  const textTracksData = new WeakMap();
+  let activeTrack = null;
+
+  const removeAllTextTracks = () => {
+    const currentTracks = player.remoteTextTracks();
+    if (currentTracks) {
+      for (let i = currentTracks.tracks_.length - 1; i >= 0; i--) {
+        player.removeRemoteTextTrack(currentTracks.tracks_[i]);
+      }
+    }
+  };
+
+  const createTextTrackData = (textTrack, loadMethod) => {
+    const controller = new AbortController();
+    textTracksData.set(textTrack, {
+      status: 'idle',
+      load: async () => {
+        const { status } = textTracksData.get(textTrack);
+        if (status === 'idle') {
+          await loadMethod(controller.signal);
+          refreshTextTrack(textTrack);
+        }
+      },
+      abortLoading: () => {
+        const { status } = textTracksData.get(textTrack);
+        if (status === 'pending') {
+          controller.abort();
+        }
+      },
+    });
+  };
+
+  const updateTextTrackData = (textTrack, dataToUpdate) => {
+    const existingData = textTracksData.get(textTrack);
+    textTracksData.set(textTrack, {
+      ...existingData,
+      ...dataToUpdate,
+    });
+  };
+  const updateTextTrackStatusToPending = (textTrack) => updateTextTrackData(textTrack, { status: 'pending' });
+  const updateTextTrackStatusToSuccess = (textTrack) => updateTextTrackData(textTrack, { status: 'success' });
+  const updateTextTrackStatusToError = (textTrack, error) => updateTextTrackData(textTrack, { status: 'error', error });
+  const updateTextTrackStatusToApplied = (textTrack) => updateTextTrackData(textTrack, { status: 'applied' });
+
+  const addTextTrack = (type, config) => {
+    const {
+      kind = type === 'transcript' ? 'captions' : 'subtitles',
+      label = type === 'transcript' ? 'Captions' : 'Subtitles',
+      default: isDefault,
+      srclang,
+      src,
+    } = config;
+
+    if (type === 'transcript') {
+      player.textTrackDisplay.el().classList.add('cld-paced-text-tracks');
+    }
+
+    const { track } = player.addRemoteTextTrack({
+      kind,
+      label,
+      srclang,
+      default: isDefault,
+      mode: isDefault ? 'showing' : 'disabled',
+    });
+
+    const createParser = () => {
+      if (type === 'srt') return srtParser;
+      if (type === 'vtt') return vttParser;
+      return (text) => transcriptParser(text, {
+        maxWords: config.maxWords,
+        wordHighlight: config.wordHighlight,
+        timeOffset: config.timeOffset ?? 0,
+      });
+    };
+
+    const createUrlFallbacks = () => {
+      if (src) return [src, undefined];
+      if (type !== 'transcript') return [];
+
+      const source = player.cloudinary.source();
+      const publicId = source.publicId();
+      const deliveryType = source.resourceConfig().type;
+      const urlPrefix = getCloudinaryUrlPrefix(player.cloudinary.cloudinaryConfig());
+      const baseUrl = getTranscriptionFileUrl(urlPrefix, deliveryType, publicId);
+      const localizedUrl = srclang ? getTranscriptionFileUrl(urlPrefix, deliveryType, publicId, srclang) : null;
+
+      return localizedUrl ? [localizedUrl, baseUrl] : [baseUrl, undefined];
+    };
+
+    createTextTrackData(track, async (signal) => {
+      updateTextTrackStatusToPending(track);
+
+      const urls = createUrlFallbacks();
+      const response = await fetchFileContent(
+        ...urls,
+        {
+          signal,
+          polling: type === 'transcript' && !src,
+          interval: 2000,
+          maxAttempts: 10,
+          responseStatusAsPending: 202,
+          onSuccess: () => updateTextTrackStatusToSuccess(track),
+          onError: (error) => {
+            updateTextTrackStatusToError(track, error);
+            addNotificationCue(player.duration(), track, 'Text track could not be loaded');
+          },
+          onAttempt: type === 'transcript' ? (count) => {
+            if (count === 2) {
+              addNotificationCue(player.duration(), track, 'Loading text track...');
+            }
+          } : undefined,
+        }
+      );
+
+      if (response) {
+        const parser = createParser();
+        const data = await parser(response);
+        removeAllTextTrackCues(track);
+        addTextTrackCues(track, data);
+        updateTextTrackStatusToApplied(track);
+      }
+    });
+  };
+
+
+  const addTextTracks = (textTracks) => {
+    textTracks.forEach(textTrackConfig => {
+      if (textTrackConfig.src && textTrackConfig.src.endsWith('.vtt')) {
+        addTextTrack('vtt', textTrackConfig);
+      } else if (textTrackConfig.src && textTrackConfig.src.endsWith('.srt')) {
+        addTextTrack('srt', textTrackConfig);
+      } else if (!textTrackConfig.src || textTrackConfig.src.endsWith('.transcript')) {
+        addTextTrack('transcript', textTrackConfig);
+      }
+    });
+
+    const defaultTextTrack = Array.from(player.remoteTextTracks()).find((textTrack) => textTrack.default);
+    if (defaultTextTrack) {
+      onChangeActiveTrack(defaultTextTrack);
+    }
+  };
+
+  const onChangeActiveTrack = (textTrack) => {
+    const prevActiveTrack = activeTrack;
+    activeTrack = textTrack;
+
+    const prevTextTrackData = textTracksData.get(prevActiveTrack);
+    if (prevTextTrackData) {
+      prevTextTrackData.abortLoading();
+    }
+
+    const selectedTextTrackData = textTracksData.get(activeTrack);
+    if (selectedTextTrackData) {
+      selectedTextTrackData.load();
+    }
+  };
+
+  player.on('texttrackchange', () => {
+    const textTracks = player.textTracks();
+    let newActiveTrack = null;
+
+    for (let i = 0; i < textTracks.length; i++) {
+      const track = textTracks[i];
+
+      if (track.mode === 'showing') {
+        newActiveTrack = track;
+        break;
+      }
+    }
+
+    if (activeTrack !== newActiveTrack) {
+      onChangeActiveTrack(newActiveTrack);
+    }
+  });
+
+  return {
+    removeAllTextTracks,
+    addTextTracks: (...args) => {
+      player.one('loadedmetadata', () => {
+        addTextTracks(...args);
+      });
+    },
+  };
+}
+
+export default textTracksManager;
diff --git a/src/plugins/text-tracks-manager/parsers/srtParser.js b/src/plugins/text-tracks-manager/parsers/srtParser.js
new file mode 100644
index 000000000..b9a7981ae
--- /dev/null
+++ b/src/plugins/text-tracks-manager/parsers/srtParser.js
@@ -0,0 +1,11 @@
+import srtParser2 from 'srt-parser-2';
+
+export const srtParser = async (fileContent) => {
+  const SRTParser = new srtParser2();
+  const cues = SRTParser.fromSrt(fileContent);
+  return cues.filter((v) => v).map(cue => ({
+    startTime: cue.startSeconds,
+    endTime: cue.endSeconds,
+    text: cue.text
+  }));
+};
diff --git a/src/plugins/text-tracks-manager/parsers/transcriptParser.js b/src/plugins/text-tracks-manager/parsers/transcriptParser.js
new file mode 100644
index 000000000..8700703a3
--- /dev/null
+++ b/src/plugins/text-tracks-manager/parsers/transcriptParser.js
@@ -0,0 +1,68 @@
+const parseTranscript = (transcriptionData, options) => {
+  const captions = [];
+
+  const addCaption = ({ startTime, endTime, text }) => {
+    captions.push({
+      startTime: startTime + options.timeOffset,
+      endTime: endTime + options.timeOffset,
+      text
+    });
+  };
+
+  transcriptionData.forEach(segment => {
+    const words = segment.words;
+
+    if (words) {
+      const maxWords = options.maxWords || words.length;
+      for (let i = 0; i < words.length; i += maxWords) {
+        if (options.wordHighlight) {
+          // Create a caption for every word, in which the current word is highlighted
+          words.slice(i, Math.min(i + maxWords, words.length)).forEach((word, idx) => {
+            addCaption({
+              startTime: word.start_time,
+              endTime: word.end_time,
+              text: words
+                .slice(i, i + maxWords)
+                .map(w => (w === word ? `<b>${w.word}</b>` : w.word))
+                .join(' ')
+            });
+
+            // if we haven't reached the end of the words array, and there's a gap between the current word end_time and the next word start_time, add a non-highlighted caption to fill the gap
+            if (words[idx + 1] && word.end_time < words[idx + 1].start_time) {
+              addCaption({
+                startTime: word.end_time,
+                endTime: words[idx + 1].start_time,
+                text: words
+                  .slice(i, i + maxWords)
+                  .map(word => word.word)
+                  .join(' ')
+              });
+            }
+          });
+        } else {
+          captions.push({
+            startTime: words[i].start_time,
+            endTime: words[Math.min(i + maxWords - 1, words.length - 1)].end_time,
+            text: words
+              .slice(i, i + maxWords)
+              .map(word => word.word)
+              .join(' ')
+          });
+        }
+      }
+    } else {
+      addCaption({
+        startTime: segment.start_time,
+        endTime: segment.end_time,
+        text: segment.transcript
+      });
+    }
+  });
+
+  return captions;
+};
+
+export const transcriptParser = async (fileContent, options) => {
+  const data = JSON.parse(fileContent);
+  return parseTranscript(data, options);
+};
diff --git a/src/plugins/text-tracks-manager/parsers/vttParser.js b/src/plugins/text-tracks-manager/parsers/vttParser.js
new file mode 100644
index 000000000..33675dd15
--- /dev/null
+++ b/src/plugins/text-tracks-manager/parsers/vttParser.js
@@ -0,0 +1,65 @@
+export const vttParser = async (fileContent) => {
+  const lines = fileContent.trim().split(/\r?\n/);
+  const cues = [];
+  let buffer = [];
+
+  const parseTime = (timeStr) => {
+    const [hms, ms] = timeStr.split('.');
+    const [h, m, s] = hms.split(':').map(Number);
+    return h * 3600 + m * 60 + s + (parseFloat(`0.${ms}`) || 0);
+  };
+
+  const parseCueBlock = (blockLines) => {
+    const cueLines = blockLines.filter(Boolean);
+    if (cueLines.length < 2) return null;
+
+    const timeLineIdx = cueLines[0].includes('-->') ? 0 : 1;
+    const timeLine = cueLines[timeLineIdx];
+
+    const [startPart, endPartWithSettings] = timeLine.split('-->');
+    const start = startPart.trim();
+
+    const [end, ...cueSettingsParts] = endPartWithSettings.trim().split(/\s+/);
+    const cueSettings = cueSettingsParts.join(' '); // like: line:90% position:50% align:start
+
+    const text = cueLines.slice(timeLineIdx + 1).join('\n').trim();
+
+    return {
+      startTime: parseTime(start),
+      endTime: parseTime(end),
+      text,
+      settings: cueSettings || null,
+    };
+  };
+
+  let inSkipBlock = false;
+
+  for (const line of lines) {
+    if (/^(NOTE|STYLE|REGION)/.test(line.trim())) {
+      inSkipBlock = true;
+      continue;
+    }
+
+    if (inSkipBlock && line.trim() === '') {
+      inSkipBlock = false;
+      continue;
+    }
+
+    if (inSkipBlock) continue;
+
+    if (line.trim() === '') {
+      const cue = parseCueBlock(buffer);
+      if (cue) cues.push(cue);
+      buffer = [];
+    } else {
+      buffer.push(line);
+    }
+  }
+
+  if (buffer.length > 0) {
+    const cue = parseCueBlock(buffer);
+    if (cue) cues.push(cue);
+  }
+
+  return cues;
+};
diff --git a/src/plugins/text-tracks-manager/utils.js b/src/plugins/text-tracks-manager/utils.js
new file mode 100644
index 000000000..1b97fd170
--- /dev/null
+++ b/src/plugins/text-tracks-manager/utils.js
@@ -0,0 +1,139 @@
+export const fetchFileContent = async (
+  url,
+  fallbackUrl,
+  config = {}
+) => {
+  const {
+    polling = false,
+    interval = 3000,
+    maxAttempts = 10,
+    signal,
+    onSuccess,
+    onError,
+    onAttempt
+  } = config;
+
+  let attempts = 0;
+
+  const attemptFetch = async (currentUrl) => {
+    if (signal?.aborted) {
+      throw new DOMException('Aborted', 'AbortError');
+    }
+
+    attempts++;
+    onAttempt?.(attempts);
+
+    const response = await fetch(currentUrl, { signal });
+
+    if (response.status === 202 && polling) {
+      if (attempts < maxAttempts) {
+        return new Promise((resolve, reject) => {
+          const timeoutId = setTimeout(() => {
+            attemptFetch(url).then(resolve).catch(reject);
+          }, interval);
+
+          signal?.addEventListener('abort', () => {
+            clearTimeout(timeoutId);
+            reject(new DOMException('Aborted', 'AbortError'));
+          }, { once: true });
+        });
+      } else {
+        throw new Error(`Polling max attempts reached (${maxAttempts}) for ${url}`);
+      }
+    }
+
+    if (!response.ok) {
+      if (fallbackUrl) {
+        return attemptFetch(fallbackUrl);
+      }
+      throw new Error(`Failed fetching from ${currentUrl} with status code ${response.status}`);
+    }
+
+    const text = await response.text();
+    onSuccess?.(text);
+    return text;
+  };
+
+  try {
+    return await attemptFetch(url);
+  } catch (error) {
+    if (error.name === 'AbortError') {
+      console.warn('Polling aborted');
+    } else {
+      console.error(error);
+    }
+
+    onError?.(error);
+  }
+};
+
+export const addTextTrackCues = (textTrack, cues) => {
+  cues.forEach(({ startTime, endTime, text, settings }) => {
+    const cue = new VTTCue(startTime, endTime, text);
+
+    if (settings) {
+      const parsed = settings.split(/\s+/);
+      parsed.forEach(setting => {
+        const [key, value] = setting.split(':');
+        if (!key || !value) return;
+
+        switch (key) {
+          case 'line':
+            cue.line = isNaN(value) ? value : parseFloat(value);
+            break;
+          case 'position':
+            cue.position = parseFloat(value);
+            break;
+          case 'size':
+            cue.size = parseFloat(value);
+            break;
+          case 'align':
+            cue.align = value;
+            break;
+        }
+      });
+    }
+
+    textTrack.addCue(cue);
+  });
+};
+
+export const removeAllTextTrackCues = (textTrack) => {
+  if (!textTrack || !textTrack.cues) return;
+
+  Array.from(textTrack.cues).forEach((cue) => {
+    try {
+      textTrack.removeCue(cue);
+    } catch (e) {
+      console.warn('Failed to remove cue:', cue, e);
+    }
+  });
+};
+
+export const addNotificationCue = (videoDuration, textTrack, text) => {
+  if (!textTrack || !text) return;
+
+  removeAllTextTrackCues(textTrack);
+
+  const fallbackDuration = 3600;
+  const endTime = (
+    typeof videoDuration === 'number' &&
+    isFinite(videoDuration) &&
+    videoDuration > 0
+  ) ? videoDuration : fallbackDuration;
+
+  const cue = new VTTCue(0, endTime, text);
+  textTrack.addCue(cue);
+};
+
+export const refreshTextTrack = (textTrack) => {
+  if (!textTrack || typeof textTrack.mode !== 'string') return;
+
+  const currentMode = textTrack.mode;
+  textTrack.mode = currentMode === 'showing' ? 'hidden' : 'showing';
+
+  // Force back to original after a short delay (just enough to trigger reflow)
+  setTimeout(() => {
+    textTrack.mode = currentMode;
+  }, 0);
+};
diff --git a/src/utils/cloudinary.js b/src/utils/cloudinary.js
index 98adca9e1..ff287dd35 100644
--- a/src/utils/cloudinary.js
+++ b/src/utils/cloudinary.js
@@ -1,7 +1,7 @@
 import { cloudinaryErrorsConverter, ERROR_CODE } from '../plugins/cloudinary/common';
 import { find } from 'utils/find';
 
-const GET_ERROR_DEFAULT_REQUEST = { method: 'head' };
+export const GET_ERROR_DEFAULT_REQUEST = { method: 'head' };
 const ERROR_WITH_GET_REQUEST = { method: 'get', credentials: 'include', headers: { 'Content-Range': 'bytes=0-0' } };
 
 const getGoodSrcs = (srcs, parsedUris) => {
@@ -100,24 +100,7 @@ const isKeyInTransformation = (transformation, key) => {
   return !!transformation[key];
 };
 
-const addTextTracks = (tracks, videojs) => {
-  tracks.forEach(track => {
-    if (track.src && track.src.endsWith('.vtt')) {
-      fetch(track.src, GET_ERROR_DEFAULT_REQUEST).then(r => {
-        if (r.status >= 200 && r.status <= 399) {
-          videojs.addRemoteTextTrack(track, true);
-        }
-      });
-    } else if (track.src && track.src.endsWith('.srt')) {
-      videojs.srtTextTracks(track);
-    } else if (videojs.pacedTranscript && (!track.src || track.src.endsWith('.transcript'))) {
-      videojs.pacedTranscript(track);
-    }
-  });
-};
-
 export {
   handleCldError,
   isKeyInTransformation,
-  addTextTracks
 };
diff --git a/src/video-player.js b/src/video-player.js
index 74af93058..c834375b5 100644
--- a/src/video-player.js
+++ b/src/video-player.js
@@ -211,13 +211,8 @@ class VideoPlayer extends Utils.mixin(Eventable) {
   }
 
   setTextTracks(conf) {
-    // remove current text tracks
-    const currentTracks = this.videojs.remoteTextTracks();
-    if (currentTracks) {
-      for (let i = currentTracks.tracks_.length - 1; i >= 0; i--) {
-        this.videojs.removeRemoteTextTrack(currentTracks.tracks_[i]);
-      }
-    }
+    this.textTracksManager.removeAllTextTracks();
+
     if (conf) {
       const kinds = Object.keys(conf);
       const allTracks = [];
@@ -236,7 +231,8 @@ class VideoPlayer extends Utils.mixin(Eventable) {
           }
         }
       }
-      Utils.addTextTracks(allTracks, this.videojs);
+
+      this.textTracksManager.addTextTracks(allTracks);
 
       if (conf.options && this.videojs.styledTextTracks) {
         this.videojs.styledTextTracks(conf.options);
@@ -382,6 +378,7 @@ class VideoPlayer extends Utils.mixin(Eventable) {
   }
 
   _initTextTracks () {
+    this.textTracksManager = this.videojs.textTracksManager();
     this.videojs.on(PLAYER_EVENT.CLD_SOURCE_CHANGED, (e, { source }) => {
       if (source?._textTracks) {
         this.setTextTracks(source._textTracks);
@@ -526,7 +523,6 @@ class VideoPlayer extends Utils.mixin(Eventable) {
 
     if (source) {
       const sourceOptions = Object.assign({}, this.playerOptions.sourceOptions);
-      
       this.source(source, sourceOptions);
     }
   }
@@ -596,7 +592,7 @@ class VideoPlayer extends Utils.mixin(Eventable) {
         }
       });
     }
-    
+
     if (publicId instanceof VideoSource) {
       return this.videojs.cloudinary.source(publicId, options);
     }
diff --git a/test/unit/cloudinaryUtils.test.js b/test/unit/cloudinaryUtils.test.js
deleted file mode 100644
index 95ec50dc9..000000000
--- a/test/unit/cloudinaryUtils.test.js
+++ /dev/null
@@ -1,48 +0,0 @@
-const tracks = [
-  {
-    default: false,
-    kind: 'subtitles',
-    label: 'German subtitles',
-    src: 'https://res.cloudinary.com/yaronr/raw/upload/v1558966008/Meetup_german.vtt',
-    srclang: 'de'
-  },
-  {
-    default: false,
-    kind: 'subtitles',
-    label: 'Hebrew subtitles',
-    src: 'https://res.cloudinary.com/yaronr/raw/upload/v1558966008/Meetup_hebrew.vtt',
-    srclang: 'he'
-  },
-  {
-    default: false,
-    kind: 'subtitles',
-    label: 'Swedish subtitles',
-    src: 'https://res.cloudinary.com/yaronr/raw/upload/v1558966008/Meetup_swedish.vtt',
-    srclang: 'se'
-  }
-];
-
-global.fetch = jest.fn((url, options) => {
-  return new Promise((resolve) => {
-    if (url === tracks[2].src) {
-      resolve({ status: 404 });
-    } else {
-      resolve({ status: 200 });
-    }
-  });
-});
-
-import { addTextTracks } from '../../src/utils/cloudinary';
-
-describe('video source tests', () => {
-  it('test filter out bad vtt', async () => {
-    let vjs = jest.createMockFromModule('video.js');
-    vjs.addRemoteTextTrack = jest.fn();
-    jest.spyOn(vjs, 'addRemoteTextTrack');
-    addTextTracks(tracks, vjs);
-    setTimeout(() => {
-      expect(vjs.addRemoteTextTrack).toBeCalledTimes(2);
-    }, 1000);
-  });
-
-});