playlists.insert method to create a private playlist
7 | owned by the channel authorizing the request.
8 |
9 | ### [Retrieve my uploads](/dotnet/MyUploads.cs)
10 |
11 | Method: youtube.playlistItems.listplaylistItems.list method to retrieve a list of videos
13 | uploaded to the channel associated with the request. The code also calls the channels.list method with the
14 | mine parameter set to true to retrieve the playlist ID that identifies the channel's uploaded
15 | videos.
16 |
17 | ### [Search by keyword](/dotnet/Search.cs)
18 |
19 | Method: youtube.search.listsearch.list method to retrieve search results
21 | associated with a particular keyword.
22 |
23 | ### [Upload a video](/dotnet/UploadVideo.cs)
24 |
25 | Method: youtube.videos.insertvideos.insert method to upload a video to the channel
27 | associated with the request.
28 |
--------------------------------------------------------------------------------
/dotnet/Search.cs:
--------------------------------------------------------------------------------
1 | using System;
2 | using System.Collections.Generic;
3 | using System.IO;
4 | using System.Reflection;
5 | using System.Threading;
6 | using System.Threading.Tasks;
7 |
8 | using Google.Apis.Auth.OAuth2;
9 | using Google.Apis.Services;
10 | using Google.Apis.Upload;
11 | using Google.Apis.Util.Store;
12 | using Google.Apis.YouTube.v3;
13 | using Google.Apis.YouTube.v3.Data;
14 |
15 | namespace Google.Apis.YouTube.Samples
16 | {
17 | /// playlistItems.list method to retrieve a list of
67 | videos uploaded to the channel associated with the request. The code also calls the channels.list
68 | method with the mine parameter set to true to retrieve the playlist ID that identifies
69 | the channel's uploaded videos.
70 |
71 | ### [Search by keyword](/go/search_by_keyword.go)
72 |
73 | Method: youtube.search.listsearch.list method to retrieve search results associated
75 | with a particular keyword.
76 |
77 | ### [Upload a video](/go/upload_video.go)
78 |
79 | Method: youtube.videos.insertvideos.insert method to upload a video to the channel
81 | associated with the request.
82 |
--------------------------------------------------------------------------------
/go/client_secrets.json.sample:
--------------------------------------------------------------------------------
1 | {
2 | "installed": {
3 | "client_id": "YOUR_CLIENT_ID_HERE",
4 | "client_secret": "YOUR_CLIENT_SECRET_HERE",
5 | "redirect_uris": ["http://localhost:8080/oauth2callback"],
6 | "auth_uri": "https://accounts.google.com/o/oauth2/auth",
7 | "token_uri": "https://accounts.google.com/o/oauth2/token"
8 | }
9 | }
10 |
--------------------------------------------------------------------------------
/go/errors.go:
--------------------------------------------------------------------------------
1 | package main
2 |
3 | import (
4 | "log"
5 | )
6 |
7 | func handleError(err error, message string) {
8 | if message == "" {
9 | message = "Error making API call"
10 | }
11 | if err != nil {
12 | log.Fatalf(message + ": %v", err.Error())
13 | }
14 | }
15 |
--------------------------------------------------------------------------------
/go/my_uploads.go:
--------------------------------------------------------------------------------
1 | package main
2 |
3 | import (
4 | "fmt"
5 | "log"
6 |
7 | "google.golang.org/api/youtube/v3"
8 | )
9 |
10 | // Retrieve playlistItems in the specified playlist
11 | func playlistItemsList(service *youtube.Service, part string, playlistId string, pageToken string) *youtube.PlaylistItemListResponse {
12 | call := service.PlaylistItems.List(part)
13 | call = call.PlaylistId(playlistId)
14 | if pageToken != "" {
15 | call = call.PageToken(pageToken)
16 | }
17 | response, err := call.Do()
18 | handleError(err, "")
19 | return response
20 | }
21 |
22 | // Retrieve resource for the authenticated user's channel
23 | func channelsListMine(service *youtube.Service, part string) *youtube.ChannelListResponse {
24 | call := service.Channels.List(part)
25 | call = call.Mine(true)
26 | response, err := call.Do()
27 | handleError(err, "")
28 | return response
29 | }
30 |
31 | func main() {
32 | client := getClient(youtube.YoutubeReadonlyScope)
33 | service, err := youtube.New(client)
34 |
35 | if err != nil {
36 | log.Fatalf("Error creating YouTube client: %v", err)
37 | }
38 |
39 | response := channelsListMine(service, "contentDetails")
40 |
41 | for _, channel := range response.Items {
42 | playlistId := channel.ContentDetails.RelatedPlaylists.Uploads
43 |
44 | // Print the playlist ID for the list of uploaded videos.
45 | fmt.Printf("Videos in list %s\r\n", playlistId)
46 |
47 | nextPageToken := ""
48 | for {
49 | // Retrieve next set of items in the playlist.
50 | playlistResponse := playlistItemsList(service, "snippet", playlistId, nextPageToken)
51 |
52 | for _, playlistItem := range playlistResponse.Items {
53 | title := playlistItem.Snippet.Title
54 | videoId := playlistItem.Snippet.ResourceId.VideoId
55 | fmt.Printf("%v, (%v)\r\n", title, videoId)
56 | }
57 |
58 | // Set the token to retrieve the next page of results
59 | // or exit the loop if all results have been retrieved.
60 | nextPageToken = playlistResponse.NextPageToken
61 | if nextPageToken == "" {
62 | break
63 | }
64 | fmt.Println()
65 | }
66 | }
67 | }
68 |
--------------------------------------------------------------------------------
/go/playlists.go:
--------------------------------------------------------------------------------
1 | package main
2 |
3 | import (
4 | "flag"
5 | "fmt"
6 | "log"
7 |
8 | "google.golang.org/api/youtube/v3"
9 | )
10 |
11 | var (
12 | method = flag.String("method", "list", "The API method to execute. (List is the only method that this sample currently supports.")
13 |
14 | channelId = flag.String("channelId", "", "Retrieve playlists for this channel. Value is a YouTube channel ID.")
15 | hl = flag.String("hl", "", "Retrieve localized resource metadata for the specified application language.")
16 | maxResults = flag.Int64("maxResults", 5, "The maximum number of playlist resources to include in the API response.")
17 | mine = flag.Bool("mine", false, "List playlists for authenticated user's channel. Default: false.")
18 | onBehalfOfContentOwner = flag.String("onBehalfOfContentOwner", "", "Indicates that the request's auth credentials identify a user authorized to act on behalf of the specified content owner.")
19 | pageToken = flag.String("pageToken", "", "Token that identifies a specific page in the result set that should be returned.")
20 | part = flag.String("part", "snippet", "Comma-separated list of playlist resource parts that API response will include.")
21 | playlistId = flag.String("playlistId", "", "Retrieve information about this playlist.")
22 | )
23 |
24 | func playlistsList(service *youtube.Service, part string, channelId string, hl string, maxResults int64, mine bool, onBehalfOfContentOwner string, pageToken string, playlistId string) *youtube.PlaylistListResponse {
25 | call := service.Playlists.List(part)
26 | if channelId != "" {
27 | call = call.ChannelId(channelId)
28 | }
29 | if hl != "" {
30 | call = call.Hl(hl)
31 | }
32 | call = call.MaxResults(maxResults)
33 | if mine != false {
34 | call = call.Mine(true)
35 | }
36 | if onBehalfOfContentOwner != "" {
37 | call = call.OnBehalfOfContentOwner(onBehalfOfContentOwner)
38 | }
39 | if pageToken != "" {
40 | call = call.PageToken(pageToken)
41 | }
42 | if playlistId != "" {
43 | call = call.Id(playlistId)
44 | }
45 | response, err := call.Do()
46 | handleError(err, "")
47 | return response
48 | }
49 |
50 | func main() {
51 | flag.Parse()
52 |
53 | if *channelId == "" && *mine == false && *playlistId == "" {
54 | log.Fatalf("You must either set a value for the channelId or playlistId flag or set the mine flag to 'true'.")
55 | }
56 | client := getClient(youtube.YoutubeReadonlyScope)
57 |
58 | service, err := youtube.New(client)
59 | if err != nil {
60 | log.Fatalf("Error creating YouTube client: %v", err)
61 | }
62 |
63 | response := playlistsList(service, "snippet,contentDetails", *channelId, *hl, *maxResults, *mine, *onBehalfOfContentOwner, *pageToken, *playlistId)
64 |
65 | for _, playlist := range response.Items {
66 | playlistId := playlist.Id
67 | playlistTitle := playlist.Snippet.Title
68 |
69 | // Print the playlist ID and title for the playlist resource.
70 | fmt.Println(playlistId, ": ", playlistTitle)
71 | }
72 | }
73 |
--------------------------------------------------------------------------------
/go/search_by_keyword.go:
--------------------------------------------------------------------------------
1 | package main
2 |
3 | import (
4 | "flag"
5 | "fmt"
6 | "log"
7 | "net/http"
8 |
9 | "google.golang.org/api/googleapi/transport"
10 | "google.golang.org/api/youtube/v3"
11 | )
12 |
13 | var (
14 | query = flag.String("query", "Google", "Search term")
15 | maxResults = flag.Int64("max-results", 25, "Max YouTube results")
16 | )
17 |
18 | const developerKey = "YOUR DEVELOPER KEY"
19 |
20 | func main() {
21 | flag.Parse()
22 |
23 | client := &http.Client{
24 | Transport: &transport.APIKey{Key: developerKey},
25 | }
26 |
27 | service, err := youtube.New(client)
28 | if err != nil {
29 | log.Fatalf("Error creating new YouTube client: %v", err)
30 | }
31 |
32 | // Make the API call to YouTube.
33 | call := service.Search.List("id,snippet").
34 | Q(*query).
35 | MaxResults(*maxResults)
36 | response, err := call.Do()
37 | handleError(err, "")
38 |
39 | // Group video, channel, and playlist results in separate lists.
40 | videos := make(map[string]string)
41 | channels := make(map[string]string)
42 | playlists := make(map[string]string)
43 |
44 | // Iterate through each item and add it to the correct list.
45 | for _, item := range response.Items {
46 | switch item.Id.Kind {
47 | case "youtube#video":
48 | videos[item.Id.VideoId] = item.Snippet.Title
49 | case "youtube#channel":
50 | channels[item.Id.ChannelId] = item.Snippet.Title
51 | case "youtube#playlist":
52 | playlists[item.Id.PlaylistId] = item.Snippet.Title
53 | }
54 | }
55 |
56 | printIDs("Videos", videos)
57 | printIDs("Channels", channels)
58 | printIDs("Playlists", playlists)
59 | }
60 |
61 | // Print the ID and title of each result in a list as well as a name that
62 | // identifies the list. For example, print the word section name "Videos"
63 | // above a list of video search results, followed by the video ID and title
64 | // of each matching video.
65 | func printIDs(sectionName string, matches map[string]string) {
66 | fmt.Printf("%v:\n", sectionName)
67 | for id, title := range matches {
68 | fmt.Printf("[%v] %v\n", id, title)
69 | }
70 | fmt.Printf("\n\n")
71 | }
72 |
--------------------------------------------------------------------------------
/go/upload_video.go:
--------------------------------------------------------------------------------
1 | package main
2 |
3 | import (
4 | "flag"
5 | "fmt"
6 | "log"
7 | "os"
8 | "strings"
9 |
10 | "google.golang.org/api/youtube/v3"
11 | )
12 |
13 | var (
14 | filename = flag.String("filename", "", "Name of video file to upload")
15 | title = flag.String("title", "Test Title", "Video title")
16 | description = flag.String("description", "Test Description", "Video description")
17 | category = flag.String("category", "22", "Video category")
18 | keywords = flag.String("keywords", "", "Comma separated list of video keywords")
19 | privacy = flag.String("privacy", "unlisted", "Video privacy status")
20 | )
21 |
22 | func main() {
23 | flag.Parse()
24 |
25 | if *filename == "" {
26 | log.Fatalf("You must provide a filename of a video file to upload")
27 | }
28 |
29 | client := getClient(youtube.YoutubeUploadScope)
30 |
31 | service, err := youtube.New(client)
32 | if err != nil {
33 | log.Fatalf("Error creating YouTube client: %v", err)
34 | }
35 |
36 | upload := &youtube.Video{
37 | Snippet: &youtube.VideoSnippet{
38 | Title: *title,
39 | Description: *description,
40 | CategoryId: *category,
41 | },
42 | Status: &youtube.VideoStatus{PrivacyStatus: *privacy},
43 | }
44 |
45 | // The API returns a 400 Bad Request response if tags is an empty string.
46 | if strings.Trim(*keywords, "") != "" {
47 | upload.Snippet.Tags = strings.Split(*keywords, ",")
48 | }
49 |
50 | call := service.Videos.Insert("snippet,status", upload)
51 |
52 | file, err := os.Open(*filename)
53 | defer file.Close()
54 | if err != nil {
55 | log.Fatalf("Error opening %v: %v", *filename, err)
56 | }
57 |
58 | response, err := call.Media(file).Do()
59 | handleError(err, "")
60 | fmt.Printf("Upload successful! Video ID: %v\n", response.Id)
61 | }
62 |
--------------------------------------------------------------------------------
/java/pom.xml:
--------------------------------------------------------------------------------
1 | ' + title + ' - ' + videoId + '
'); 61 | } 62 | 63 | // Retrieve the next page of videos in the playlist. 64 | function nextPage() { 65 | requestVideoPlaylist(playlistId, nextPageToken); 66 | } 67 | 68 | // Retrieve the previous page of videos in the playlist. 69 | function previousPage() { 70 | requestVideoPlaylist(playlistId, prevPageToken); 71 | } 72 | -------------------------------------------------------------------------------- /javascript/nodejs-quickstart.js: -------------------------------------------------------------------------------- 1 | var fs = require('fs'); 2 | var readline = require('readline'); 3 | var {google} = require('googleapis'); 4 | var OAuth2 = google.auth.OAuth2; 5 | 6 | // If modifying these scopes, delete your previously saved credentials 7 | // at ~/.credentials/youtube-nodejs-quickstart.json 8 | var SCOPES = ['https://www.googleapis.com/auth/youtube.readonly']; 9 | var TOKEN_DIR = (process.env.HOME || process.env.HOMEPATH || 10 | process.env.USERPROFILE) + '/.credentials/'; 11 | var TOKEN_PATH = TOKEN_DIR + 'youtube-nodejs-quickstart.json'; 12 | 13 | // Load client secrets from a local file. 14 | fs.readFile('client_secret.json', function processClientSecrets(err, content) { 15 | if (err) { 16 | console.log('Error loading client secret file: ' + err); 17 | return; 18 | } 19 | // Authorize a client with the loaded credentials, then call the YouTube API. 20 | authorize(JSON.parse(content), getChannel); 21 | }); 22 | 23 | /** 24 | * Create an OAuth2 client with the given credentials, and then execute the 25 | * given callback function. 26 | * 27 | * @param {Object} credentials The authorization client credentials. 28 | * @param {function} callback The callback to call with the authorized client. 29 | */ 30 | function authorize(credentials, callback) { 31 | var clientSecret = credentials.installed.client_secret; 32 | var clientId = credentials.installed.client_id; 33 | var redirectUrl = credentials.installed.redirect_uris[0]; 34 | var oauth2Client = new OAuth2(clientId, clientSecret, redirectUrl); 35 | 36 | // Check if we have previously stored a token. 37 | fs.readFile(TOKEN_PATH, function(err, token) { 38 | if (err) { 39 | getNewToken(oauth2Client, callback); 40 | } else { 41 | oauth2Client.credentials = JSON.parse(token); 42 | callback(oauth2Client); 43 | } 44 | }); 45 | } 46 | 47 | /** 48 | * Get and store new token after prompting for user authorization, and then 49 | * execute the given callback with the authorized OAuth2 client. 50 | * 51 | * @param {google.auth.OAuth2} oauth2Client The OAuth2 client to get token for. 52 | * @param {getEventsCallback} callback The callback to call with the authorized 53 | * client. 54 | */ 55 | function getNewToken(oauth2Client, callback) { 56 | var authUrl = oauth2Client.generateAuthUrl({ 57 | access_type: 'offline', 58 | scope: SCOPES 59 | }); 60 | console.log('Authorize this app by visiting this url: ', authUrl); 61 | var rl = readline.createInterface({ 62 | input: process.stdin, 63 | output: process.stdout 64 | }); 65 | rl.question('Enter the code from that page here: ', function(code) { 66 | rl.close(); 67 | oauth2Client.getToken(code, function(err, token) { 68 | if (err) { 69 | console.log('Error while trying to retrieve access token', err); 70 | return; 71 | } 72 | oauth2Client.credentials = token; 73 | storeToken(token); 74 | callback(oauth2Client); 75 | }); 76 | }); 77 | } 78 | 79 | /** 80 | * Store token to disk be used in later program executions. 81 | * 82 | * @param {Object} token The token to store to disk. 83 | */ 84 | function storeToken(token) { 85 | try { 86 | fs.mkdirSync(TOKEN_DIR); 87 | } catch (err) { 88 | if (err.code != 'EEXIST') { 89 | throw err; 90 | } 91 | } 92 | fs.writeFile(TOKEN_PATH, JSON.stringify(token), (err) => { 93 | if (err) throw err; 94 | console.log('Token stored to ' + TOKEN_PATH); 95 | }); 96 | } 97 | 98 | /** 99 | * Lists the names and IDs of up to 10 files. 100 | * 101 | * @param {google.auth.OAuth2} auth An authorized OAuth2 client. 102 | */ 103 | function getChannel(auth) { 104 | var service = google.youtube('v3'); 105 | service.channels.list({ 106 | auth: auth, 107 | part: 'snippet,contentDetails,statistics', 108 | forUsername: 'GoogleDevelopers' 109 | }, function(err, response) { 110 | if (err) { 111 | console.log('The API returned an error: ' + err); 112 | return; 113 | } 114 | var channels = response.data.items; 115 | if (channels.length == 0) { 116 | console.log('No channel found.'); 117 | } else { 118 | console.log('This channel\'s ID is %s. Its title is \'%s\', and ' + 119 | 'it has %s views.', 120 | channels[0].id, 121 | channels[0].snippet.title, 122 | channels[0].statistics.viewCount); 123 | } 124 | }); 125 | } 126 | -------------------------------------------------------------------------------- /javascript/playlist_updates.html: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 |' + JSON.stringify(response.result) + ''); 71 | }); 72 | } 73 | -------------------------------------------------------------------------------- /javascript/quickstart.html: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 |
YouTube Data API Quickstart
9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 114 | 115 | 119 | 120 | 121 | -------------------------------------------------------------------------------- /javascript/search.html: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 |' + str + ''); 17 | }); 18 | } 19 | -------------------------------------------------------------------------------- /javascript/upload_video.css: -------------------------------------------------------------------------------- 1 | #channel-image { 2 | width: 2em; 3 | height: 2em; 4 | vertical-align: middle; 5 | } 6 | 7 | #channel-name { 8 | margin-left: 0.2em; 9 | margin-right: 0.2em; 10 | } 11 | 12 | #disclaimer { 13 | font-size: 0.75em; 14 | color: #aeaeae; 15 | max-width: 350px; 16 | } 17 | 18 | body { 19 | font-family: "Open Sans", sans-serif; 20 | font-size: 1.5em; 21 | } 22 | 23 | .post-sign-in { 24 | display: none; 25 | } 26 | 27 | .during-upload { 28 | display: none; 29 | } 30 | 31 | .post-upload { 32 | display: none; 33 | } 34 | 35 | label { 36 | display: block; 37 | } 38 | 39 | input[type="text"], textarea, progress { 40 | font-size: 0.75em; 41 | width: 15em; 42 | margin-bottom: 1em; 43 | padding: 0.5em; 44 | font-family: "Open Sans", sans-serif; 45 | } 46 | 47 | textarea { 48 | height: 7em; 49 | } 50 | -------------------------------------------------------------------------------- /javascript/upload_video.html: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 |
% done (/ bytes)
50 | 51 |Uploaded video with id . Polling for status...
55 |By uploading a video, you certify that you own all rights to the content or that you are authorized by the owner to make the content publicly available on YouTube, and that it otherwise complies with the YouTube Terms of Service located at http://www.youtube.com/t/terms
59 |A service error occurred: %s
An client error occurred: %s
composer require google/apiclient:~2.0 in ""
14 |
15 | A service error occurred: %s
An client error occurred: %s
86 | You need to set \$OAUTH2_CLIENT_ID and
87 | \$OAUTH2_CLIENT_ID before proceeding.
88 |
89 | END;
90 | } else {
91 | // If the user hasn't authorized the app, initiate the OAuth flow
92 | $state = mt_rand();
93 | $client->setState($state);
94 | $_SESSION['state'] = $state;
95 |
96 | $authUrl = $client->createAuthUrl();
97 | $htmlBody = << You need to authorize access before proceeding.
100 | END;
101 | }
102 | ?>
103 |
104 |
105 |
106 | A service error occurred: An client error occurred:
84 | You need to set
87 | END;
88 | } else {
89 | // If the user hasn't authorized the app, initiate the OAuth flow
90 | $state = mt_rand();
91 | $client->setState($state);
92 | $_SESSION['state'] = $state;
93 |
94 | $authUrl = $client->createAuthUrl();
95 | $htmlBody = << You need to authorize access before proceeding.
98 | END;
99 | }
100 | ?>
101 |
102 |
103 |
104 | A service error occurred: An client error occurred:
96 | You need to set
99 | END;
100 | } else {
101 | $state = mt_rand();
102 | $client->setState($state);
103 | $_SESSION['state'] = $state;
104 |
105 | $authUrl = $client->createAuthUrl();
106 | $htmlBody = << You need to authorize access before proceeding.
109 | END;
110 | }
111 | ?>
112 |
113 |
114 |
115 | A service error occurred: An client error occurred: Live Streams
";
65 | foreach ($streamsResponse['items'] as $streamItem) {
66 | $htmlBody .= sprintf('
';
70 |
71 | } catch (Google_Service_Exception $e) {
72 | $htmlBody = sprintf('%s%s\$OAUTH2_CLIENT_ID and
85 | \$OAUTH2_CLIENT_ID before proceeding.
86 | Videos in list $uploadsListId
";
77 | foreach ($playlistItemsResponse['items'] as $playlistItem) {
78 | $htmlBody .= sprintf('
';
82 | }
83 | } catch (Google_Service_Exception $e) {
84 | $htmlBody = sprintf('%s%s\$OAUTH2_CLIENT_ID and
97 | \$OAUTH2_CLIENT_ID before proceeding.
98 |
20 | Search Term:
21 |
22 |
23 | Max Results:
24 |
25 |
26 |
27 | END;
28 |
29 | // This code will execute if the user entered a search query in the form
30 | // and submitted the form. Otherwise, the page displays the form above.
31 | if (isset($_GET['q']) && isset($_GET['maxResults'])) {
32 | /*
33 | * Set $DEVELOPER_KEY to the "API key" value from the "Access" tab of the
34 | * {{ Google Cloud Console }} <{{ https://cloud.google.com/console }}>
35 | * Please ensure that you have enabled the YouTube Data API for your project.
36 | */
37 | $DEVELOPER_KEY = 'REPLACE_ME';
38 |
39 | $client = new Google_Client();
40 | $client->setDeveloperKey($DEVELOPER_KEY);
41 |
42 | // Define an object that will be used to make all API requests.
43 | $youtube = new Google_Service_YouTube($client);
44 |
45 | $htmlBody = '';
46 | try {
47 |
48 | // Call the search.list method to retrieve results matching the specified
49 | // query term.
50 | $searchResponse = $youtube->search->listSearch('id,snippet', array(
51 | 'q' => $_GET['q'],
52 | 'maxResults' => $_GET['maxResults'],
53 | ));
54 |
55 | $videos = '';
56 | $channels = '';
57 | $playlists = '';
58 |
59 | // Add each result to the appropriate list, and then display the lists of
60 | // matching videos, channels, and playlists.
61 | foreach ($searchResponse['items'] as $searchResult) {
62 | switch ($searchResult['id']['kind']) {
63 | case 'youtube#video':
64 | $videos .= sprintf('$videos
81 | Channels
82 | $channels
83 | Playlists
84 | $playlists
85 | END;
86 | } catch (Google_Service_Exception $e) {
87 | $htmlBody .= sprintf('%s%s
21 |
60 |
61 |
--------------------------------------------------------------------------------
/player/event_listeners.js:
--------------------------------------------------------------------------------
1 | var player;
2 | // Callback for when the YouTube iFrame player is ready
3 | function onYouTubeIframeAPIReady() {
4 | player = new YT.Player('player', {
5 | // Set Player height and width
6 | height: '390',
7 | width: '640',
8 | // Set the id of the video to be played
9 | videoId: 'M7lc1UVf-VE',
10 | events: {
11 | 'onReady': onPlayerReady
12 | // You can add more event listeners here
13 | }
14 | });
15 | };
16 |
17 | function onPlayerReady (){
18 | //add onStateChange event handler
19 | player.addEventListener("onStateChange","onPlayerStateChange");
20 |
21 | //add your own rate listener below:
22 |
23 | };
24 |
25 | function onPlayerStateChange(event){
26 | // Get current state
27 | var currentState;
28 | if (event.data == YT.PlayerState.ENDED){
29 | currentState = "Ended";
30 | }
31 | else if (event.data == YT.PlayerState.PLAYING){
32 | currentState = "Playing";
33 | }
34 | else if (event.data == YT.PlayerState.PAUSED){
35 | currentState = "Paused";
36 | }
37 | else if (event.data == YT.PlayerState.BUFFERING){
38 | currentState = "Buffering";
39 | }
40 | else if (event.data == YT.PlayerState.CUED){
41 | currentState = "Cued";
42 | } else{
43 | currentState = "Unknown";
44 | }
45 |
46 | currentState += " (" + event.data + ")"
47 | // Update video state div
48 | document.getElementById('currentState').innerText = currentState;
49 | };
50 |
51 | function onPlaybackRateChange(event){
52 | // Implment this function to display the rate of the player on the page
53 | var currentRate;
54 |
55 | // You code goes here
56 |
57 | document.getElementById('currentRate').innerText = currentRate;
58 | }
--------------------------------------------------------------------------------
/player/player_control.html:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
22 | YouTube in Your App
23 |
28 |
32 |
33 |
34 |
35 |
36 |
37 |
38 |
39 |
40 |
41 |
42 |
59 |
43 |
58 |
44 |
50 | Current Player Status:
45 |
46 |
47 |
48 |
49 |
51 |
57 | Current Player Rate:
52 |
53 |
54 |
55 |
56 |
21 |
22 | YouTube in Your App
23 |
28 |
32 |
33 |
34 |
50 |
51 |
--------------------------------------------------------------------------------
/player/player_control.js:
--------------------------------------------------------------------------------
1 | var player;
2 | // Callback for when the YouTube iFrame player is ready
3 | function onYouTubeIframeAPIReady() {
4 | player = new YT.Player('player', {
5 | // Set Player height and width
6 | height: '390',
7 | width: '640',
8 | // Set the id of the video to be played
9 | videoId: 'M7lc1UVf-VE',
10 | // Setup event listeners
11 | // These are covered in the next section
12 | events: {
13 | 'onReady': onPlayerReady
14 | }
15 | });
16 | };
17 |
18 | function onPlayerReady (){
19 | player.playVideo();
20 | setTimeout(pauseVideo, 4000);
21 | setTimeout(loadNewVideo, 6000);
22 | setTimeout(stopVideo, 8500);
23 | setInterval(getContent, 1000);
24 | };
25 |
26 | function pauseVideo(){
27 | player.pauseVideo();
28 | }
29 |
30 | function loadNewVideo(){
31 | player.loadVideoById("me91AGSVsyo");
32 | }
33 |
34 | function stopVideo(){
35 | player.stopVideo();
36 | }
37 |
38 | function getContent(){
39 | var content
40 | content = player.INSERT_METHOD_HERE;
41 | document.getElementById('content').innerText = content
42 | }
--------------------------------------------------------------------------------
/python/add_featured_video.py:
--------------------------------------------------------------------------------
1 | #!/usr/bin/python
2 |
3 | import httplib2
4 | import os
5 | import sys
6 |
7 | from apiclient.discovery import build
8 | from apiclient.errors import HttpError
9 | from oauth2client.client import flow_from_clientsecrets
10 | from oauth2client.file import Storage
11 | from oauth2client.tools import argparser, run_flow
12 |
13 |
14 | # The CLIENT_SECRETS_FILE variable specifies the name of a file that contains
15 | # the OAuth 2.0 information for this application, including its client_id and
16 | # client_secret. You can acquire an OAuth 2.0 client ID and client secret from
17 | # the {{ Google Cloud Console }} at
18 | # {{ https://cloud.google.com/console }}.
19 | # Please ensure that you have enabled the YouTube Data API for your project.
20 | # For more information about using OAuth2 to access the YouTube Data API, see:
21 | # https://developers.google.com/youtube/v3/guides/authentication
22 | # For more information about the client_secrets.json file format, see:
23 | # https://developers.google.com/api-client-library/python/guide/aaa_client_secrets
24 |
25 | CLIENT_SECRETS_FILE = "client_secrets.json"
26 |
27 | # This variable defines a message to display if the CLIENT_SECRETS_FILE is
28 | # missing.
29 | MISSING_CLIENT_SECRETS_MESSAGE = """
30 | WARNING: Please configure OAuth 2.0
31 |
32 | To make this sample run you will need to populate the client_secrets.json file
33 | found at:
34 |
35 | %s
36 |
37 | with information from the {{ Cloud Console }}
38 | {{ https://cloud.google.com/console }}
39 |
40 | For more information about the client_secrets.json file format, please visit:
41 | https://developers.google.com/api-client-library/python/guide/aaa_client_secrets
42 | """ % os.path.abspath(os.path.join(os.path.dirname(__file__),
43 | CLIENT_SECRETS_FILE))
44 |
45 | # This OAuth 2.0 access scope allows for full read/write access to the
46 | # authenticated user's account.
47 | YOUTUBE_SCOPE = "https://www.googleapis.com/auth/youtube"
48 | YOUTUBE_API_SERVICE_NAME = "youtube"
49 | YOUTUBE_API_VERSION = "v3"
50 |
51 | # If offsetMs is not valid, the API will throw an error
52 | VALID_OFFSET_TYPES = ("offsetFromEnd", "offsetFromStart",)
53 |
54 | def get_authenticated_service(args):
55 | flow = flow_from_clientsecrets(CLIENT_SECRETS_FILE, scope=YOUTUBE_SCOPE,
56 | message=MISSING_CLIENT_SECRETS_MESSAGE)
57 |
58 | storage = Storage("%s-oauth2.json" % sys.argv[0])
59 | credentials = storage.get()
60 |
61 | if credentials is None or credentials.invalid:
62 | credentials = run_flow(flow, storage, args)
63 |
64 | return build(YOUTUBE_API_SERVICE_NAME, YOUTUBE_API_VERSION,
65 | http=credentials.authorize(httplib2.Http()))
66 |
67 | def add_featured_video(youtube, options):
68 | add_video_request = youtube.channels().update(
69 | part="invideoPromotion",
70 | # You can use the API Explorer to test API requests:
71 | # https://developers.google.com/youtube/v3/docs/channels/update#try-it
72 | body={
73 | "invideoPromotion": {
74 | "items": [{
75 | "id": {
76 | "type": "video",
77 | "videoId": options.video_id
78 | },
79 | "timing": {
80 | "offsetMs": options.offset_ms,
81 | "type": options.offset_type
82 | }
83 | }],
84 | },
85 | "id": options.channel_id
86 | }).execute()
87 |
88 | if __name__ == '__main__':
89 | argparser.add_argument("--channel-id", required=True,
90 | help="Channel ID of the channel to add a featured video")
91 | argparser.add_argument("--video-id", required=True,
92 | help="Video ID to feature on your channel")
93 | argparser.add_argument("--offset-ms",
94 | help="Offset in milliseconds to show video.",
95 | default="10000")
96 | argparser.add_argument("--offset-type", choices=VALID_OFFSET_TYPES,
97 | help="Whether the offset is from the beginning or end of video playback.",
98 | default=VALID_OFFSET_TYPES[0])
99 | args = argparser.parse_args()
100 |
101 | youtube = get_authenticated_service(args)
102 | try:
103 | add_featured_video(youtube, args)
104 | except HttpError, e:
105 | print "An HTTP error %d occurred:\n%s" % (e.resp.status, e.content)
106 | else:
107 | print "Added featured video %s to channel %s." % (
108 | args.video_id, args.channel_id)
109 |
--------------------------------------------------------------------------------
/python/add_subscription.py:
--------------------------------------------------------------------------------
1 | #!/usr/bin/python
2 |
3 | # This code sample shows how to add a channel subscription.
4 | # The default channel-id is for the GoogleDevelopers YouTube channel.
5 | # Sample usage:
6 | # python add_subscription.py --channel-id=UC_x5XG1OV2P6uZZ5FSM9Ttw
7 |
8 | import argparse
9 | import os
10 | import re
11 |
12 | import google.oauth2.credentials
13 | import google_auth_oauthlib.flow
14 | from googleapiclient.discovery import build
15 | from googleapiclient.errors import HttpError
16 | from google_auth_oauthlib.flow import InstalledAppFlow
17 |
18 |
19 | # The CLIENT_SECRETS_FILE variable specifies the name of a file that contains
20 | # the OAuth 2.0 information for this application, including its client_id and
21 | # client_secret. You can acquire an OAuth 2.0 client ID and client secret from
22 | # the {{ Google Cloud Console }} at
23 | # {{ https://cloud.google.com/console }}.
24 | # Please ensure that you have enabled the YouTube Data API for your project.
25 | # For more information about using OAuth2 to access the YouTube Data API, see:
26 | # https://developers.google.com/youtube/v3/guides/authentication
27 | # For more information about the client_secrets.json file format, see:
28 | # https://developers.google.com/api-client-library/python/guide/aaa_client_secrets
29 | CLIENT_SECRETS_FILE = 'client_secret.json'
30 |
31 | # This OAuth 2.0 access scope allows for full read/write access to the
32 | # authenticated user's account.
33 | SCOPES = ['https://www.googleapis.com/auth/youtube']
34 | API_SERVICE_NAME = 'youtube'
35 | API_VERSION = 'v3'
36 |
37 | def get_authenticated_service():
38 | flow = InstalledAppFlow.from_client_secrets_file(CLIENT_SECRETS_FILE, SCOPES)
39 | credentials = flow.run_console()
40 | return build(API_SERVICE_NAME, API_VERSION, credentials = credentials)
41 |
42 | # This method calls the API's youtube.subscriptions.insert method to add a
43 | # subscription to the specified channel.
44 | def add_subscription(youtube, channel_id):
45 | add_subscription_response = youtube.subscriptions().insert(
46 | part='snippet',
47 | body=dict(
48 | snippet=dict(
49 | resourceId=dict(
50 | channelId=channel_id
51 | )
52 | )
53 | )).execute()
54 |
55 | return add_subscription_response['snippet']['title']
56 |
57 | if __name__ == '__main__':
58 | parser = argparse.ArgumentParser(description='Process arguments.')
59 | parser.add_argument('--channel-id', help='ID of the channel to subscribe to.',
60 | default='UC_x5XG1OV2P6uZZ5FSM9Ttw')
61 | args = parser.parse_args()
62 |
63 | youtube = get_authenticated_service()
64 | try:
65 | channel_title = add_subscription(youtube, args.channel_id)
66 | except HttpError, e:
67 | print 'An HTTP error %d occurred:\n%s' % (e.resp.status, e.content)
68 | else:
69 | print 'A subscription to \'%s\' was added.' % channel_title
70 |
--------------------------------------------------------------------------------
/python/channel_bulletin.py:
--------------------------------------------------------------------------------
1 | #!/usr/bin/python
2 |
3 | import httplib2
4 | import os
5 | import sys
6 |
7 | from apiclient.discovery import build
8 | from apiclient.errors import HttpError
9 | from oauth2client.client import flow_from_clientsecrets
10 | from oauth2client.file import Storage
11 | from oauth2client.tools import argparser, run_flow
12 |
13 |
14 | # The CLIENT_SECRETS_FILE variable specifies the name of a file that contains
15 | # the OAuth 2.0 information for this application, including its client_id and
16 | # client_secret. You can acquire an OAuth 2.0 client ID and client secret from
17 | # the {{ Google Cloud Console }} at
18 | # {{ https://cloud.google.com/console }}.
19 | # Please ensure that you have enabled the YouTube Data API for your project.
20 | # For more information about using OAuth2 to access the YouTube Data API, see:
21 | # https://developers.google.com/youtube/v3/guides/authentication
22 | # For more information about the client_secrets.json file format, see:
23 | # https://developers.google.com/api-client-library/python/guide/aaa_client_secrets
24 | CLIENT_SECRETS_FILE = "client_secrets.json"
25 |
26 | # This OAuth 2.0 access scope allows for full read/write access to the
27 | # authenticated user's account.
28 | YOUTUBE_READ_WRITE_SCOPE = "https://www.googleapis.com/auth/youtube"
29 | YOUTUBE_API_SERVICE_NAME = "youtube"
30 | YOUTUBE_API_VERSION = "v3"
31 |
32 | # This variable defines a message to display if the CLIENT_SECRETS_FILE is
33 | # missing.
34 | MISSING_CLIENT_SECRETS_MESSAGE = """
35 | WARNING: Please configure OAuth 2.0
36 |
37 | To make this sample run you will need to populate the client_secrets.json file
38 | found at:
39 |
40 | %s
41 |
42 | with information from the {{ Cloud Console }}
43 | {{ https://cloud.google.com/console }}
44 |
45 | For more information about the client_secrets.json file format, please visit:
46 | https://developers.google.com/api-client-library/python/guide/aaa_client_secrets
47 | """ % os.path.abspath(os.path.join(os.path.dirname(__file__),
48 | CLIENT_SECRETS_FILE))
49 |
50 | def get_authenticated_service(args):
51 | flow = flow_from_clientsecrets(CLIENT_SECRETS_FILE,
52 | scope=YOUTUBE_READ_WRITE_SCOPE,
53 | message=MISSING_CLIENT_SECRETS_MESSAGE)
54 |
55 | storage = Storage("%s-oauth2.json" % sys.argv[0])
56 | credentials = storage.get()
57 |
58 | if credentials is None or credentials.invalid:
59 | credentials = run_flow(flow, storage, args)
60 |
61 | return build(YOUTUBE_API_SERVICE_NAME, YOUTUBE_API_VERSION,
62 | http=credentials.authorize(httplib2.Http()))
63 |
64 | # This method calls the API's youtube.activities.insert method to post the
65 | # channel bulletin.
66 | def post_bulletin(youtube, args):
67 | body = dict(
68 | snippet=dict(
69 | description=args.message
70 | )
71 | )
72 |
73 | if args.video_id:
74 | body["contentDetails"] = dict(
75 | bulletin=dict(
76 | resourceId=dict(
77 | kind="youtube#video",
78 | videoId=args.video_id
79 | )
80 | )
81 | )
82 |
83 | if args.playlist_id:
84 | body["contentDetails"] = dict(
85 | bulletin=dict(
86 | resourceId=dict(
87 | kind="youtube#playlist",
88 | playlistId=args.playlist_id
89 | )
90 | )
91 | )
92 |
93 | youtube.activities().insert(
94 | part=",".join(body.keys()),
95 | body=body
96 | ).execute()
97 |
98 | if __name__ == "__main__":
99 | argparser.add_argument("--message", required=True,
100 | help="Text of message to post.")
101 | argparser.add_argument("--video-id",
102 | help="Optional ID of video to post.")
103 | argparser.add_argument("--playlist-id",
104 | help="Optional ID of playlist to post.")
105 | args = argparser.parse_args()
106 |
107 | # You can post a message with or without an accompanying video or playlist.
108 | # However, you can't post a video and a playlist at the same time.
109 | if args.video_id and args.playlist_id:
110 | exit("You cannot post a video and a playlist at the same time.")
111 |
112 | youtube = get_authenticated_service(args)
113 | try:
114 | post_bulletin(youtube, args)
115 | except HttpError, e:
116 | print "An HTTP error %d occurred:\n%s" % (e.resp.status, e.content)
117 | else:
118 | print "The bulletin was posted to your channel."
119 |
--------------------------------------------------------------------------------
/python/geolocation_search.py:
--------------------------------------------------------------------------------
1 | #!/usr/bin/python
2 |
3 | # This sample executes a search request for the specified search term.
4 | # Sample usage:
5 | # python geolocation_search.py --q=surfing --location-"37.42307,-122.08427" --location-radius=50km --max-results=10
6 | # NOTE: To use the sample, you must provide a developer key obtained
7 | # in the Google APIs Console. Search for "REPLACE_ME" in this code
8 | # to find the correct place to provide that key..
9 |
10 | import argparse
11 |
12 | from googleapiclient.discovery import build
13 | from googleapiclient.errors import HttpError
14 |
15 |
16 | # Set DEVELOPER_KEY to the API key value from the APIs & auth > Registered apps
17 | # tab of
18 | # https://cloud.google.com/console
19 | # Please ensure that you have enabled the YouTube Data API for your project.
20 | DEVELOPER_KEY = 'REPLACE_ME'
21 | YOUTUBE_API_SERVICE_NAME = 'youtube'
22 | YOUTUBE_API_VERSION = 'v3'
23 |
24 | def youtube_search(options):
25 | youtube = build(YOUTUBE_API_SERVICE_NAME, YOUTUBE_API_VERSION,
26 | developerKey=DEVELOPER_KEY)
27 |
28 | # Call the search.list method to retrieve results matching the specified
29 | # query term.
30 | search_response = youtube.search().list(
31 | q=options.q,
32 | type='video',
33 | location=options.location,
34 | locationRadius=options.location_radius,
35 | part='id,snippet',
36 | maxResults=options.max_results
37 | ).execute()
38 |
39 | search_videos = []
40 |
41 | # Merge video ids
42 | for search_result in search_response.get('items', []):
43 | search_videos.append(search_result['id']['videoId'])
44 | video_ids = ','.join(search_videos)
45 |
46 | # Call the videos.list method to retrieve location details for each video.
47 | video_response = youtube.videos().list(
48 | id=video_ids,
49 | part='snippet, recordingDetails'
50 | ).execute()
51 |
52 | videos = []
53 |
54 | # Add each result to the list, and then display the list of matching videos.
55 | for video_result in video_response.get('items', []):
56 | videos.append('%s, (%s,%s)' % (video_result['snippet']['title'],
57 | video_result['recordingDetails']['location']['latitude'],
58 | video_result['recordingDetails']['location']['longitude']))
59 |
60 | print 'Videos:\n', '\n'.join(videos), '\n'
61 |
62 |
63 | if __name__ == '__main__':
64 | parser = argparse.ArgumentParser()
65 | parser.add_argument('--q', help='Search term', default='Google')
66 | parser.add_argument('--location', help='Location', default='37.42307,-122.08427')
67 | parser.add_argument('--location-radius', help='Location radius', default='5km')
68 | parser.add_argument('--max-results', help='Max results', default=25)
69 | args = parser.parse_args()
70 |
71 | try:
72 | youtube_search(args)
73 | except HttpError, e:
74 | print 'An HTTP error %d occurred:\n%s' % (e.resp.status, e.content)
75 |
--------------------------------------------------------------------------------
/python/like_video.py:
--------------------------------------------------------------------------------
1 | #!/usr/bin/python
2 |
3 | # This sample shows how to rate a video.
4 | # Sample usage:
5 | # python like_video.py --videoId=OE63BYWdqC4 --rating=like
6 |
7 | import argparse
8 | import os
9 | import re
10 |
11 | import google.oauth2.credentials
12 | import google_auth_oauthlib.flow
13 | from googleapiclient.discovery import build
14 | from googleapiclient.errors import HttpError
15 | from google_auth_oauthlib.flow import InstalledAppFlow
16 |
17 |
18 | # The CLIENT_SECRETS_FILE variable specifies the name of a file that contains
19 | # the OAuth 2.0 information for this application, including its client_id and
20 | # client_secret. You can acquire an OAuth 2.0 client ID and client secret from
21 | # the {{ Google Cloud Console }} at
22 | # {{ https://cloud.google.com/console }}.
23 | # Please ensure that you have enabled the YouTube Data API for your project.
24 | # For more information about using OAuth2 to access the YouTube Data API, see:
25 | # https://developers.google.com/youtube/v3/guides/authentication
26 | # For more information about the client_secrets.json file format, see:
27 | # https://developers.google.com/api-client-library/python/guide/aaa_client_secrets
28 | CLIENT_SECRETS_FILE = 'client_secret.json'
29 |
30 | # This OAuth 2.0 access scope allows for full read/write access to the
31 | # authenticated user's account.
32 | SCOPES = ['https://www.googleapis.com/auth/youtube.force-ssl']
33 | API_SERVICE_NAME = 'youtube'
34 | API_VERSION = 'v3'
35 |
36 | RATINGS = ('like', 'dislike', 'none')
37 |
38 | # Authorize the request and store authorization credentials.
39 | def get_authenticated_service():
40 | flow = InstalledAppFlow.from_client_secrets_file(CLIENT_SECRETS_FILE, SCOPES)
41 | credentials = flow.run_console()
42 | return build(API_SERVICE_NAME, API_VERSION, credentials = credentials)
43 |
44 | # Add the video rating. This code sets the rating to 'like,' but you could
45 | # also support an additional option that supports values of 'like' and
46 | # 'dislike.'
47 | def like_video(youtube, args):
48 | youtube.videos().rate(
49 | id=args.videoId,
50 | rating=args.rating
51 | ).execute()
52 |
53 | if __name__ == '__main__':
54 | parser = argparse.ArgumentParser()
55 | parser.add_argument('--videoId', default='OE63BYWdqC4',
56 | help='ID of video to like.')
57 | parser.add_argument('--rating', default='like',
58 | choices=RATINGS,
59 | help='Indicates whether the rating is "like", "dislike", or "none".')
60 | args = parser.parse_args()
61 |
62 | youtube = get_authenticated_service()
63 | try:
64 | like_video(youtube, args)
65 | except HttpError, e:
66 | print 'An HTTP error %d occurred:\n%s' % (e.resp.status, e.content)
67 | else:
68 | print ('The %s rating has been added for video ID %s.' %
69 | (args.rating, args.videoId))
70 |
--------------------------------------------------------------------------------
/python/list_broadcasts.py:
--------------------------------------------------------------------------------
1 | #!/usr/bin/python
2 |
3 | import argparse
4 | import os
5 | import re
6 |
7 | import google.oauth2.credentials
8 | import google_auth_oauthlib.flow
9 | from googleapiclient.discovery import build
10 | from googleapiclient.errors import HttpError
11 | from google_auth_oauthlib.flow import InstalledAppFlow
12 |
13 |
14 | # The CLIENT_SECRETS_FILE variable specifies the name of a file that contains
15 | # the OAuth 2.0 information for this application, including its client_id and
16 | # client_secret. You can acquire an OAuth 2.0 client ID and client secret from
17 | # the {{ Google Cloud Console }} at
18 | # {{ https://cloud.google.com/console }}.
19 | # Please ensure that you have enabled the YouTube Data API for your project.
20 | # For more information about using OAuth2 to access the YouTube Data API, see:
21 | # https://developers.google.com/youtube/v3/guides/authentication
22 | # For more information about the client_secrets.json file format, see:
23 | # https://developers.google.com/api-client-library/python/guide/aaa_client_secrets
24 | CLIENT_SECRETS_FILE = 'client_secret.json'
25 |
26 | # This OAuth 2.0 access scope allows for read-only access to the authenticated
27 | # user's account, but not other types of account access.
28 | SCOPES = ['https://www.googleapis.com/auth/youtube.readonly']
29 | API_SERVICE_NAME = 'youtube'
30 | API_VERSION = 'v3'
31 |
32 | VALID_BROADCAST_STATUSES = ('all', 'active', 'completed', 'upcoming',)
33 |
34 | # Authorize the request and store authorization credentials.
35 | def get_authenticated_service():
36 | flow = InstalledAppFlow.from_client_secrets_file(CLIENT_SECRETS_FILE, SCOPES)
37 | credentials = flow.run_console()
38 | return build(API_SERVICE_NAME, API_VERSION, credentials = credentials)
39 |
40 | # Retrieve a list of broadcasts with the specified status.
41 | def list_broadcasts(youtube, broadcast_status):
42 | print 'Broadcasts with status "%s":' % broadcast_status
43 |
44 | list_broadcasts_request = youtube.liveBroadcasts().list(
45 | broadcastStatus=broadcast_status,
46 | part='id,snippet',
47 | maxResults=50
48 | )
49 |
50 | while list_broadcasts_request:
51 | list_broadcasts_response = list_broadcasts_request.execute()
52 |
53 | for broadcast in list_broadcasts_response.get('items', []):
54 | print '%s (%s)' % (broadcast['snippet']['title'], broadcast['id'])
55 |
56 | list_broadcasts_request = youtube.liveBroadcasts().list_next(
57 | list_broadcasts_request, list_broadcasts_response)
58 |
59 | if __name__ == '__main__':
60 | parser = argparse.ArgumentParser()
61 | parser.add_argument('--broadcast-status', help='Broadcast status',
62 | choices=VALID_BROADCAST_STATUSES, default=VALID_BROADCAST_STATUSES[0])
63 | args = parser.parse_args()
64 |
65 | youtube = get_authenticated_service()
66 | try:
67 | list_broadcasts(youtube, args.broadcast_status)
68 | except HttpError, e:
69 | print 'An HTTP error %d occurred:\n%s' % (e.resp.status, e.content)
70 |
--------------------------------------------------------------------------------
/python/list_streams.py:
--------------------------------------------------------------------------------
1 | #!/usr/bin/python
2 |
3 | import os
4 | import re
5 |
6 | import google.oauth2.credentials
7 | import google_auth_oauthlib.flow
8 | from googleapiclient.discovery import build
9 | from googleapiclient.errors import HttpError
10 | from google_auth_oauthlib.flow import InstalledAppFlow
11 |
12 |
13 | # The CLIENT_SECRETS_FILE variable specifies the name of a file that contains
14 | # the OAuth 2.0 information for this application, including its client_id and
15 | # client_secret. You can acquire an OAuth 2.0 client ID and client secret from
16 | # the {{ Google Cloud Console }} at
17 | # {{ https://cloud.google.com/console }}.
18 | # Please ensure that you have enabled the YouTube Data API for your project.
19 | # For more information about using OAuth2 to access the YouTube Data API, see:
20 | # https://developers.google.com/youtube/v3/guides/authentication
21 | # For more information about the client_secrets.json file format, see:
22 | # https://developers.google.com/api-client-library/python/guide/aaa_client_secrets
23 | CLIENT_SECRETS_FILE = 'client_secret.json'
24 |
25 | # This OAuth 2.0 access scope allows for read-only access to the authenticated
26 | # user's account, but not other types of account access.
27 | SCOPES = ['https://www.googleapis.com/auth/youtube.readonly']
28 | API_SERVICE_NAME = 'youtube'
29 | API_VERSION = 'v3'
30 |
31 | # Authorize the request and store authorization credentials.
32 | def get_authenticated_service():
33 | flow = InstalledAppFlow.from_client_secrets_file(CLIENT_SECRETS_FILE, SCOPES)
34 | credentials = flow.run_console()
35 | return build(API_SERVICE_NAME, API_VERSION, credentials = credentials)
36 |
37 | # Retrieve a list of the liveStream resources associated with the currently
38 | # authenticated user's channel.
39 | def list_streams(youtube):
40 | print 'Live streams:'
41 |
42 | list_streams_request = youtube.liveStreams().list(
43 | part='id,snippet',
44 | mine=True,
45 | maxResults=50
46 | )
47 |
48 | while list_streams_request:
49 | list_streams_response = list_streams_request.execute()
50 |
51 | for stream in list_streams_response.get('items', []):
52 | print '%s (%s)' % (stream['snippet']['title'], stream['id'])
53 |
54 | list_streams_request = youtube.liveStreams().list_next(
55 | list_streams_request, list_streams_response)
56 |
57 | if __name__ == '__main__':
58 | youtube = get_authenticated_service()
59 | try:
60 | list_streams(youtube)
61 | except HttpError, e:
62 | print 'An HTTP error %d occurred:\n%s' % (e.resp.status, e.content)
63 |
--------------------------------------------------------------------------------
/python/my_uploads.py:
--------------------------------------------------------------------------------
1 | #!/usr/bin/python
2 |
3 | # Retrieve the authenticated user's uploaded videos.
4 | # Sample usage:
5 | # python my_uploads.py
6 |
7 | import argparse
8 | import os
9 | import re
10 |
11 | import google.oauth2.credentials
12 | import google_auth_oauthlib.flow
13 | from googleapiclient.discovery import build
14 | from googleapiclient.errors import HttpError
15 | from google_auth_oauthlib.flow import InstalledAppFlow
16 |
17 |
18 | # The CLIENT_SECRETS_FILE variable specifies the name of a file that contains
19 | # the OAuth 2.0 information for this application, including its client_id and
20 | # client_secret. You can acquire an OAuth 2.0 client ID and client secret from
21 | # the {{ Google Cloud Console }} at
22 | # {{ https://cloud.google.com/console }}.
23 | # Please ensure that you have enabled the YouTube Data API for your project.
24 | # For more information about using OAuth2 to access the YouTube Data API, see:
25 | # https://developers.google.com/youtube/v3/guides/authentication
26 | # For more information about the client_secrets.json file format, see:
27 | # https://developers.google.com/api-client-library/python/guide/aaa_client_secrets
28 | CLIENT_SECRETS_FILE = 'client_secret.json'
29 |
30 | # This OAuth 2.0 access scope allows for read-only access to the authenticated
31 | # user's account, but not other types of account access.
32 | SCOPES = ['https://www.googleapis.com/auth/youtube.readonly']
33 | API_SERVICE_NAME = 'youtube'
34 | API_VERSION = 'v3'
35 |
36 | # Authorize the request and store authorization credentials.
37 | def get_authenticated_service():
38 | flow = InstalledAppFlow.from_client_secrets_file(CLIENT_SECRETS_FILE, SCOPES)
39 | credentials = flow.run_console()
40 | return build(API_SERVICE_NAME, API_VERSION, credentials = credentials)
41 |
42 | def get_my_uploads_list():
43 | # Retrieve the contentDetails part of the channel resource for the
44 | # authenticated user's channel.
45 | channels_response = youtube.channels().list(
46 | mine=True,
47 | part='contentDetails'
48 | ).execute()
49 |
50 | for channel in channels_response['items']:
51 | # From the API response, extract the playlist ID that identifies the list
52 | # of videos uploaded to the authenticated user's channel.
53 | return channel['contentDetails']['relatedPlaylists']['uploads']
54 |
55 | return None
56 |
57 | def list_my_uploaded_videos(uploads_playlist_id):
58 | # Retrieve the list of videos uploaded to the authenticated user's channel.
59 | playlistitems_list_request = youtube.playlistItems().list(
60 | playlistId=uploads_playlist_id,
61 | part='snippet',
62 | maxResults=5
63 | )
64 |
65 | print 'Videos in list %s' % uploads_playlist_id
66 | while playlistitems_list_request:
67 | playlistitems_list_response = playlistitems_list_request.execute()
68 |
69 | # Print information about each video.
70 | for playlist_item in playlistitems_list_response['items']:
71 | title = playlist_item['snippet']['title']
72 | video_id = playlist_item['snippet']['resourceId']['videoId']
73 | print '%s (%s)' % (title, video_id)
74 |
75 | playlistitems_list_request = youtube.playlistItems().list_next(
76 | playlistitems_list_request, playlistitems_list_response)
77 |
78 | if __name__ == '__main__':
79 | youtube = get_authenticated_service()
80 | try:
81 | uploads_playlist_id = get_my_uploads_list()
82 | if uploads_playlist_id:
83 | list_my_uploaded_videos(uploads_playlist_id)
84 | else:
85 | print('There is no uploaded videos playlist for this user.')
86 | except HttpError, e:
87 | print 'An HTTP error %d occurred:\n%s' % (e.resp.status, e.content)
88 |
--------------------------------------------------------------------------------
/python/playlist_updates.py:
--------------------------------------------------------------------------------
1 | #!/usr/bin/python
2 |
3 | # This code sample creates a private playlist in the authorizing user's
4 | # YouTube channel.
5 | # Usage:
6 | # python playlist_updates.py --title=
35 |
36 |
37 |
38 |
39 |
40 |
41 |
48 |
49 |
42 |
47 | Content:
43 |
44 | (None)
45 |
46 |