Implementing a LinkedIn Video Downloader with yt-dlp in TypeScript

Implementing LinkedIn Video Downloader with yt-dlp in TypeScript

Welcome to the second unit of the course! In the previous unit, you learned how to extract and preview videos from Google Drive, download them with curl, and transcribe them using FFmpeg and OpenAI Whisper . Now we’re extending our capabilities to support LinkedIn video downloads using yt-dlp — a powerful CLI tool for downloading from social platforms.

What You'll Learn

In this unit, you will: Detect and validate different LinkedIn video URL formats. Understand how yt-dlp is wrapped in a service module for clean use in your backend. Use a unified /process-url route to delegate downloads to either Drive or LinkedIn services. Preview LinkedIn video content and load it into a native player, ready for future transcription.

Recognizing LinkedIn Video URLs

LinkedIn videos often follow these formats: Post-based: https://www.linkedin.com/posts/USERNAME_activity-VIDEO_ID Feed-based: https://www.linkedin.com/feed/update/urn:li:activity:VIDEO_ID To identify these, we use the following function in public/app.js: JavaScriptfunction getLinkedInPostId(url) { const patterns = [ /activity-(\d+)/, // Matches /posts/..._activity-123456 /urn:li:activity:(\d+)/, // Matches urn:li:activity:123456 /urn:li:ugcPost:(\d+)/ // Matches urn:li:ugcPost:123456 ]; for (const pattern of patterns) { const match = url.match(pattern); if (match) return match[1]; } return null; } This function iterates through known LinkedIn post ID patterns and extracts the first valid match. It enables reliable detection of various LinkedIn video link structures.

Previewing LinkedIn Videos in the Browser

We embed the video for preview using an iframe: TypeScriptfunction embedLinkedInPost(postId) { previewFrame.innerHTML = \` <div class="video-wrapper"> <iframe src="https://www.linkedin.com/embed/feed/update/urn:li:activity:\${postId}" frameborder="0" allow="autoplay; encrypted-media" allowfullscreen> </iframe> </div> \`; } This function constructs an iframe URL using the extracted postId. The embedded player helps users verify that they’ve pasted a valid video URL before initiating a download. Note: LinkedIn does not allow iframe embedding for all posts. Previews will only work for public or embed-enabled posts. Private posts or content shared by other users may not render in the iframe due to LinkedIn's content restrictions. If the preview frame remains blank, the video might still be downloadable using yt-dlp, even if it's not viewable in the browser.

Join the 1M+ learners on CodeSignal

Be a part of our community of 1M+ users who develop and demonstrate their skills on CodeSignal

Wrapping yt-dlp with downloadLinkedInVideo

Instead of embedding yt-dlp download logic directly in your route, we isolate it in a reusable backend service. Here's the full implementation:

TypeScript

import fs from 'fs';
import path from 'path';
import { exec } from 'child_process';
import { randomUUID } from 'crypto';

export function downloadLinkedInVideo(
  url: string
): Promise<{ filename: string; duration: number }> {
  return new Promise((resolve, reject) => {
    // Ensure the downloads directory exists
    const downloadDir = path.join(process.cwd(), 'downloads');
    if (!fs.existsSync(downloadDir)) {
      fs.mkdirSync(downloadDir, { recursive: true });
    }

    // Generate a unique filename and resolve the output path
    const fileId = randomUUID();
    const fileName = `${fileId}.mp4`;
    const filePath = path.join(downloadDir, fileName);

    // Resolve the path to the yt-dlp binary
    const ytDlpPath = path.join(process.cwd(), 'bin', 'yt-dlp');

    // Construct the yt-dlp command for downloading as mp4
    const ytdlpCmd =
      `"${ytDlpPath}" -f mp4 -o "${filePath}" "${url}" --quiet --no-warnings`;

    // Execute yt-dlp to download the video
    exec(ytdlpCmd, (downloadErr) => {
      if (downloadErr) {
        return reject(downloadErr);
      }

      // Once downloaded, probe the video to get its duration
      const probeCmd =
        `ffprobe -v error -select_streams v:0 -show_entries format=duration ` +
        `-of default=noprint_wrappers=1:nokey=1 "${filePath}"`;

      exec(probeCmd, (probeErr, stdout) => {
        if (probeErr) {
          return reject(probeErr);
        }

        const duration = parseFloat(stdout) || 0;
        resolve({ filename: fileName, duration });
      });
    });
  });
}

Explanation:

Generates a unique filename using randomUUID()
Constructs and runs a yt-dlp command to download the LinkedIn video
Uses ffprobe to detect video duration
Resolves with the filename and duration — ready to be used in the frontend
Both the filename and duration are returned to the route handler so the file can be loaded and transcribed.

Why this structure works well:

Separation of concerns: Keeps your route logic clean by pushing download responsibilities into a dedicated service.
Cross-platform maintainability: You can reuse or extend this service later to support other platforms (e.g., Twitter, YouTube) with minimal changes.
Scalability: Makes it easier to add caching, file cleanup, or logging logic in the future without rewriting your route handler.