Unable to retrieve the video URL. Ensure the video ID is correct and accessible.

[dangvanhuy2k2]

i got an error after downloading a video a few days ago the code worked fine seems gg drive has had new updates

[cotton1234]

Hello,

I also faced the issue. Issue is for some videos you need to be logged in.
Login to browser. Export the cookie for google and drive.google.com in json file.
Load the file in the script.

Modified Script:

`from urllib.parse import unquote
import requests
import argparse
import sys
from tqdm import tqdm
import os
import json

def load_cookies(cookie_file: str) -> dict:
"""Load cookies from a JSON file and convert to a dictionary."""
try:
with open(cookie_file, 'r') as f:
data = json.load(f)

    # If the data is a list, convert to a dictionary
    if isinstance(data, list):
        cookies = {item['name']: item['value'] for item in data if 'name' in item and 'value' in item}
    else:
        cookies = data  # Assume it's already a dictionary
    return cookies
except Exception as e:
    print(f"Error loading cookies: {e}")
    return {}

def get_video_url(page_content: str, verbose: bool) -> tuple[str, str]:
"""Extracts the video playback URL and title from the page content."""
if verbose:
print("[INFO] Parsing video playback URL and title.")
contentList = page_content.split("&")
video, title = None, None
for content in contentList:
if content.startswith('title=') and not title:
title = unquote(content.split('=')[-1])
elif "videoplayback" in content and not video:
video = unquote(content).split("|")[-1]
if video and title:
break

if verbose:
    print(f"[INFO] Video URL: {video}")
    print(f"[INFO] Video Title: {title}")
return video, title

def download_file(url: str, cookies: dict, filename: str, chunk_size: int, verbose: bool) -> None:
"""Downloads the file from the given URL with provided cookies, supports resuming."""
headers = {}
file_mode = 'wb'

downloaded_size = 0
if os.path.exists(filename):
    downloaded_size = os.path.getsize(filename)
    headers['Range'] = f"bytes={downloaded_size}-"
    file_mode = 'ab'

if verbose:
    print(f"[INFO] Starting download from {url}")
    if downloaded_size > 0:
        print(f"[INFO] Resuming download from byte {downloaded_size}")

response = requests.get(url, stream=True, cookies=cookies, headers=headers)
if response.status_code in (200, 206):  # 200 for new downloads, 206 for partial content
    total_size = int(response.headers.get('content-length', 0)) + downloaded_size
    with open(filename, file_mode) as file:
        with tqdm(total=total_size, initial=downloaded_size, unit='B', unit_scale=True, desc=filename, file=sys.stdout) as pbar:
            for chunk in response.iter_content(chunk_size=chunk_size):
                if chunk:
                    file.write(chunk)
                    pbar.update(len(chunk))
    print(f"\n{filename} downloaded successfully.")
else:
    print(f"Error downloading {filename}, status code: {response.status_code}")

def main(video_id: str, output_file: str = None, chunk_size: int = 1024, verbose: bool = False, cookie_file: str = None) -> None:
"""Main function to process video ID and download the video file."""
drive_url = f'https://drive.google.com/u/0/get_video_info?docid={video_id}&drive_originator_app=303'

# Load cookies from file if provided, else use empty dict
cookies = load_cookies(cookie_file) if cookie_file else {}

if verbose:
    print(f"[INFO] Accessing {drive_url}")
    if cookies:
        print(f"[INFO] Using provided cookies: {list(cookies.keys())}")

response = requests.get(drive_url, cookies=cookies)
page_content = response.text
response_cookies = response.cookies.get_dict()
# Merge response cookies with provided cookies (response cookies take precedence)
cookies.update(response_cookies)

video, title = get_video_url(page_content, verbose)

# Ensure filename has an extension
filename = output_file if output_file else title
if filename and not os.path.splitext(filename)[1]:
    filename += '.mp4'  # Default to .mp4 if no extension

if video:
    download_file(video, cookies, filename, chunk_size, verbose)
else:
    print("Unable to retrieve the video URL. Ensure the video ID is correct, accessible, and cookies are valid.")

if name == "main":
parser = argparse.ArgumentParser(description="Script to download videos from Google Drive.")
parser.add_argument("video_id", type=str, help="The video ID from Google Drive (e.g., 'abc-Qt12kjmS21kjDm2kjd').")
parser.add_argument("-o", "--output", type=str, help="Optional output file name for the downloaded video (default: video name in gdrive).")
parser.add_argument("-c", "--chunk_size", type=int, default=1024, help="Optional chunk size (in bytes) for downloading the video. Default is 1024 bytes.")
parser.add_argument("-v", "--verbose", action="store_true", help="Enable verbose mode.")
parser.add_argument("--cookie-file", type=str, help="Path to JSON file containing cookies for authentication.")
parser.add_argument("--version", action="version", version="%(prog)s 1.0")

args = parser.parse_args()
main(args.video_id, args.output, args.chunk_size, args.verbose, args.cookie_file)

`

Thanks

[davydmaker]

i got an error after downloading a video a few days ago the code worked fine seems gg drive has had new updates

It's working normally here, can you provide more details about the problem?

Is the video actually being shared with other people besides the account owner?