How do I download all files from a Google Drive folder with more than 50 files?

I cannot figure out how to write a program to download all files from a publicly accessible Google Drive folder, which has more than 1,000 of them.

This is what I've tried so far:

import gdown
url = 'https://drive.google.com/drive/folders/MY-PUBLICLY-ACCESSIBLE-FOLDER-ID?usp=drive_link'
gdown.download_folder(url, quiet=True, remaining_ok=True, use_cookies=False)

But it only downloads 50 of the files.

You can use the Google Drive API:

https://developers.google.com/drive/api/quickstart/python

Here is a script I have used in the past:

from googleapiclient.discovery import build
from googleapiclient.http import MediaIoBaseDownload
from google_auth_oauthlib.flow import InstalledAppFlow
import io
import os

# Define the scopes
SCOPES = ['https://www.googleapis.com/auth/drive.readonly']

# Obtain your Google credentials
def get_credentials():
    flow = InstalledAppFlow.from_client_secrets_file('credentials.json', SCOPES)
    creds = flow.run_local_server(port=0)
    return creds

# Build the downloader
creds = get_credentials()
drive_downloader = build('drive', 'v3', credentials=creds)

# Replace 'FOLDER_ID' with your actual Google Drive folder ID
folder_id = 'FOLDER_ID'
query = f"Folder ID '{folder_id}'"
results = drive_downloader.files().list(q=query, pageSize=1000).execute()
items = results.get('files', [])

# Download the files
for item in items:
    request = drive_downloader.files().get_media(fileId=item['id'])
    f = io.FileIO(item['name'], 'wb')
    downloader = MediaIoBaseDownload(f, request)
    done = False
    while done is False:
        status, done = downloader.next_chunk()
        print(f"Download {int(status.progress() * 100)}.")

print(f"Downloaded {len(items)} files from the folder.")

Work Around:

Since gdown's download_folder function doesn't care how many subfolders of 50 files or fewer it has to download we can use the following function to organize the files in the folder you want to save in a new path by creating a temp_folder where all the files are moved into subfolders comprising of 50 files or fewer and then running the gdown's download_folder function:

import os

def organize_folder_into_subfolders(path_to_original_folder, max_number_of_files_per_subfolder=50):
    '''Moves all files in a folder into newly created subfolders comprising of the max_number_of_files_per_subfolder or fewer'''
    files_in_folder = os.listdir(path_to_original_folder)
    if not path_to_original_folder.endswith('/'):
        path_to_original_folder += '/'
    temp_path_to_original_folder = path_to_original_folder + 'temp_folder'
    os.makedirs(temp_path_to_original_folder)
    subfolders_dict = {'temp_subfolder_0': []}
    os.makedirs(temp_path_to_original_folder + '/' + 'temp_subfolder_0')
    for _file_name in files_in_folder:
        if len(subfolders_dict['temp_subfolder_' + str(len(subfolders_dict) - 1)]) == max_number_of_files_per_subfolder:
            subfolders_dict['temp_subfolder_' + str(len(subfolders_dict))] = []
            os.makedirs(temp_path_to_original_folder + '/' + 'temp_subfolder_' + str(len(subfolders_dict) - 1))
        subfolders_dict['temp_subfolder_' + str(len(subfolders_dict) - 1)].append(_file_name)
    for _file_subfolder_path, _file_names in subfolders_dict.items():
        for _file_name in _file_names:
            os.rename(path_to_original_folder + _file_name, temp_path_to_original_folder + '/' + _file_subfolder_path + '/' + _file_name)
    return subfolders_dict

And then run the download_folder function:

import gdown
url = 'https://drive.google.com/drive/folders/1OXV4qhFF_qJ8VqyrXpR7CzHDsToaqY_W?usp=drive_link'
gdown.download_folder(url, quiet=True, use_cookies=False, remaining_ok=True)

And then if you want your original and new folders not organized as subfolders, we can use this function to "undo" or put the files back into the original and new folders and delete the temp subfolders:

import os

def undo_organize_folder_into_subfolders(path_to_original_folder, path_to_new_folder, subfolders_dict):
    '''Moves the files organized as subfolders back to the original & new folders and deletes subfolders'''
    if not path_to_original_folder.endswith('/'):
        path_to_original_folder += '/'
    if not path_to_new_folder.endswith('/'):
        path_to_new_folder += '/'
    temp_path_to_original_folder = path_to_original_folder + 'temp_folder'
    temp_path_to_new_folder = path_to_new_folder + 'temp_folder'
    for _file_subfolder_path, _file_names in subfolders_dict.items():
        for _file_name in _file_names:
            os.rename(temp_path_to_original_folder + '/' + _file_subfolder_path + '/' + _file_name, path_to_original_folder + _file_name)
            os.rename(temp_path_to_new_folder + '/' + _file_subfolder_path + '/' + _file_name, path_to_new_folder + _file_name)
        os.rmdir(temp_path_to_original_folder + '/' + _file_subfolder_path)
        os.rmdir(temp_path_to_new_folder + '/' + _file_subfolder_path)
    os.rmdir(temp_path_to_original_folder)
    os.rmdir(temp_path_to_new_folder)

And just make sure you have your current working directory set:

from google.colab import drive
drive.mount('/content/drive', force_remount=True)
%cd '/content/drive/My Drive/Colab Notebooks/'

The reason you are only able to download 50 files is that the gdown library, by default, uses the "cookie" method to access Google Drive files, and Google Drive has a limitation of 50 for direct downloads using cookies.
You can use the Google Drive API along to download 1000 files with the google-api-python-client library.

You'll need to install the google-api-python-client library to work with the Google Drive API and then, you'll need to create a project in the Google Developers Console, enable the Drive API, and create credentials (OAuth 2.0 client ID). Download the credentials as a JSON file and place it in your project directory.
Here's a Python script for the same

import os
import json
from googleapiclient.discovery import build
from google.oauth2.credentials import Credentials

def authenticate(credentials_file):
    creds = Credentials.from_authorized_user_file(credentials_file)
    return build('drive', 'v3', credentials=creds)

def download_files(service, folder_id, output_dir):
    page_token = None
    while True:
        response = service.files().list(
            q=f"'{folder_id}' in parents",
            spaces='drive',
            fields='nextPageToken, files(id, name, mimeType)',
            pageToken=page_token
        ).execute()

        for file in response.get('files', []):
            file_id = file['id']
            file_name = file['name']
            mime_type = file['mimeType']
            
            if mime_type == 'application/vnd.google-apps.folder':
                # If the file is a subfolder, recursively call the function to download its contents.
                download_files(service, file_id, os.path.join(output_dir, file_name))
            else:
                # If the file is not a folder, download it.
                request = service.files().get_media(fileId=file_id)
                file_path = os.path.join(output_dir, file_name)
                with open(file_path, 'wb') as f:
                    f.write(request.execute())

        page_token = response.get('nextPageToken', None)
        if page_token is None:
            break

if __name__ == '__main__':
    credentials_file = 'path_to_your_credentials.json' 
    folder_id = 'MY-PUBLICLY-ACCESSIBLE-FOLDER-ID'
    output_directory = 'path_to_output_directory'

    if not os.path.exists(output_directory):
        os.makedirs(output_directory)

    service = authenticate(credentials_file)
    download_files(service, folder_id, output_directory)

please change the file paths accordingly

Since there is limitation of max 50 files for gdown library, you might want to check out something like ZDrive library.

It is pretty simple if you check it out. And since you know your folder Id, it should be easy job to use a downloader from the library.

Supporting the same idea as the gdown library it can be coded in few code lines (based on library documentation):

from zdrive import Downloader
output_directory = "/home/abhinav/Documents"
d = Downloader()
folder_id = 'XXXX-YYYY-ZZZZ'
d.downloadFolder(folder_id, destinationFolder=output_directory)

There are good answers above and that may be enhanced for them. The reason why your code only downloads 50 of the files is that the gdown library has a limit of 50 files for direct downloads using cookies. To download more than 50 files.

Start with install oogle-api-python-client

pip install --upgrade google-api-python-client google-auth-httplib2 google-auth-oauthlib google-auth google-auth-oauthlib google-auth-httplib2 google-auth google-auth-oauthlib pickle5

then you can use this code

import io
import os
import pickle
from googleapiclient.http import MediaIoBaseDownload
from google_auth_oauthlib.flow import InstalledAppFlow
from google.auth.transport.requests import Request
from googleapiclient.discovery import build

# If modifying these SCOPES, delete the file token.pickle.
SCOPES = ['https://www.googleapis.com/auth/drive.readonly']

def main():
    creds = None
    # The file token.pickle stores the user's access and refresh tokens, and is

    if os.path.exists('token.pickle'):
        with open('token.pickle', 'rb') as token:
            creds = pickle.load(token)
    # If there are no (valid) credentials available, let the user log in.
    if not creds or not creds.valid:
        if creds and creds.expired and creds.refresh_token:
            creds.refresh(Request())
        else:
            flow = InstalledAppFlow.from_client_secrets_file(
                'credentials.json', SCOPES)
            creds = flow.run_local_server(port=0)
        # Save the credentials for the next run
        with open('token.pickle', 'wb') as token:
            pickle.dump(creds, token)

    # Call the Drive v3 API
    drive_service = build('drive', 'v3', credentials=creds)

    # Get the folder ID from the URL.
    url = 'YOUR_GOOGLE_DRIVE_URL'  # Replace with your Google Drive URL
    folder_id = url.split("/")[-1]

    # Create a directory to store the downloaded files.
    download_dir = os.path.join(os.getcwd(), "downloaded_files")
    if not os.path.exists(download_dir):
        os.mkdir(download_dir)

    # Download the files.
    page_token = None
    while True:
        response = drive_service.files().list(q="'{}' in parents".format(folder_id),
                                              spaces='drive',
                                              fields='nextPageToken, files(id, name)',
                                              pageToken=page_token).execute()
        files = response.get('files', [])
        for file in files:
            request = drive_service.files().get_media(fileId=file['id'])
            fh = io.FileIO(os.path.join(download_dir, file['name']), 'wb')
            downloader = MediaIoBaseDownload(fh, request)
            done = False
            while done is False:
                status, done = downloader.next_chunk()
                print(f'Download {int(status.progress() * 100)}.')

        page_token = response.get('nextPageToken', None)
        if page_token is None:
            break

if __name__ == '__main__':
    main()