Downloading Google Drive Videos with Go

Welcome! In this lesson, we will explore how to download video files from Google Drive using Go. As we build a robust video transcribing system, it's important to handle files from various sources, including remote locations like Google Drive. In Go, we can achieve this by working with HTTP requests and the standard library, without relying on external tools. By the end of this lesson, you'll know how to recognize Google Drive URLs, extract file IDs, and download files directly using Go.

In this lesson, you'll learn how to:

• Recognize and handle Google Drive URLs in Go.
• Extract the file ID from a Google Drive link using Go's standard library.
• Download videos from a publicly accessible Google Drive link using HTTP requests in Go.
• Understand the limitations and considerations when downloading files from Google Drive.

Before we start coding, let's discuss the approach in Go. Our goal is to download video files from Google Drive. Google Drive URLs contain unique identifiers for each file. The process involves:

1. Checking if a URL is a Google Drive link.
2. Extracting the file ID from the URL.
3. Constructing a direct download link using the file ID.
4. Downloading the file using Go's HTTP client.

Unlike some other languages, Go does not have a built-in library specifically for Google Drive downloads. However, for publicly shared files, we can use the standard library to perform the download by constructing the correct URL.

Important Limitations: The direct download approach using https://drive.google.com/uc?export=download&id=... works well for small files, but large files often trigger Google Drive's confirmation/interstitial page that returns HTML instead of the actual video. For production systems, consider:

• Checking the Content-Type header to detect HTML responses
• Using the official Google Drive API with proper authentication for reliable downloads
• Implementing retry logic or fallback mechanisms

Below are utility functions that provide all the necessary steps to recognize Google Drive URLs, extract file IDs, and download files. This approach keeps the code organized and reusable.

We use Go's net/url and strings packages to check if a given URL is a Google Drive link. To prevent domain spoofing attacks (e.g., drive.google.com.evil.com), we implement secure domain validation:

import (
    "net/url"
    "strings"
)

// Checks if the provided URL is a Google Drive link.
func IsGoogleDriveURL(rawURL string) bool {
    u, err := url.Parse(rawURL)
    if err != nil {
        return false
    }
    return isValidDomain(u.Host, "drive.google.com")
}

// Validates that host matches the expected domain or is a valid subdomain.
// Prevents domain spoofing attacks like "drive.google.com.evil.com".
func isValidDomain(host, expectedDomain string) bool {
    host = strings.ToLower(host)
    // Remove port if present
    if idx := strings.Index(host, ":"); idx != -1 {
        host = host[:idx]
    }
    // Exact match or valid subdomain
    return host == expectedDomain || strings.HasSuffix(host, "."+expectedDomain)
}

Explanation:

• The IsGoogleDriveURL function parses the URL and uses secure domain validation.
• The isValidDomain helper function ensures the host is either an exact match or a valid subdomain of the expected domain.
• It converts the host to lowercase and removes any port information before checking.
• This prevents attackers from using malicious domains like drive.google.com.attacker.io to bypass validation.

Google Drive URLs usually have one of these formats:

• https://drive.google.com/file/d/{fileid}/view
• https://drive.google.com/open?id={fileid}

We can extract the file ID using string manipulation and query parsing:

import (
    "errors"
    "net/url"
    "strings"
)

// Extracts the file ID from a Google Drive URL.
// Supports both /file/d/{fileid}/ and ?id={fileid} formats.
func getGoogleDriveFileID(link string) (string, error) {
    if strings.Contains(link, "/file/d/") {
        parts := strings.Split(link, "/file/d/")
        if len(parts) < 2 {
            return "", errors.New("invalid file ID format")
        }
        return strings.Split(parts[1], "/")[0], nil
    } else if strings.Contains(link, "id=") {
        u, err := url.Parse(link)
        if err != nil {
            return "", err
        }
        id := u.Query().Get("id")
        return id, nil
    }
    return "", errors.New("no file ID found")
}

Explanation:
This function checks for both common URL patterns and extracts the file ID accordingly. It returns an error if the format is invalid or the ID is missing.

With the file ID, we can construct a direct download link and use Go's HTTP client to download the file. For publicly shared files, the download URL is:

https://drive.google.com/uc?export=download&id={fileid}

Here's how you can download the file and save it locally:

import (
    "fmt"
    "io"
    "net/http"
    "os"
    "path/filepath"
    "strings"
    "time"
)

// Downloads a publicly shared Google Drive file and saves it to temp_resources/{fileid}.mp4
func DownloadGoogleDriveFile(link string) (string, error) {
    fmt.Println("Downloading from Google Drive...")
    fileID, err := getGoogleDriveFileID(link)
    if err != nil {
        return "", err
    }
    downloadURL := fmt.Sprintf("https://drive.google.com/uc?export=download&id=%s", fileID)
    output := filepath.Join("temp_resources", fileID+".mp4")

    client := &http.Client{
        Timeout: 30 * time.Minute,
    }
    resp, err := client.Get(downloadURL)
    if err != nil {
        return "", fmt.Errorf("failed to start download: %v", err)
    }
    defer resp.Body.Close()

    if resp.StatusCode != http.StatusOK {
        return "", fmt.Errorf("failed to download file: status %s", resp.Status)
    }

    // Check if we received HTML (confirmation page) instead of the video
    contentType := resp.Header.Get("Content-Type")
    if strings.Contains(contentType, "text/html") {
        return "", fmt.Errorf("received HTML instead of video - file may be too large or require confirmation")
    }

    out, err := os.Create(output)
    if err != nil {
        return "", fmt.Errorf("failed to create file: %v", err)
    }
    defer out.Close()

    n, err := io.Copy(out, resp.Body)
    if err != nil {
        return "", fmt.Errorf("failed to write file: %v", err)
    }

    if n == 0 {
        return "", fmt.Errorf("downloaded file is empty")
    }

    return output, nil
}

Explanation:

• Prints a message to indicate the download is starting.
• Extracts the file ID using getGoogleDriveFileID.
• Constructs the direct download URL for Google Drive.
• Creates an HTTP client with a 30-minute timeout to prevent indefinite hangs.
• Downloads the file using the client's Get method.
• Checks the Content-Type header to detect if Google Drive returned an HTML confirmation page instead of the actual file.
• Saves the file to a temp_resources directory, naming it {fileid}.mp4.
• Checks for errors at each step, including HTTP status and file writing.
• Returns the path to the downloaded file or an error.

Note: This method works best for small to medium-sized files that are shared publicly on Google Drive. For large files, private files, or production systems requiring reliable downloads, use the Google Drive API with OAuth2 authentication, which provides proper error handling and avoids the confirmation page issue.

Being able to download videos from Google Drive using Go is a valuable skill for many applications, such as organizing educational content, analyzing media, or preparing data for further processing. Understanding the limitations of direct downloads helps you choose the right approach for your use case. Always ensure you have permission to download and use the content, and respect any legal or copyright restrictions.

With this foundation, you're ready to implement Google Drive downloads in your own Go projects. Let's move on to the practice section, where you'll apply these techniques in real-world scenarios.