YouTube API: Upload Videos With PHP - A Complete Guide

Nov 8, 2025 by Admin 55 views

Hey guys! Want to automate your YouTube uploads using PHP? You've landed in the right spot! This guide will walk you through the entire process of using the YouTube API to upload videos directly from your PHP application. We'll cover everything from setting up your Google Cloud project to writing the PHP code that handles the upload. Let's dive in!

Setting Up Your Google Cloud Project

Before we even touch a line of PHP, we need to configure a Google Cloud project. This is where you'll enable the YouTube Data API v3 and create the credentials needed to authenticate your application. Think of it as getting your permission slip to play in YouTube's sandbox!

Create a Google Cloud Project: Head over to the Google Cloud Console and create a new project. Give it a meaningful name like "My YouTube Uploader" so you remember what it's for. Make sure to select an appropriate organization if you're working within one. Selecting the right project is crucial as it serves as the container for all your API-related configurations. Make sure that you enable billing to avoid surprises.
Enable the YouTube Data API v3: Once your project is ready, navigate to the API Library (you can search for it in the console). Search for "YouTube Data API v3" and enable it. This is the API we'll use to interact with YouTube's services, including uploading videos, managing playlists, and more. When enabling the API, double-check that you are doing it for the correct project to avoid any future complications.
Create Credentials: Now, we need to create credentials that our PHP application can use to authenticate with the API. Go to the "Credentials" section and create an "OAuth client ID." You'll need to configure the consent screen first. Choose "External" unless you're part of a Google Workspace organization. Fill out the necessary information, like your application name and support email. For the authorized domains, add your application's domain (e.g., example.com). Finally, specify the redirect URI, which is the URL where Google will redirect the user after they grant permission to your application (e.g., https://example.com/oauth2callback.php). The redirect URI is very important; if it is not configured correctly, the authentication process will fail.
Download the Credentials: After creating the OAuth client ID, download the JSON file containing your credentials. This file holds sensitive information, so keep it safe! This file contains your client ID, client secret, and other important details needed to authenticate your application. Treat this file like a password; never commit it to a public repository or share it with unauthorized individuals.

Installing the Google API Client Library for PHP

Next up, we need to install the Google API Client Library for PHP. This library provides the classes and functions we need to interact with the YouTube API. We'll use Composer, the PHP dependency manager, to install it.

Install Composer: If you don't have Composer installed already, download and install it from getcomposer.org. Composer simplifies the process of managing dependencies in PHP projects. It allows you to declare the libraries your project depends on and it will manage the installation and updating of those libraries.
Require the Google API Client Library: Open your terminal or command prompt, navigate to your project directory, and run the following command:
```
composer require google/apiclient:^2.0
```
This command tells Composer to download and install the Google API Client Library. The ^2.0 specifies that you want version 2.0 or higher, but compatible with 2.x. This ensures you get the latest features and security updates while maintaining compatibility. After running the command, Composer will create a vendor directory in your project, containing the library and its dependencies. Always ensure your composer dependencies are up to date to leverage the latest features and security patches.

Writing the PHP Code

Now for the fun part! Let's write the PHP code to authenticate with the YouTube API and upload a video. We'll break this down into several steps.

Authentication: First, we need to authenticate our application with the YouTube API. This involves using the credentials we downloaded earlier to obtain an access token. The following code snippet demonstrates the authentication process:
```
<?php
require_once __DIR__ . '/vendor/autoload.php';

session_start();

$client = new Google_Client();
$client->setApplicationName('My YouTube Uploader');
$client->setClientId('YOUR_CLIENT_ID'); // Replace with your client ID
$client->setClientSecret('YOUR_CLIENT_SECRET'); // Replace with your client secret
$client->setRedirectUri('https://example.com/oauth2callback.php'); // Replace with your redirect URI
$client->setScopes([Google_Service_YouTube::YOUTUBE_UPLOAD, Google_Service_YouTube::YOUTUBE]);
$client->setAccessType('offline');
$client->setApprovalPrompt('force');

if (isset($_GET['code'])) {
    $token = $client->fetchAccessTokenWithAuthCode($_GET['code']);
    $client->setAccessToken($token);

    // Save the token to a file or database for later use
    $_SESSION['access_token'] = $token;

    header('Location: ./');
    exit;
}

if (isset($_SESSION['access_token']) && $_SESSION['access_token']) {
    $client->setAccessToken($_SESSION['access_token']);
} else {
    $authUrl = $client->createAuthUrl();
    print "<a href='" . $authUrl . "'>Connect to YouTube</a>";
}

$youtube = new Google_Service_YouTube($client);
?>
```
Explanation:
- We require the autoload.php file generated by Composer to load the necessary classes.
- We start a session to store the access token.
- We create a new Google_Client object and set the application name, client ID, client secret, and redirect URI. Remember to replace the placeholders with your actual credentials!
- We set the scopes to Google_Service_YouTube::YOUTUBE_UPLOAD and Google_Service_YouTube::YOUTUBE, which grant us permission to upload videos and manage YouTube accounts.
- We set the access type to offline so we can obtain a refresh token, allowing us to access the API even when the user is not present.
- If we receive an authorization code in the $_GET['code'] parameter, we exchange it for an access token and store it in the session.
- If we have an access token stored in the session, we set it on the client.
- If we don't have an access token, we generate an authorization URL and display a link for the user to connect to YouTube.

Uploading the Video: Now that we're authenticated, let's upload a video. The following code snippet demonstrates how to upload a video using the YouTube API:

<?php
// Assuming you have already authenticated and have a $youtube service object

$videoPath = '/path/to/your/video.mp4'; // Replace with the path to your video file

$video = new Google_Service_YouTube_Video();
$video->setSnippet(new Google_Service_YouTube_VideoSnippet());
$video->getSnippet()->setTitle('My Awesome Video');
$video->getSnippet()->setDescription('This is a description of my awesome video.');
$video->getSnippet()->setTags(['php', 'youtube', 'api']);
$video->setStatus(new Google_Service_YouTube_VideoStatus());
$video->getStatus()->setPrivacyStatus('private'); // or 'public' or 'unlisted'

$chunkSizeBytes = 1 * 1024 * 1024; // 1MB

$client->setDefer(true);

$insert = $youtube->videos->insert(
    'snippet,status',
    $video,
    ['mediaUpload' => new Google_Http_MediaFileUpload(
        $client,
        $video,
        'video/*',
        filesize($videoPath),
        false,
        $chunkSizeBytes
    )]
);

$media = new Google_Http_MediaFileUpload(
    $client,
    $video,
    'video/*',
    filesize($videoPath),
    false,
    $chunkSizeBytes
);
$media->setFileSize(filesize($videoPath));
$media->setMimeType('video/*');
$media->setData(file_get_contents($videoPath));

$insert->setProgressCallback(function($progress) {
    printf("%%.2f%% Complete", $progress * 100);
});

try {
  $status = false;
  $handle = fopen($videoPath, "rb");
  while (!$status && !feof($handle)) {
    $chunk   = fread($handle, $chunkSizeBytes);
    $status  = $media->nextChunk($chunk);
    if($status != false) {
      $result = $status;
    }
  }

  fclose($handle);

  $client->setDefer(false);

} catch (Google_Service_Exception $e) {
  echo sprintf('<p>A service error occurred: <code>%s</code></p>',
    htmlspecialchars($e->getMessage()));
} catch (Exception $e) {
  echo sprintf('<p>An client error occurred: <code>%s</code></p>',
    htmlspecialchars($e->getMessage()));
}


print_r($result);
?>

Explanation:

We create a new Google_Service_YouTube_Video object and set the snippet and status.
The snippet contains the video title, description, and tags.
The status determines the video's privacy setting (public, private, or unlisted).
We set the chunk size to 1MB, which is the recommended size for uploading large files.
We set the client to defer execution, which allows us to upload the video in chunks.
We create a new Google_Http_MediaFileUpload object to handle the upload.
We call the videos->insert method to upload the video.
We use a try-catch block to handle any exceptions that may occur during the upload.

Handling Callbacks and Progress

It's important to provide feedback to the user during the upload process. The YouTube API allows you to set a progress callback function that will be called periodically during the upload. This function can be used to display a progress bar or other visual indicator.

In the example code above, we've already included a progress callback function:

$insert->setProgressCallback(function($progress) {
    printf("%%.2f%% Complete", $progress * 100);
});

This function simply prints the percentage of the video that has been uploaded. You can customize this function to display a more sophisticated progress indicator.

Storing and Refreshing Access Tokens

Access tokens expire after a certain period of time. To avoid having to re-authenticate the user every time the token expires, you can store the refresh token and use it to obtain a new access token. The refresh token is obtained when you set the access_type to offline during the authentication process.

To refresh the access token, you can use the following code:

<?php
// Assuming you have a $client object and a refresh token stored in a database or file

$client->refreshToken('YOUR_REFRESH_TOKEN'); // Replace with your refresh token
$accessToken = $client->getAccessToken();

// Store the new access token in the database or file
?>

Important: Store the refresh token securely, as it can be used to access the user's YouTube account.

Best Practices and Tips

Error Handling: Implement robust error handling to catch and handle any exceptions that may occur during the upload process. Display user-friendly error messages to help users troubleshoot problems.
Rate Limiting: Be aware of the YouTube API's rate limits. If you exceed the rate limits, your application may be temporarily blocked. Implement a retry mechanism to handle rate limiting errors.
Security: Protect your API credentials and refresh tokens. Never commit them to a public repository or share them with unauthorized individuals. Store them securely in a database or file with appropriate permissions.
User Experience: Provide a smooth and intuitive user experience. Display progress updates and informative error messages. Allow users to customize video settings, such as title, description, and privacy status.

Conclusion

And there you have it! You've successfully learned how to upload videos to YouTube using the YouTube API and PHP. This opens up a world of possibilities for automating your video uploads, creating custom video management tools, and integrating YouTube functionality into your web applications. Remember to follow best practices for error handling, security, and user experience to create a robust and user-friendly application. Happy coding, and may your videos go viral!