How To Use YouTube API – A Step-By-Step Guide To Integrate YouTube API And Full Documentation List

Let us understand how to use YouTube API – A Step-By-Step guide to Integrate YouTube API and full documentation list.

Overview of YouTube API

The YouTube API is an application program interface that enables you to curate a playlist, and embedded videos, and provides other YouTube features on your website. Thanks to the API organizations do not have to build new code from scratch and can offer advanced video-sharing services on their website or app. 

Google YouTube API like other APIS (application program interface) simplifies programming by avoiding the tedious task of writing extensive lines of code every time the user wants to access data. Coders can use preset functions and protocols when selecting YouTube videos for their websites.

Also read: Move Beyond Enterprise IT to an API Strategy

YouTube API scopes, types, and functionalities

Like any other API, the YouTube Video API has simplified coding by eliminating the need to write multiple lines of code each time the user needs to access data. Instead, they use predefined functions and protocols to curate YouTube videos on a website.  YouTube API has a range of functionalities and features that make it useful for businesses and developers.

Compared to standalone YouTube embed codes, YouTube API allows you to access YouTube’s data in a more thorough and scalable manner. With the YouTube API, you may access complete playlists, user uploads, and even search results. 

To allow viewers to upload videos, manage channel subscriptions directly from the website or app, and add YouTube functionality to your website.

The common functionalities of YouTube API services are listed below.

YouTube Resources	Example Http Request	Description
YouTube Search	Get/Search	Retrieves a range of search results based on queries
YouTube Playlist	DELETE/Playlist	Delete a playlist
YouTube Videos	POST/Videos	Uploads videos to YouTube from your website or app
YouTube comments	POST/comments/markAsSpam	You can flag one or more comments as spam.
YouTube Channels	GET/Channel	Retrieves a channel’s videos or playlists (or any other resource, such as comments)
YouTube Subscription	POST/subscription	Adds a subscriber to an authenticated user’s channel.
YouTube Members	GET/members	Retrieves a list of members for a channel that has given you authorization.
YouTube Caption	PUT/Captions	Updates a caption track (you can upload a new file or change it to a draft.
YouTube Channel Sections	POST/ channelSections	Add a section of featured videos, for example, to an authenticated user’s channel
YouTube Watermarks	Post/WaterMarks	Remove watermark image associated with a channel

How to use YouTube API – 7 step integration guide

In this section, we focus on how to use YouTube API integration. It is 7 steps simple API integration YouTube. 

Step1: Log in to Google Developer Console

Create a Google account and use the credentials to log in to Google Developers Console.

Step2: Create a new project

When you first log in you will see an empty dashboard. On the upper right corner of your screen, click on Create Project.  You will be directed to a screen where you can add a project name, and select organization and URL from the dropdown box. After you create the project, everything you do moving forward including the API Key will be exclusively for the project. If you are working on multiple projects concurrently ensure the correct project is selected. 

Step3: On a new project dashboard, explore and enable API

You will now be taken to a brand-new dashboard with different cards like Project name and resources. Find the Getting Started card and click on Explore and Enable APIs. Alternatively, you can navigate to the APIs and services > library.

Step4: In the library, navigate to YouTube Data API v3 under YouTube APIs

The YouTube API console is divided into sections – Navigate to the YouTube APIs and select YouTube Data API v3 or you can search for YouTube Data API in the search console.

Step5: Enable APIs

Once you arrive at the YouTube Data API page, click the Enable button.

Step6: Create a credential

After clicking the Enable button you will be able to view the overview page. Click Create Credentials in the top right-hand corner. In the Credentials window, select YouTube Data API v3 from the dropdown menu, WebServer (Tomcat, Node.js), and check the Public data in the third option.

Select “What credentials do I need?” You can now get the YouTube API key. Click  Done 

Step7: A screen with the API key will appear

Done! Congratulations you now have the API key. You need to save credentials.

YouTube API documentation references

The YouTube API is a powerful tool for developers to interact with the YouTube platform and get access to the wealth of information available on YouTube. The API allows developers to retrieve data, upload videos, manage playlists and much more. 

You can access YouTube API documentation on the YouTube Developers website. Each API endpoint is described in depth in the documentation, along with the parameters that can be supplied and the format of the answer. YouTube offers sample code and client libraries many programming languages in addition to the API documentation, making it simple for developers to get started with the API right away.

For programmers wishing to use the YouTube API, the following resources may be helpful:

• YouTubecalculator API documentation and is provided by YouTube. It is a comprehensive documentation covering everything from authentication to API endpoints and response formats. The documentation is easy to navigate. 
•  YouTube API reference Guide provides an overview of the API’s functionality, including authentication, quota usage, error handling, and recommended API usage procedures.
• YouTube Tools lets you test authorized and unauthorized requests. The Quota calculator show how usage impacts your quota usage. 
• YouTube Data forum is a community forum where developers can ask questions and get help from other developers who are using the YouTube API.

YouTube API examples

Developers may access and engage with YouTube’s enormous library of videos, channels, and playlists thanks to the YouTube API. The creation of unique applications, automated video uploads, and data collection for analysis are all possible with this potent tool. In this section, we focus on different YouTube API examples in different languages. 

Also read: How to use Spotify API; a step-by-step integration guide and full documentation list

How to use YouTube API Python?

Prerequisites you need Python 2.7 or Python 3.5, pip package management tool, and Google API Client Library for Python. This simple guide explains how to use YouTube API Python, 

Step1: Set up your project credentials

• Start by setting up YouTube API and download your credentials.json in the current direct of your notebook/Python file. 
• Use the APIs Explorer widget in the side panel to obtain sample code for retrieving the information about GoogleDevelopers YouTube Channel. This call does not need user authorization or other specialized rights from the user running the sample; it simply utilizes an API key to identify your application. Click the code symbol for the first listing to open and populate the fullscreen APIs Explorer.

Step2: Set up and run the sample 

• You will be able to see the following information on the left side of the fullscreen API explorer. 
• List of parameters the method support below the request parameters header. The part and the id parameter values should be set. The part and id parameter value should be set. The parameter value, UC_x5XG1OV2P6uZZ5FSM9Ttw, is the ID for the GoogleDevelopers YouTube channel.
• You will be able to see credentials 
• Below the parameters, there is a section named Credentials. The pulldown menu in that section should display the value API key. The APIs Explorer uses demo credentials by default to make it easier to get started. But you’ll use your own API key to run the sample locally.
• On the right side of the fullscreen API explorer you can see tabs with code samples in several languages. Select the Python tab.
• Copy the code samples and save it in a file named example.py.
• In the sample that you downloaded, find the YOUR_API_KEY string and replace it with API Key for your application.
• Run the sample from the command line. In your working directory, run: python example.py
• The sample should execute the request and print the response to STDOUT.

Step 3: Run authorized requests

You can now modify your code sample so that it collects information from your YouTube channel instead  GoogleDevelopers YouTube channel. You need to authorize this request. 

• Go back to the documentation for the API’s channels.list method.
• In the “Common use cases” section, click the code symbol for the third listing in the table. That use case is to call the list method for “my channel.”
• On the left side of the fullscreen APIs Explorer look for the list of parameters followed by the Credentials section. However, there are two changes from the example where you retrieved information about the GoogleDevelopers channel:
• In the parameters section, instead of the id parameter value being set, the mine parameter value should be set to true. This instructs the API server to retrieve information about the currently authenticated user’s channel.
• In the Credentials section, the pulldown menu should select the option for Google OAuth 2.0.
• In addition, if you click the Show scopes link, the scope should be checked.
• Select the Python tab, copy the code sample, and save it to example.py. Look for the YOUR_CLIENT_SECRET_FILE.json string and replace it with the location of the client secret file you downloaded in step1.
• Run the sample from the command line. In your working directory, run: python example.py
• Copy the URL from the console and open it in your browser.
• In case you have not logged into your Google account, you will be prompted to log in. If you are logged into multiple Google accounts, you will be asked to select one account to use for the authorization.
• Click the button to grant your application access to the scopes specified in your code sample.
• Copy the auth code from the browser and paste it into your terminal. You can then close the browser tab used for the auth flow. The API response should again be printed to STDOUT.

Also read: What to Look for in a Geolocation API

How to use YouTube JavaScript API tutorial

If you want to explore YouTube JavaScript API and learn to use it, the best way would be via a project. 

Step1: The first step is to go to the Google Cloud console and create your project.

We have already explained how you can generate the API key in the preceding section. 

Step2: Set up and run the sample

To acquire examples of code to retrieve data from the GoogleDevelopers YouTube channel, use the APIs Explorer widget on the side panel. This call does not need user authorization or other specialized rights from the user running the sample; it simply utilizes an API key to identify your application.

• Open the channels.list method’s documentation in the API. The “Common use cases” part of that page includes a table that lists various typical applications of the technology. Results by channel ID are listed in the table’s first row.
• For the fullscreen APIs Ex, open it by clicking the code symbol for the first listing.
• Open the channels.list method’s documentation in the API.
• The “Common use cases” part of that page includes a table that lists various typical applications of the technology. Results by channel ID are listed in the table’s first row.
• For the fullscreen APIs Examples, open it by clicking the code symbol for the first listing.
• You can see the following information on the left-side of the fullscreen API explorer – 
• Request parameter header contains a list of parameters that the method supports. The values for the part and id parameters should be set. The ID for the GoogleDevelopers YouTube channel is given below: UC_x5XG1OV2P6uZZ5FSM9Ttw, which is the value for the id parameter.
• Credentials is a part that is located below the parameters. The value API key ought to appear in the pulldown option in that area. To make things simpler to use when getting started, the APIs Explorer utilizes demo credentials by default. But to run the sample locally, you’ll need your own API key.
• On the right-side of the fullscreen API explorer shows tabs with code samples in the different languages you can select JavaScript from the list. 
• Copy the code sample and save it as example.html. 
• Look for  YOUR_API_KEY string in the example and replace that with the API key that you created in step 1.
• Start the web server using the following command from your working directory:
• python -m http.server 8000
• Open the example.html file in your browser and the browser’s developer tools, such as the “Developer Tools” in the Chrome browser. 
• Click the load button to load the Google APIs Client Library for JavaScript. After you click the button, the developer console shows a note indicating the GAPI client is loaded. 
• Click on the execute button to send API request. The developer’s console should then display the API response. 

Step3: Run an authorized request

We will now modify your code sample so that it collects information from your YouTube Channel rather than GoogleDeveloper’s YouTube channel. User consent is required for the request. 

• Return to the channels.list method of the API’s documentation.
• Click the code icon next to the third listing in the table under “Common use cases” in the section. To use case one, invoke the list method for “my channel.”
• Click the code icon next to the third listing in the table under “Common use cases” in the section. To use case one, invoke the list method for “my channel.”
• A list of parameters is displayed on the left side of the full-screen APIs Explorer, followed by an area for credentials. But there are two differences from the case where you got data via the GoogleDevelopers channel
• The mine parameter value should be set to true in the parameters section rather than the id parameter value. This tells the API server to get data on the channel of the user who is presently logged in.
• The pulldown menu in the Credentials area needs to be set to Google OAuth 2.0.

Additionally, you should check the scope if you click the Show scopes link

How to use YouTube API Node Js?

In this section, we focus on learning how to use YouTube API Node. You first need to create new project and get the API key for the project. You now need to generate a node application. Now create our package.json

npm init

Now install express. Express is the most popular and small framework for Node and it  provides us with routes and a simple means of parsing query parameters.

npm install express

We create an express application to start it

      const express = require(“express”);

      const app = express();

      app.get(“/”, (req, res) => {

      res.send(“Hello World!”);

});

      app.listen(port, () => {

  console.log(`App listening at http://localhost:${port}`);

});

To start an application we write in the console the below

node server.js

Confirm the request is working in the browser.  Our next step is to create a new URL where we can provide some search strings and get date from YouTube API.

app.get(“/search“, async (req, res, next) => {

    const searchQuery = req.query.search_query;

    res.send(searchQuery);

});

The search URL is working because URL is working because we used express to read query parameters. It is time to use API of YouTube. If you want to get the list of videos like in search of YouTube here is the request that we need for this.

As you can see our search URL is working and because we used express we get out of the box possibility to read query parameters.

Now it’s time to use API of youTube. As we want to get the list of videos like in search of YouTube here is the request that we need for this.

We can see v3 api here and we offer various stuff. The API key is critical or we will see a 403 error without it. The q parameter comes next. This is the search term we use when entering a YouTube search. In order to receive more fields in the response, such as the title, description, tags, and channel id, we additionally want to provide part=snippet. Since there are many more video types, including channels, playlists, and many more, we also wish to filter our data by video type.

npm install axios

use async await notation to make code easier to read and support

const axios = require(“axios“);

const apiKey = “AIzaSyDh4lSGdVGOnOg9oEvLTeLeCvl1eH5UMb0“;

const apiUrl = “https://www.googleapis.com/youtube/v3“;

app.get(“/search“, async (req, res, next) => {

  try {

    const searchQuery = req.query.search_query;

    const url = `${apiUrl}/search?key=${apiKey}&type=video&part=snippet&q=${searchQuery}`;

    const response = await axios.get(url);

    const titles = response.data.items.map((item) => item.snippet.title);

    res.send(titles);

  } catch (err) {

    next(err);

  }

});

So here I stored API key and API URL in additional properties so we can reuse them in other requests later. we also prepare the correct URL with params and call axios.get with await. Inside response we loop through all items to get titles of each element.

We also wrapped our code in try catch block so we can react on errors. The easiest way to handle errors is just to propagate it to Express framework by using next. As you can see in browser our code is working and we get our list of video titles in API.

How to use c# YouTube API?

Using C# YouTube API is quite intuitive. 

Step1: Create a Google API Console Project

Go to the Google cloud console to create a project using the steps outlined in the previous section. You will get an API on the successful creation of the project.

Step2: Create a new C# console application in Visual Studio You can create a new C# console application in Visual Studio by selecting “File” -> “New” -> “Project” and then selecting “Console App (.NET Framework)” under the C# section.

Step3: Install the Google API client library for .net

To access the YouTube API for C# application, you need install Google  API client library for .NET. 

Go to the Package Manage Console and enter the following command

Install–Package Google.Apis.YouTube.v3

Step4 : Include namesspace in the class file

using Google.Apis.Services;

using Google.Apis.YouTube.v3;

Step5: Add following methods to your class file

Find the Given method and replace it your API key. 

private async Task GetYouTubeVideos() {

    var youtubeService = new YouTubeService(new BaseClientService.Initializer() {

        ApiKey = “REPLACE_ME”,

            ApplicationName = this.GetType().ToString()

    });

    var searchListRequest = youtubeService.Search.List(“snippet”);

    searchListRequest.Q = “My Videos”; // Replace with your search term.

    searchListRequest.MaxResults = 50;

    // Call the search.list method to retrieve results matching the specified query term.

    var searchListResponse = await searchListRequest.ExecuteAsync();

    List < string > videos = new List < string > ();

    List < string > channels = new List < string > ();

    List < string > playlists = new List < string > ();

    // Add each result to the appropriate list, and then display the lists of

    // matching videos, channels, and playlists.

    foreach(var searchResult in searchListResponse.Items) {

        switch (searchResult.Id.Kind) {

            case “youtube#video”:

                videos.Add(string.Format(“{0} ({1})”, searchResult.Snippet.Title, searchResult.Id.VideoId));

                break;

            case “youtube#channel”:

                channels.Add(string.Format(“{0} ({1})”, searchResult.Snippet.Title, searchResult.Id.ChannelId));

                break;

            case “youtube#playlist”:

                playlists.Add(string.Format(“{0} ({1})”, searchResult.Snippet.Title, searchResult.Id.PlaylistId));

                break;

        }

    }

    Console.WriteLine(string.Format(“Videos:\n{0}\n”, string.Join(“\n”, videos)));

    Console.WriteLine(string.Format(“Channels:\n{0}\n”, string.Join(“\n”, channels)));

    Console.WriteLine(string.Format(“Playlists:\n{0}\n”, string.Join(“\n”, playlists)));

}

The above posted above calls API’s search.list method to obtain search results linked to a specific keyword.

Step6: Use the following method in your class 

static void Main(string[] args)

{

new Program().GetYouTubeVideos().GetAwaiter().GetResult();

Console.ReadLine();

}

You can view the basic video details in the console. You can refer to the API  documents to get more functionality. 

How to use YouTube API php curl?

There are a few steps you must take in order to access the YouTube API with PHP and cURL:

Activate the YouTube API key and create a Google Cloud Platform project: In the Google Cloud Console, you must create a project and enable the YouTube Data API if you haven’t previously. The documentation for Google Developers contains more details on how to do this.

To access the YouTube API, you must first obtain API credentials, which consist of a client ID and client secret. The steps in the manual for Google Developers can be used to do this.

Install and enable cURL in your PHP environment: This is a prerequisite. Run this command to see if cURL has been set up.

php -m | grep curl

If cURL isn’t already installed, you can either get it from the cURL website or install it using your package management (such as apt-get, yum, etc.).

Log in using the YouTube API: You’ll need to use the client ID and client secret you previously got to obtain an access token in order to authenticate with the YouTube API. Here’s an illustration of how to authenticate in PHP using cURL:

$client_id = ‘YOUR_CLIENT_ID’;

$client_secret = ‘YOUR_CLIENT_SECRET’;

// Set up cURL

$ch = curl_init();

curl_setopt($ch, CURLOPT_URL, ‘https://accounts.google.com/o/oauth2/token’);

curl_setopt($ch, CURLOPT_POST, true);

curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);

curl_setopt($ch, CURLOPT_POSTFIELDS, array(

    ‘grant_type’ => ‘client_credentials’,

    ‘client_id’ => $client_id,

    ‘client_secret’ => $client_secret,

    ‘scope’ => ‘https://www.googleapis.com/auth/youtube.force-ssl’

));

// Send the request

$response = curl_exec($ch);

curl_close($ch);

// Decode the response

$json = json_decode($response, true);

// Get the access token

$access_token = $json[‘access_token’];

You can use an access token to send requests to the YouTube API once you have one. Here’s a perfect example of how to search for videos using cURL:

$search_term = ‘SEARCH_TERM’;

// Set up cURL

$ch = curl_init();

curl_setopt($ch, CURLOPT_URL, ‘https://www.googleapis.com/youtube/v3/search?part=snippet&q=’ . urlencode($search_term));

curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);

curl_setopt($ch, CURLOPT_HTTPHEADER, array(

    ‘Authorization: Bearer ‘ . $access_token,

    ‘Accept: application/json’

));

// Send the request

$response = curl_exec($ch);

curl_close($ch);

// Decode the response

$json = json_decode($response, true);

// Loop through the results

foreach ($json[‘items’] as $item) {

 // Do something with the search results

}

Also read: How to use ChatGPT API; a step-by-step integration guide and full documentation list

How to use Google YouTube Android API?

Prerequisite to use Google YouTube Android API are  Android Studio SDK 1.2 or later, Android SDK packages, access to internet on your test device, and Google account. 

Step1: Acquire a SHAI fingerprint

Run the Keytool utility command shown below in a terminal to obtain the SHA1 fingerprint you will need to enable the API.

keytool -exportcert -alias androiddebugkey -keystore ~/.android/debug.keystore -list -v

Enter “android” when promoted for a keystore password. The keystore prints prints fingerprint in the shell. 

$ keytool -exportcert -alias androiddebugkey -keystore ~/.android/debug.keystore -list -v

Enter keystore password: Type “android” if using debug.keystore

Alias name: androiddebugkey

Creation date: Dec 4, 2014

Entry type: PrivateKeyEntry

Certificate chain length: 1

Certificate[1]:

Owner: CN=Android Debug, O=Android, C=US

Issuer: CN=Android Debug, O=Android, C=US

Serial number: 503bd581

Valid from: Mon Aug 27 13:16:01 PDT 2012 until: Wed Aug 20 13:16:01 PDT 2042

Certificate fingerprints:

MD5:

1B:2B:2D:37:E1:CE:06:8B:A0:F0:73:05:3C:A3:63:DD

SHA1:

D8:AA:43:97:59:EE:C5:95:26:6A:07:EE:1C:37:8E:F4:F0:C8:05:C8

SHA256:

F3:6F:98:51:9A:DF:C3:15:4E:48:4B:0F:91:E3:3C:6A:A0:97:DC:0A:3F:B2:D2:E1:FE:23:57:F5:EB:AC:13:30

Signature algorithm name: SHA1withRSA

Version: 3

Copy the SHAI fingerprint highlighted in the example  above. 

Step2: Turn on the YouTube Data API

• To automatically enable the API, use this wizard to create or choose a project in the Google Developers Console. Continue by clicking, then select Credentials.
• Click the Cancel option located on the Create Credentials page.
• Choose the OAuth consent screen tab from the menu at the top of the page. Once you’ve chosen an email address and, if necessary, a product name, click the Save button.
• Click the Create credentials button while selecting OAuth client ID on the Credentials tab.
• Choose the Android application category.
• In the Signing-certificate fingerprint field, paste the SHA1 fingerprint from Step1
• Enter com.example in the field marked “Package name”.quickstart.
• Select “Create” from the menu.

Step3: Create an Android Project

• Open Android Studio and start a new Android Studio Project. 
• In the New Project screen and name the application “QuickStart”
• Specify “example.com” as the Company Domain, and make sure the package name that is generated automatically corresponds to the one you supplied in the Developer Console in Step2. Choose Next.
• Check the Phone and Tablet checkbox and select “API 14: Android 4.0 (IceCreamSandwich)” as the Minimum SDK on the Target Android Devices screen. Uncheck all of the other checkboxes. Choose Next.
• Click Add No Activity on the Add an activity to Mobile screen.
• Click Finish

At this point, Android Studio creates and open a project. 

Step4: Get the project ready

The list of the default project files that Android Studio has prepared is expandable in the Project sidebar. Open the build.gradle file that is linked to the “app” module (not the project) in that list by expanding the list of Gradle scripts. The first line should read apply plugin: ‘com.android.application’.

• In the toolbar, select Tools > Android > Sync Project with Gradle Files. You will be able to use the libraries required for your project.
• Find and open the default src/main/AndroidManifest.xml file. In the Project sidebar, this file is nested under app and then under manifests. Replace the file’s contents with the following code:
• <?xml version=”1.0″ encoding=”utf-8″?>
  <manifest xmlns:android=”http://schemas.android.com/apk/res/android”
      package=”com.example.quickstart”>
  
      <uses-permission android:name=”android.permission.INTERNET” />
      <uses-permission android:name=”android.permission.ACCESS_NETWORK_STATE” />
      <uses-permission android:name=”android.permission.GET_ACCOUNTS” />
  
      <application
          android:allowBackup=”true”
          android:icon=”@mipmap/ic_launcher”
          android:label=”YouTube Data API Android Quickstart”
          android:theme=”@style/AppTheme” >
          <activity
              android:name=”.MainActivity”
              android:label=”YouTube Data API Android Quickstart” >
              <intent-filter>
                  <action android:name=”android.intent.action.MAIN” />
                  <category android:name=”android.intent.category.LAUNCHER” />
              </intent-filter>
          </activity>
  
      </application>
  </manifest>

Step 5: setup sample

Create a new Java class. Select the java folder in the Project sidebar. This folder appears in the group of app files. After clicking on the folder, you can select File > New > Java Class from the menu bar, or you can right-click on the folder and select New > Java Class. If prompted to select a directory, choose …/app/src/main/java.

Name the class “MainActivity” and click OK. Replace the contents of the new file with the following code.

package com.example.quickstart;

import com.google.android.gms.common.ConnectionResult;
import com.google.android.gms.common.GoogleApiAvailability;
import com.google.api.client.extensions.android.http.AndroidHttp;
import com.google.api.client.googleapis.extensions.android.gms.auth.GoogleAccountCredential;
import com.google.api.client.googleapis.extensions.android.gms.auth.GooglePlayServicesAvailabilityIOException;
import com.google.api.client.googleapis.extensions.android.gms.auth.UserRecoverableAuthIOException;
import com.google.api.client.http.HttpTransport;
import com.google.api.client.json.JsonFactory;
import com.google.api.client.json.jackson2.JacksonFactory;
import com.google.api.client.util.ExponentialBackOff;
import com.google.api.services.youtube.YouTubeScopes;
import com.google.api.services.youtube.model.*;
import android.Manifest;
import android.accounts.AccountManager;
import android.app.Activity;
import android.app.Dialog;
import android.app.ProgressDialog;
import android.content.Context;
import android.content.Intent;
import android.content.SharedPreferences;
import android.net.ConnectivityManager;
import android.net.NetworkInfo;
import android.os.AsyncTask;
import android.os.Bundle;
import android.support.annotation.NonNull;
import android.text.TextUtils;
import android.text.method.ScrollingMovementMethod;
import android.view.View;
import android.view.ViewGroup;
import android.widget.Button;
import android.widget.LinearLayout;
import android.widget.TextView;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import pub.devrel.easypermissions.AfterPermissionGranted;
import pub.devrel.easypermissions.EasyPermissions;

public class MainActivity extends Activity
    implements EasyPermissions.PermissionCallbacks {
    GoogleAccountCredential mCredential;
    private TextView mOutputText;
    private Button mCallApiButton;
    ProgressDialog mProgress;

    static final int REQUEST_ACCOUNT_PICKER = 1000;
    static final int REQUEST_AUTHORIZATION = 1001;
    static final int REQUEST_GOOGLE_PLAY_SERVICES = 1002;
    static final int REQUEST_PERMISSION_GET_ACCOUNTS = 1003;

    private static final String BUTTON_TEXT = “Call YouTube Data API”;
    private static final String PREF_ACCOUNT_NAME = “accountName”;
    private static final String[] SCOPES = { YouTubeScopes.YOUTUBE_READONLY };

    /**
     * Create the main activity.
     * @param savedInstanceState previously saved instance data.
     */
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        LinearLayout activityLayout = new LinearLayout(this);
        LinearLayout.LayoutParams lp = new LinearLayout.LayoutParams(
                LinearLayout.LayoutParams.MATCH_PARENT,
                LinearLayout.LayoutParams.MATCH_PARENT);
        activityLayout.setLayoutParams(lp);
        activityLayout.setOrientation(LinearLayout.VERTICAL);
        activityLayout.setPadding(16, 16, 16, 16);

        ViewGroup.LayoutParams tlp = new ViewGroup.LayoutParams(
                ViewGroup.LayoutParams.WRAP_CONTENT,
                ViewGroup.LayoutParams.WRAP_CONTENT);

        mCallApiButton = new Button(this);
        mCallApiButton.setText(BUTTON_TEXT);
        mCallApiButton.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                mCallApiButton.setEnabled(false);
                mOutputText.setText(“”);
                getResultsFromApi();
                mCallApiButton.setEnabled(true);
            }
        });
        activityLayout.addView(mCallApiButton);

        mOutputText = new TextView(this);
        mOutputText.setLayoutParams(tlp);
        mOutputText.setPadding(16, 16, 16, 16);
        mOutputText.setVerticalScrollBarEnabled(true);
        mOutputText.setMovementMethod(new ScrollingMovementMethod());
        mOutputText.setText(
                “Click the \'” + BUTTON_TEXT +”\’ button to test the API.”);
        activityLayout.addView(mOutputText);

        mProgress = new ProgressDialog(this);
        mProgress.setMessage(“Calling YouTube Data API …”);

        setContentView(activityLayout);

        // Initialize credentials and service object.
        mCredential = GoogleAccountCredential.usingOAuth2(
                getApplicationContext(), Arrays.asList(SCOPES))
                .setBackOff(new ExponentialBackOff());
    }

       /**
     * Attempt to call the API, after verifying that all the preconditions are
     * satisfied. The preconditions are: Google Play Services installed, an
     * account was selected and the device currently has online access. If any
     * of the preconditions are not satisfied, the app will prompt the user as
     * appropriate.
     */
    private void getResultsFromApi() {
        if (! isGooglePlayServicesAvailable()) {
            acquireGooglePlayServices();
        } else if (mCredential.getSelectedAccountName() == null) {
            chooseAccount();
        } else if (! isDeviceOnline()) {
            mOutputText.setText(“No network connection available.”);
        } else {
            new MakeRequestTask(mCredential).execute();
        }
    }

    /**
     * Attempts to set the account used with the API credentials. If an account
     * name was previously saved it will use that one; otherwise an account
     * picker dialog will be shown to the user. Note that the setting the
     * account to use with the credentials object requires the app to have the
     * GET_ACCOUNTS permission, which is requested here if it is not already
     * present. The AfterPermissionGranted annotation indicates that this
     * function will be rerun automatically whenever the GET_ACCOUNTS permission
     * is granted.
     */
    @AfterPermissionGranted(REQUEST_PERMISSION_GET_ACCOUNTS)
    private void chooseAccount() {
        if (EasyPermissions.hasPermissions(
                this, Manifest.permission.GET_ACCOUNTS)) {
            String accountName = getPreferences(Context.MODE_PRIVATE)
                    .getString(PREF_ACCOUNT_NAME, null);
            if (accountName != null) {
                mCredential.setSelectedAccountName(accountName);
                getResultsFromApi();
            } else {
                // Start a dialog from which the user can choose an account
                startActivityForResult(
                        mCredential.newChooseAccountIntent(),
                        REQUEST_ACCOUNT_PICKER);
            }
        } else {
            // Request the GET_ACCOUNTS permission via a user dialog
            EasyPermissions.requestPermissions(
                    this,
                    “This app needs to access your Google account (via Contacts).”,
                    REQUEST_PERMISSION_GET_ACCOUNTS,
                    Manifest.permission.GET_ACCOUNTS);
        }
    }

    /**
     * Called when an activity launched here (specifically, AccountPicker
     * and authorization) exits, giving you the requestCode you started it with,
     * the resultCode it returned, and any additional data from it.
     * @param requestCode code indicating which activity result is incoming.
     * @param resultCode code indicating the result of the incoming
     *     activity result.
     * @param data Intent (containing result data) returned by incoming
     *     activity result.
     */
    @Override
    protected void onActivityResult(
            int requestCode, int resultCode, Intent data) {
        super.onActivityResult(requestCode, resultCode, data);
        switch(requestCode) {
            case REQUEST_GOOGLE_PLAY_SERVICES:
                if (resultCode != RESULT_OK) {
                    mOutputText.setText(
                            “This app requires Google Play Services. Please install ” +
                            “Google Play Services on your device and relaunch this app.”);
                } else {
                    getResultsFromApi();
                }
                break;
            case REQUEST_ACCOUNT_PICKER:
                if (resultCode == RESULT_OK && data != null &&
                        data.getExtras() != null) {
                    String accountName =
                            data.getStringExtra(AccountManager.KEY_ACCOUNT_NAME);
                    if (accountName != null) {
                        SharedPreferences settings =
                                getPreferences(Context.MODE_PRIVATE);
                        SharedPreferences.Editor editor = settings.edit();
                        editor.putString(PREF_ACCOUNT_NAME, accountName);
                        editor.apply();
                        mCredential.setSelectedAccountName(accountName);
                        getResultsFromApi();
                    }
                }
                break;
            case REQUEST_AUTHORIZATION:
                if (resultCode == RESULT_OK) {
                    getResultsFromApi();
                }
                break;
        }
    }

    /**
     * Respond to requests for permissions at runtime for API 23 and above.
     * @param requestCode The request code passed in
     * requestPermissions(android.app.Activity, String, int, String[])
     * @param permissions The requested permissions. Never null.
     * @param grantResults The grant results for the corresponding permissions
     * which is either PERMISSION_GRANTED or PERMISSION_DENIED. Never null.
     */
    @Override
    public void onRequestPermissionsResult(int requestCode,
                                           @NonNull String[] permissions,
                                           @NonNull int[] grantResults) {
        super.onRequestPermissionsResult(requestCode, permissions, grantResults);
        EasyPermissions.onRequestPermissionsResult(
                requestCode, permissions, grantResults, this);
    }

    /**
     * Callback for when a permission is granted using the EasyPermissions
     * library.
     * @param requestCode The request code associated with the requested
     *         permission
     * @param list The requested permission list. Never null.
     */
    @Override
    public void onPermissionsGranted(int requestCode, List<String> list) {
        // Do nothing.
    }

    /**
     * Callback for when a permission is denied using the EasyPermissions
     * library.
     * @param requestCode The request code associated with the requested
     *         permission
     * @param list The requested permission list. Never null.
     */
    @Override
    public void onPermissionsDenied(int requestCode, List<String> list) {
        // Do nothing.
    }

    /**
     * Checks whether the device currently has a network connection.
     * @return true if the device has a network connection, false otherwise.
     */
    private boolean isDeviceOnline() {
        ConnectivityManager connMgr =
                (ConnectivityManager) getSystemService(Context.CONNECTIVITY_SERVICE);
        NetworkInfo networkInfo = connMgr.getActiveNetworkInfo();
        return (networkInfo != null && networkInfo.isConnected());
    }

    /**
     * Check that Google Play services APK is installed and up to date.
     * @return true if Google Play Services is available and up to
     *     date on this device; false otherwise.
     */
    private boolean isGooglePlayServicesAvailable() {
        GoogleApiAvailability apiAvailability =
                GoogleApiAvailability.getInstance();
        final int connectionStatusCode =
                apiAvailability.isGooglePlayServicesAvailable(this);
        return connectionStatusCode == ConnectionResult.SUCCESS;
    }

    /**
     * Attempt to resolve a missing, out-of-date, invalid or disabled Google
     * Play Services installation via a user dialog, if possible.
     */
    private void acquireGooglePlayServices() {
        GoogleApiAvailability apiAvailability =
                GoogleApiAvailability.getInstance();
        final int connectionStatusCode =
                apiAvailability.isGooglePlayServicesAvailable(this);
        if (apiAvailability.isUserResolvableError(connectionStatusCode)) {
            showGooglePlayServicesAvailabilityErrorDialog(connectionStatusCode);
        }
    }


    /**
     * Display an error dialog showing that Google Play Services is missing
     * or out of date.
     * @param connectionStatusCode code describing the presence (or lack of)
     *     Google Play Services on this device.
     */
    void showGooglePlayServicesAvailabilityErrorDialog(
            final int connectionStatusCode) {
        GoogleApiAvailability apiAvailability = GoogleApiAvailability.getInstance();
        Dialog dialog = apiAvailability.getErrorDialog(
                MainActivity.this,
                connectionStatusCode,
                REQUEST_GOOGLE_PLAY_SERVICES);
        dialog.show();
    }

    /**
     * An asynchronous task that handles the YouTube Data API call.
     * Placing the API calls in their own task ensures the UI stays responsive.
     */
    private class MakeRequestTask extends AsyncTask<Void, Void, List<String>> {
        private com.google.api.services.youtube.YouTube mService = null;
        private Exception mLastError = null;

        MakeRequestTask(GoogleAccountCredential credential) {
            HttpTransport transport = AndroidHttp.newCompatibleTransport();
            JsonFactory jsonFactory = JacksonFactory.getDefaultInstance();
            mService = new com.google.api.services.youtube.YouTube.Builder(
                    transport, jsonFactory, credential)
                    .setApplicationName(“YouTube Data API Android Quickstart”)
                    .build();
        }

        /**
         * Background task to call YouTube Data API.
         * @param params no parameters needed for this task.
         */
        @Override
        protected List<String> doInBackground(Void… params) {
            try {
                return getDataFromApi();
            } catch (Exception e) {
                mLastError = e;
                cancel(true);
                return null;
            }
        }

        /**
         * Fetch information about the “GoogleDevelopers” YouTube channel.
         * @return List of Strings containing information about the channel.
         * @throws IOException
         */
        private List<String> getDataFromApi() throws IOException {
            // Get a list of up to 10 files.
            List<String> channelInfo = new ArrayList<String>();
            ChannelListResponse result = mService.channels().list(“snippet,contentDetails,statistics”)
                 .setForUsername(“GoogleDevelopers”)
                 .execute();
            List<Channel> channels = result.getItems();
            if (channels != null) {
                Channel channel = channels.get(0);
                channelInfo.add(“This channel’s ID is ” + channel.getId() + “. ” +
                        “Its title is ‘” + channel.getSnippet().getTitle() + “, ” +
                        “and it has ” + channel.getStatistics().getViewCount() + ” views.”);
            }
            return channelInfo;
        }

        @Override
        protected void onPreExecute() {
            mOutputText.setText(“”);
            mProgress.show();
        }

        @Override
        protected void onPostExecute(List<String> output) {
            mProgress.hide();
            if (output == null || output.size() == 0) {
                mOutputText.setText(“No results returned.”);
            } else {
                output.add(0, “Data retrieved using the YouTube Data API:”);
                mOutputText.setText(TextUtils.join(“\n”, output));
            }
        }

        @Override
        protected void onCancelled() {
            mProgress.hide();
            if (mLastError != null) {
                if (mLastError instanceof GooglePlayServicesAvailabilityIOException) {
                    showGooglePlayServicesAvailabilityErrorDialog(
                            ((GooglePlayServicesAvailabilityIOException) mLastError)
                                    .getConnectionStatusCode());
                } else if (mLastError instanceof UserRecoverableAuthIOException) {
                    startActivityForResult(
                            ((UserRecoverableAuthIOException) mLastError).getIntent(),
                            MainActivity.REQUEST_AUTHORIZATION);
                } else {
                    mOutputText.setText(“The following error occurred:\n”
                            + mLastError.getMessage());
                }
            } else {
                mOutputText.setText(“Request cancelled.”);
            }
        }
    }
}

Step6: Run the App

• To test the app, click the Run and Run App from the menu. 
• You will need to choose  the connected device (recommended) or an emulator. If you use an emulator, make sure it is set up to use one of the system images for the Google APIs. The quickstart generates a dialogue from which you may install Google Play services if you try to run it on a device that doesn’t already have them set up.
• If you are using an emulator allow it to fully start up and establish its network. 
• You might need to unlock the emulator’s screen if you’re starting it for the first time. However, the quickstart app ought to launch automatically.
• The software asks you to provide an account information when you launch it for the first time. To select an account to connect to, complete the sign-in process.
• The application asks you to authorize access when you choose an account. Click OK to confirm.

Also read: Tool integration: Why is it important for your business workflow between departments?

YouTube API pricing

The YouTube Data API is free API and Google does not charge you for accessing the YouTube API. YouTube API has restricted number of usages or number of requests your application can make to an API over a period of time (quota). The default cap for any Google Cloud project is 10,000 units each day.

This is usually sufficient for most API users. If you would like to request additional quota your project will be audited to ensure it complies with YouTube API terms of service. You can view Quota Calculator to calculate the cost for calling different API methods. 

What is YouTube music API?

Ytmusicapi is a Python 3 library that sends requests to the YouTube music API. You can find Ytmusicapi in GitHub. The API allows for the following features – 

• Browsing
• Explore music
• Library management
• Playlist 
• Uploads

What is YouTube search API?

YouTube search API endpoint allows you to scrape the result from YouTube search engine via the SerpAPIService. Common parameters used –

• search_query – Parameter defines the search query. You can use anything that you would use in a regular YouTube search.
• Localization – Paraamter defines the language and region of the search results. You can specify geographical and linguistic specific results. 

What is YouTube analytics API?

You can use YouTube analytics API to create unique reports. Both channels and content owners can access reports via the API. There are two types of report fields: dimensions and metrics.

• Dimensions are conventional criteria used to aggregate data, like the user’s country or the date of the action.  

Each data row in the report has a different set of dimensional values. YouTube calculates the values of the report based on the dimensions selected you select. 

• Metrics are specific measurements of user behavior, ad effectiveness, or projected revenue. Metrics tracking user activity include things like rating and view counts. The analytics API offers filtering and sorting therefore the caller application is not required to have native support for those features. The API also enables you to access data for groups created by YouTube Analytics, which can contain up to 500 videos, playlists, channels, or other assets.

What is YouTube shorts API?

YouTube Shorts are short videos that anyone can make using their mobile phones. Developers can use YouTube Shorts API to incorporate Shorts functionality into their products or services. It enables programmers to make tools that let users interact with Shorts material, upload and share videos, and access licensed music and sound effects.

Along with data to assist developers monitor performance and user engagement, the API offers capabilities for controlling Shorts content.

What is YouTube player API?

Coders can use the  YouTube player API to embed a YouTube Player on your website and control it with JavaScript. You can queue videos for playback, start, pause, or stop them, change the player volume, or get details about the video that is now playing using the JavaScript functions of the API. Additionally, you can include event listeners, which will run in reaction to certain player events like a player status change.

Also read: APIs Aren’t Just for Tech Companies

What is YouTube ads API?

YouTube advertising are a popular medium of communication, and you pay only when people watch your ads. The YouTube ads API is a programming interface for Google Ads is the Google Ads API. Developers can use it to communicate directly with the Google Ad platform, improving the effectiveness of handling extensive or intricate YouTube Ad campaigns. Some use scenarios are-

• Automated account management
• Custom reporting
• Ad management based on inventory
• Manage Smart Bidding strategies

What is YouTube reporting API?

YouTube Reporting API and YouTube Analytical Data lets you get YouTube Analytics data to automate challenging reporting tasks, create custom dashboards, and much more. You can use the Reporting API to support applications and collect and store bulk reports and provide tools for data mining, filtering, and sorting.  The Analytics API allows for focused immediate queries that produce a personalized response to user input.

What is YouTube feed API?

The YouTube Feed API is a subset of the YouTube Data API that enables developers to get and display specified subsets of YouTube video material, such as user-uploaded videos, the most recent uploads to a channel, or the most well-liked videos in a given area or category.

By integrating this API into their own applications and services, developers may utilize it to build unique video feeds that let consumers browse and watch YouTube content without ever leaving their platform.

What is YouTube livestream API?

You may create, update, and administer live events on YouTube using the YouTube Live Streaming API. The API allows you to schedule broadcasts and link them to video streams, which serve as the broadcast’s real content. Actually, parts of the YouTube Data API and YouTube Content ID API make up the Live Streaming API.

Users of YouTube can manage their accounts using the Data API, and they can engage with YouTube’s rights management system using the YouTube Content ID API. But only live events are created and managed using the resources that make up the Live Streaming API.

How to Hire YouTube API developers?

Before you hire YouTube API developers you need to create a project outline and define the roles of the project manager. You can post your requirements or relevant job boards like Unremot, Upwork, and LinkedIn.

Remember to add requirements such as skills required, experiences, project time frame, and budget. After shortlisting candidates, you can conduct interviews to assess candidates and carry out reference checks. Once you have found your candidate make an offer that details the scope of their work and compensation.