Downloading Media Files from Google Drive in C#

Welcome to the first lesson of our course on end-to-end media transcription in C#. In this unit, you will learn how to download media files directly from Google Drive using C#. This is an important skill because many media files — such as videos or audio recordings — are often shared via Google Drive, and downloading them programmatically is not as straightforward as downloading from a regular web link. Google Drive uses special URL formats and sometimes requires extra steps to access files, especially if they are large or shared in different ways.

By the end of this lesson, you will understand how to identify Google Drive links, extract the necessary file information, and download the file to your local environment using C#. This will set the foundation for later lessons, where you will process and transcribe these media files.

Google Drive URLs are not like typical direct download links. Instead, they often look like this:

https://drive.google.com/file/d/1UB-sWNzDOC-xjLL9xZkTr11e7KXtOg5y/view?usp=sharing

or sometimes like this:

https://drive.google.com/open?id=1UB-sWNzDOC-xjLL9xZkTr11e7KXtOg5y

Notice that the file’s unique identifier (the file ID) is hidden inside the URL, either as part of the path or as a query parameter. To download a file, you need to extract this file ID and use it to build a special download link. This is why parsing the URL correctly is so important. If you do not extract the file ID properly, your download will fail, or you might get an HTML page instead of the actual file.

To make downloading from Google Drive easier, we use a helper class called GoogleDriveService. This class is designed to handle all the tricky parts of working with Google Drive links. In the context of media transcription, this class allows you to fetch media files from Google Drive so you can later process and transcribe them.

The main responsibilities of this class are to:

1. Check if a given URL is a Google Drive link.
2. Extract the file ID from the URL.
3. Download the file using the correct download link, handling any redirects or confirmation steps that Google Drive might require.

By using this class, you do not have to worry about the details of Google Drive’s URL formats or download process. You can simply provide a link and let the class handle the rest.

The first step is to check if a given URL is a Google Drive link. The IsGoogleDriveUrl method does this:

private bool IsGoogleDriveUrl(string url)
{
    return url.Contains("drive.google.com");
}

This simple check ensures that only Google Drive links are processed by the service.

A key part of downloading from Google Drive is extracting the file ID from the URL. The GetFileId method in the GoogleDriveService class is responsible for this. It checks for three main types of Google Drive URLs using precise string matching.

First, it looks for URLs that start with the complete prefix https://drive.google.com/file/d/, such as:

https://drive.google.com/file/d/1UB-sWNzDOC-xjLL9xZkTr11e7KXtOg5y/view?usp=sharing

In this case, the method extracts everything after the prefix and takes the first segment before any forward slash, which is the file ID.

Second, it handles URLs that start with https://drive.google.com/open, such as:

https://drive.google.com/open?id=1UB-sWNzDOC-xjLL9xZkTr11e7KXtOg5y

Here, it creates a Uri object and uses HttpUtility.ParseQueryString to properly parse the query parameters and retrieve the value of the id parameter.

Third, it also supports URLs that start with https://drive.google.com/uc, such as:

https://drive.google.com/uc?id=1UB-sWNzDOC-xjLL9xZkTr11e7KXtOg5y&export=download

This case is handled similarly to the previous one, by parsing the query string and extracting the id parameter.

The relevant code for extracting the file ID looks like this:

public string? GetFileId(string url)
{
    const string googleDriveFileIdPrefix = "https://drive.google.com/file/d/";
    if (url.StartsWith(googleDriveFileIdPrefix))
    {
        return url[googleDriveFileIdPrefix.Length..].Split('/')[0];
    }

    const string googleDriveFileOpenPrefix = "https://drive.google.com/open";
    if (url.StartsWith(googleDriveFileOpenPrefix))
    {
        Uri uri = new(url);
        var query = System.Web.HttpUtility.ParseQueryString(uri.Query);
        return query["id"];
    }

    const string googleDriveUcPrefix = "https://drive.google.com/uc";
    if (url.StartsWith(googleDriveUcPrefix))
    {
        Uri uri = new(url);
        var query = System.Web.HttpUtility.ParseQueryString(uri.Query);
        return query["id"];
    }

    return null;
}

If the URL does not match any of these formats, the method returns null, indicating that it could not find a file ID. This approach ensures that the download process will work reliably for the most common types of Google Drive links, including direct download links using the /uc endpoint.

Once the file ID is extracted, the DownloadFileAsync method takes over. This method builds a special download URL using the file ID:

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

It then sends an HTTP request to this URL. Sometimes, Google Drive requires a confirmation step for large files or files that are downloaded often. In these cases, the response is an HTML page with a special confirmation link. The method uses a regular expression to find this link in the HTML, then follows it to start the actual download.

Here is the relevant code for downloading the file:

public async Task<string> DownloadFileAsync(string url)
{
    if (!IsGoogleDriveUrl(url))
        throw new ArgumentException("URL is not a valid Google Drive link.");

    var fileId = GetFileId(url);
    if (fileId == null)
        throw new ArgumentException("Could not extract file ID from the provided URL.");

    var downloadUrl = $"https://drive.google.com/uc?id={fileId}&export=download";
    using var httpClient = new HttpClient();
    using var response = await httpClient.GetAsync(downloadUrl);
    var content = await response.Content.ReadAsStringAsync();

    // Check for confirmation page (for large files)
    var confirmMatch = Regex.Match(content, @"confirm=([0-9A-Za-z_]+)");
    if (confirmMatch.Success)
    {
        var confirmToken = confirmMatch.Groups[1].Value;
        var confirmUrl = $"https://drive.google.com/uc?export=download&id={fileId}&confirm={confirmToken}";
        using var confirmResponse = await httpClient.GetAsync(confirmUrl);
        return await SaveToTempFileAsync(await confirmResponse.Content.ReadAsStreamAsync());
    }
    else
    {
        // Direct download
        return await SaveToTempFileAsync(await response.Content.ReadAsStreamAsync());
    }
}

The method uses the IsGoogleDriveUrl and GetFileId methods we discussed above to validate the URL and extract the file ID before starting the download process.

The file is saved to a temporary location on your computer, using a unique file name. The method checks that the file is not empty before finishing. If anything goes wrong — such as an invalid URL, missing file ID, or download error — the method throws an exception with a helpful message.

Why do we need confirmMatch?
When you try to download a large file or a file that Google Drive wants to scan for viruses, Google Drive does not immediately return the file. Instead, it returns an HTML page asking for confirmation. The confirmMatch variable is used to detect if this confirmation is needed by searching for a special token in the HTML. If found, the code uses this token to build a new download URL that bypasses the warning and starts the actual file download.

The helper method for saving the file is:

private async Task<string> SaveToTempFileAsync(Stream stream)
{
    var tempFile = Path.Combine(Path.GetTempPath(), $"{Guid.NewGuid()}.mp4");
    using (var fileStream = File.Create(tempFile))
    {
        await stream.CopyToAsync(fileStream);
    }
    var fileInfo = new FileInfo(tempFile);
    if (fileInfo.Length == 0)
        throw new Exception("Downloaded file is empty.");
    return tempFile;
}

For example, when you run the download, you might see output like:

Attempting to download from Google Drive...
Downloading file to: C:\Users\Student\AppData\Local\Temp\c2f1e8b2-3e2a-4b1a-9c2e-1a2b3c4d5e6f.mp4
Download complete.

This shows the progress and the location of the downloaded file.

In your main application, you use the GoogleDriveService class to download a file and display information about it. Here is how it looks in Program.cs:

using MediaTranscriber;
using System;
using System.IO;
using System.Threading.Tasks;

var mediaUrl = "https://drive.google.com/file/d/1UB-sWNzDOC-xjLL9xZkTr11e7KXtOg5y/view?usp=sharing";

var googleDriveService = new GoogleDriveService();

try
{
    // --- Download Video ---
    Console.WriteLine("Downloading video...");
    var downloadedVideoPath = await googleDriveService.DownloadFileAsync(mediaUrl);
    Console.WriteLine($"Video downloaded to: {downloadedVideoPath}");

    // --- Print File Information ---
    var fileInfo = new FileInfo(downloadedVideoPath);
    Console.WriteLine($"File name: {fileInfo.Name}");
    Console.WriteLine($"File size: {fileInfo.Length / 1024.0 / 1024.0:F2} MB");
    Console.WriteLine($"File path: {fileInfo.FullName}");
}
catch (Exception ex)
{
    Console.ForegroundColor = ConsoleColor.Red;
    Console.WriteLine($"\nAn error occurred: {ex.Message}");
    Console.ResetColor();
}

When you run this code, you will see output similar to:

Downloading video...
Attempting to download from Google Drive...
Downloading file to: C:\Users\Student\AppData\Local\Temp\c2f1e8b2-3e2a-4b1a-9c2e-1a2b3c4d5e6f.mp4
Download complete.
Video downloaded to: C:\Users\Student\AppData\Local\Temp\c2f1e8b2-3e2a-4b1a-9c2e-1a2b3c4d5e6f.mp4
File name: c2f1e8b2-3e2a-4b1a-9c2e-1a2b3c4d5e6f.mp4
File size: 12.34 MB
File path: C:\Users\Student\AppData\Local\Temp\c2f1e8b2-3e2a-4b1a-9c2e-1a2b3c4d5e6f.mp4

This shows that the file was downloaded successfully and provides details about the file, such as its name, size, and location.

In this lesson, you learned how to download files from Google Drive using C#. You saw how to identify Google Drive URLs, extract the file ID, and handle the download process — including any extra confirmation steps required by Google Drive. You also learned how to use the GoogleDriveService class in a real application to download a file and display its details.

These skills are essential for working with media files stored on Google Drive, especially if you want to automate the process of downloading and transcribing media. In the next section, you will get hands-on practice with these concepts, so you can confidently download files from Google Drive in your own projects.