YouTube API Blog

Simple Update Protocol for User Activity Feed docs are now available

2009-06-18T11:00:00.000-07:00

At Google I/O 2009, we demoed a nifty sample application that tracks updates to any number of YouTube user activity feeds. The technology behind the application is the Simple Update Protocol (SUP), a simple and compact "ping feed" that enables your application to efficiently monitor changes to a large number of user activity feeds.

If you run a social network with tons of users who also happen to be active on YouTube, you should consider using SUP to let your users easily share their updates on YouTube with their friends through their social graph on your site. See the docs here.

Posted by Kuan Yong, YouTube APIs and Tools Team

Public Service Announcement - Upload Regression Testing

2009-06-09T16:03:00.001-07:00

The team has been working to improve the API upload infrastructure behind the scenes, and the new build is up at:

http://uploads2.gdata.youtube.com

Please do regression testing on your systems and report problems in our discussion forum.

Barring any major complications, this will begin rolling out to the production uploads URL (uploads.gdata.youtube.com) in two weeks.

Posted by Stephanie Liu, YouTube APIs and Tools Team

Google I/O Pass Winner!

2009-05-26T23:26:00.000-07:00

Wow, there's quite a bit of creative talent out there! It was hard to select from all the posts, but the winning haiku was from lionstone:

public void youtube
extends the community
return social change

Honorable mention goes to Ron (who already bought a ticket to the conference!):

Documentation -
cut, five, seven, five, season
form situation

We'll be seeing both of them at Google I/O tomorrow -- if you're coming as well, come say 'hi' to the team at Office Hours, at the Sandbox, and in our two sessions. If you can't make it, watch the Twitter stream during the conference and the videos that will be posted afterwards.

Posted by Stephanie Liu, YouTube APIs and Tools Team

Google I/O Pass

2009-05-18T17:50:00.000-07:00

Google I/O, our largest developer conference in San Francisco, CA, is just around the corner, and we'd love to see more YouTube developers there. We'll have two formal sessions, as well as office hours and lots of demos at the Developer Sandbox.

Kuan, our Product Manager, will be giving a session about writing great, monetizable apps, and Jeff Fisher and Jochen Hartmann will be giving a session on the new social feeds.

Check out the rest of the great sessions and the schedule.

We have one free pass ($400 value) to give away, so if you'll be in the area, tell us why you want to go in this forum thread. We'll pick the worthiest person by the end of the week (hint: Jeff really likes Haikus :).

Posted by Stephanie Liu, YouTube APIs and Tools Team

YouTube APIs: Search Explained

2009-05-05T16:05:00.000-07:00

In an alternate universe (where I have a goatee) I may be a voice actor instead of a Googler. However, since we live in this universe, the best I can do is make you a screencast about the YouTube API. Specifically, this video discusses the various search options we have in our Data API and the various limitations and caveats to keep in mind while integrating it into your program or website.

If our API documentation is like the printed manual in the box of a new purchase that you never read, think of this video as the one-page laminated card with pretty pictures on it telling you not to get crushed by a bookshelf or hurt your back. Enjoy!

Modifying Chow-Down Part 2: Make it Faster!

2009-04-21T11:11:00.000-07:00

As promised in the previous blog post, I was given the task of making our Chow Down Gdata sample a little faster. It would sometimes take a while to load restaurant information due to the requests to YouTube and Picasa Web Albums taking a while to be processed on the backend. Since this would cause the user to sometimes see a "loading" bar for several seconds; something had to be done.

Originally, the application used the Python client library to retrieve information from YouTube and PWA and then stored it inside of memcache. The new solution is to instead retrieves these feeds directly in the browser using the json-in-script support of the Google Data APIs. This approach worked well for the Chow Down application since we were not retrieving any private information for use in this application and so did not need to authenticate as a user.

Another benefit of using the JSON feeds is that the browser can asynchronously request results from both YouTube and PWA at the same time and render the results as soon as they are returned. This helps decrease the "perceived load time" that the user experiences since they are seeing information start to be loaded instead of just watching a progress bar.

The code for the entire sample is available on code.google.com:

http://code.google.com/p/gdata-samples/source/browse/trunk/chow-down-gdata/

But you can see all of the logic for retrieving the feeds using JavaScript in the ajax_restaurant_info template:

http://code.google.com/p/gdata-samples/source/browse/trunk/chow-down-gdata/src/templates/ajax_restaurant_info.html

The code makes use of the jQuery JavaScript library in order to remain compact and compatible.

So if your site is using the Data APIs of one or more Google properties and you don't need authentication, considering switching to the JSON feeds to improve perceived latency and let your pages load the AJAXy way.

Modifying the Chow-Down Application, part 1: Adding media from YouTube and Picasa

2009-04-16T16:09:00.000-07:00

Recently I was given the task of modifying the Chow Down sample application (originally written to demonstrate how to implement the Google FriendConnect API on Google AppEngine) to include videos, pictures and search results in the restaurant detail pages. This task resulted in the creation of Chow Down Gdata (full source code) which uses the YouTube Data API, the Picasa Web Albums API and the AJAX Search APIs.

Since everything was written in Python, using our Python client library was a no brainer. The first step was to add the necessary files and import statements. The application follows a standard MVC layout, so the next step was to create a new view called JsonRestaurantInfoView in views.py, which I then connected both to the ajax_restaurant_info.htmltemplate and also to the restaurants_info method in providers/restaurants.py.

The bulk of the modifications happen inside restaurants_info:


# Create client and query to execute a YouTube search:
gdata_youtube_client = gdata.youtube.service.YouTubeService();
query = gdata.youtube.service.YouTubeVideoQuery()
query.vq = "%s %s" % (restaurant.name, restaurant.city)
video_feed = gdata_youtube_client.YouTubeQuery(query)

# Grab the URL to the embeddable Flash player SWF (if embeddable)
swf_url = video_entry.GetSwfUrl()

if swf_url:
 restaurant.player = """<object width="425" height="350">
        <param name="movie" value="%s"></param>
        <embed src="%s" type="application/x-shockwave-flash"
         width="425" height="350"></embed></object>""" %
         (swf_url, swf_url)

But wait! We are not done yet. Let's also look for pictures for this restaurant in Picasa:

gdata_picasawebalbums_client = gdata.photos.service.PhotosService()
query_parameters = map(urllib.quote, [restaurant.name, restaurant.city]);

# Fetch a feed of 10 thumbnails, 32x32 pixels in size and cropped to a square
photo_feed = gdata_picasawebalbums_client.GetFeed(
 "/data/feed/api/all?q=%s%%20%s&max-results=10&thumbsize=32c" %
 (query_parameters[0], query_parameters[1]))

We store all the new metadata in the restaurant object that ends up being passed to the template. To direct users there from the search page, I added a simple show_restaurant_info function which is triggered when a user clicks on the restaurant title in the search listing. While I was in the templates/index.html file, I also added the ajax_api_restaurant_info function which fetches blog, web, news and book search information about the restaurant.

Check out the full source code to get the full picture including information about how this data was also cached.

In the next article, Jeff Fisher is going to talk about how to optimize the performance for this application by using JavaScript.

Latest Release Notes: Playlist Search, Time, and More

2009-04-07T10:51:00.000-07:00

Enjoy a few new tidbits in the latest release.

Search for playlists

Yup, the same way you can search for videos and channels , you can now use the API to search for playlists:

http://gdata.youtube.com/feeds/api/playlists/snippets?q=soccer&v=2

The query above will return a list of playlist snippets that match the query 'soccer'. Searching in playlists is an excellent way to find YouTube videos about a specific point of interest (e.g. dancing, cooking, sports etc.).

Time filtering for video search

You can now restrict the video search result to a specific time interval (today, this_week, this_month, all_time):

http://gdata.youtube.com/feeds/api/videos?q=soccer&time=today&v=2

The default is 'all_time'.

More results

You can now request past the 100th video in a playlist and past the 200th video in a favorite list. Additionally, you can now get 1000 videos in a search feed instead of 999! Enjoy that last video, guys.

As always, post in the forum if you have any feedback or questions!

Posted by Daniel Danciu, Software Engineer

Recent activity: apitestjhartmann has written a tutorial

2009-03-17T11:29:00.000-07:00

As you may have heard, YouTube has been getting more social lately. Our activity feeds help your users stay up-to-date on the cool channels and videos that their friends (or anyone else, for that matter) have been uploading, subscribing to, adding as favorites and so forth.

But we don't just care about YouTube users. We also care about developers. And we want you to have time to be more social, too.

With that in mind, Jeff Fisher and I wrote a hands-on tutorial that explains how to build the YouTubeActivityViewer, a PHP application that uses the new activity feeds. The application uses our PHP client library with jQuery. If you're still not ready to rush out and socialize, you can also build in a caching system with memcache.

Latest .NET SDK Released! LINQ & New Social Notifier Sample

2009-03-05T11:58:00.000-08:00

Posted by Frank Mantek, Google Data APIs Team

The new .NET SDK is released and available for download here:

http://code.google.com/p/google-gdata/downloads/list

There's now updated support for YouTube V2 and a new vertical object model that allows you to use local LINQ queries. Please go through the Google.YouTube namespaces and see what's new there. We have some documentation for it here:

http://google-gdata.googlecode.com/svn/trunk/clients/cs/docs/AdditionalContent/YouTubeLinqExamples.html

Last, but not least, there is the Notifier for YouTube sample application, which showcases the activity feeds YouTube is exposing. You can subscribe to events from your friends and other YouTube users and get notified whenever they leave their marks in the YouTube universe. The sample is also available as a separate download.

The complete release notes can be found here:

http://google-gdata.googlecode.com/svn/docs/RELEASE_NOTES.HTML

which also lists all the bugs that were fixed in this release. Report new ones here:

http://code.google.com/p/google-gdata/issues/list

PHP Client Library: Uploading videos now 99% more efficient !

2009-03-02T13:58:00.000-08:00

Posted by Jochen Hartmann, YouTube APIs and Tools Team

If you are using the PHP Client Library to upload your videos to YouTube.com you may have had to deal with memory issues, such as the common Fatal error: Allowed memory size of ... bytes exhausted error message.

I am happy to announce that as of version 1.7.6 of the client library, this should no longer be a problem. Jeff Fisher and I have added support for streaming large video files to our API in manageable 1 MB chunks. The change is completely transparent, so you won't need to do anything besides upgrade your copy of the client library.

Prior to this change, our client library used to rely solely on the Zend_Http_Client object to handle HTTP communication between servers. The client makes requests by reading the entire body of your HTTP POST message into a string, which then gets sent to our API server. This behavior is perfectly acceptable for normal use since most of the time we are just sending XML strings or small media files such as images, but doesn't work quite so well for uploading 1 GB video files.

To address this problem, I designed a Zend_Gdata_MediaMimeStream object which only stores a handle to the video file being uploaded. Jeff built a Zend_Gdata_HttpAdapterStreamingSocket which then reads from the media stream in 1 MB chunks and sends to the socket until the entire message is read. We have tested this code extensively and are always open to feedback on how to improve performance issues in our client library, so check out the source code if you are interested.

While I have your attention, let me also share another trick for those obsessed with efficiency: If you are only interested in working with the raw XML instead of the complete Zend_Gdata object model, you can flip a minor switch that is available in all of our service classes (Zend_Gdata_YouTube, Zend_Gdata_Docs, etc.):

$yt = new Zend_Gdata_YouTube(); $yt->useObjectMapping(false); $xmlString = $yt->getRecentlyFeaturedVideoFeed(); echo gettype($xmlString); # will return 'string'

As you can see in the snippet above, the $xmlString variable is now just a regular string instead of a Zend_Gdata_VideoFeed object. My testing shows that this can make fetching video feeds from YouTube faster by up to 35 times. Of course you would need to add a little bit of time parsing the XML with the tool of your choice (XPath, etc.). I should also add that those interested in parsing XML without the aid of the client library may want to check out the Backward Compatibility Guidelines for the YouTube Data API.

YouTube API Outgrows Shy Adolescence, Now Social

2009-02-24T16:00:00.000-08:00

Posted by Stephanie Liu, YouTube APIs and Tools Team

YouTube has been getting more social lately, using activity feeds to make it easier to find cool videos and channels that your YouTube friends are favoriting, rating, subscribing to, etc. But what if all your friends aren't on YouTube, but rather on social network / site XYZ?

Well, my friends, the API has come out of its awkward teenage years, and now has more sophisticated social skills to help. Activities like favoriting, uploading, commenting, and more can now be integrated into the social context of your choice. Check out the docs for the new user activity feed and friend activity feed.

Before you ask, the user activity feed is fully customizable by the user, and the corresponding feed through the API respects all privacy settings. So users still have full control over what they make available in their recent activity feed.

We think some cool apps can be made with these feeds -- like the obvious social network / feed aggregator integrations, to notification apps, to novel data views. We can't wait to see what you guys make!

Get started by perusing the docs and playing with the sample. Besides the protocol guide, we've also updated the Java and PHP guides with helpful snippets. An activity viewer sample written in PHP and its source code is also available for you to play with.

As always, let us know if you have any questions or feedback in the forum.

PS. If you want to socialize with the team in person, come to Google I/O, where we'll be giving a session on "Going social with the YouTube APIs"!

TubeLoc: An AS3 Player Wrapper Using LocalConnection

2009-02-11T16:34:00.000-08:00

Posted by Jeff Fisher, YouTube APIs and Tools Team

We know developers really like AS3, but sometimes they have difficulty getting our players to work correctly. To make this process easier for the Flashy/Flexy crowd, the awesome Ben Longoria has given us TubeLoc.

TubeLoc is an AS3 wrapper around the Player API that uses LocalConnection to communicate to the AS2 YouTube SWFs. It takes this a step further by also providing Flex components to make inserting a YouTube video and controls easy.

Ready to get started? First read the article that goes in depth on how to use TubeLoc. Next, visit the project page to download the code and play with the live demos. Finally, tell us what you think on the forum. Thanks Ben!

YouTube APIs + iPhone = Cool mobile apps

2009-02-05T15:00:00.000-08:00

Posted by Kuan Yong, YouTube APIs and Tools Team

The YouTube APIs Terms of Service permits commercial use of the APIs under certain conditions, and in most cases, as long as you play fair, you are free (and highly encouraged) to develop great iPhone apps using the YouTube APIs and sell them in the iTunes App Store.

An iPhone app that uses the YouTube APIs typically needs to do two things:

Call the YouTube API Data API to search videos, get video metadata, etc. You should use our Objective C client library instead of trying to construct the HTTP request or parse the response by hand.
Invoke the native YouTube player on the iPhone to play videos.

There are at least two ways to play YouTube videos in your iPhone app (that don't run afoul of Apple's SDK rules). The easier way requires just one line of code but it involves quitting your app and launching the full YouTube app on the phone. The better way needs a little more setup but provides a seamless way of taking the user to the YouTube player and back to your app. Note that these two methods work only on an actual device, not in the iPhone simulator, since the latter does not have a YouTube player.

Method 1: Open the YouTube play page URL (Easier)

1. Grab the video url from the media tag in the API response with the application/x-shockwave-flash type. It should look something like this:

http://www.youtube.com/v/oHg5SJYRHA0&f=gdata_videos&c=ytapi-my-clientID&d=nGF83uyVrg8eD4rfEkk22mDOl3qUImVMV6ramM

If you don't see the c and d parameters in the URL, it's because you are not passing in your developer key and client ID in the request. While they are not mandatory for read requests, we highly recommend that you provide them in every API request.

2. Open the URL in your app by calling the openURL method on your UIApplication instance:

[[UIApplication sharedApplication] openURL:[NSURL URLWithString:@"http://www.youtube.com/v/oHg5SJYRHA0&f=gdata_videos&c=ytapi-my-clientID&d=nGF83uyVrg8eD4rfEkk22mDOl3qUImVMV6ramM"]];

When your app calls openURL, it will quit and launch the full native YouTube app on the phone. After the video stops playing, the user remains in the YouTube app. The user has no easy way of getting back to your app.

Method 2: Embed the YouTube player in a UIWebView

No, the iPhone still doesn't do Flash, but if you haven't already noticed, the Safari browser on the iPhone is clever enough to turn any YouTube embed into a clickable thumbnail that launches the native YouTube player app on the phone. You can take advantage of this feature in your app by using a UIWebView. Here's how:

1. Set up a UIWebView in your app. You can make it part of a xib or create it programmatically. Size the UIWebView according to how large you want the clickable thumbnail to be.

2. Grab the video url using the same method as the one described above.

3. Call the loadHTMLString:baseURL: method on the UIWebView instance with some carefully constructed HTML that contains the YouTube embedded player code snippet and some supporting HTML to make sure that the video thumbnail appears correctly. Set the base URL to the URL of your website (it doesn't do anything here -- ordinarily UIWebView uses it to handle relative URL links correctly).

The best way to illustrate this is with a code snippet. Note the use of the viewport HTML meta parameter and the consistent use of width and height parameters throughout.

// webView is a UIWebView, either initialized programmatically or loaded as part of a xib.

NSString *htmlString = @"<html><head>
<meta name = \"viewport\" content = \"initial-scale = 1.0, user-scalable = no, width = 212\"/></head>
<body style=\"background:#F00;margin-top:0px;margin-left:0px\">
<div><object width=\"212\" height=\"172\">
<param name=\"movie\" value=\"http://www.youtube.com/v/oHg5SJYRHA0&f=gdata_videos&c=ytapi-my-clientID&d=nGF83uyVrg8eD4rfEkk22mDOl3qUImVMV6ramM\"></param>
<param name=\"wmode\" value=\"transparent\"></param>
<embed src=\"http://www.youtube.com/v/oHg5SJYRHA0&f=gdata_videos&c=ytapi-my-clientID&d=nGF83uyVrg8eD4rfEkk22mDOl3qUImVMV6ramM\"
type=\"application/x-shockwave-flash\" wmode=\"transparent\" width=\"212\" height=\"172\"></embed>
</object></div></body></html>";

[webView loadHTMLString:htmlString baseURL:[NSURL URLWithString:@"http://www.your-url.com"]];

One of the biggest benefits of this approach is that your app does not have to quit in order for the video to start playing. In fact, the iPhone will keep your app running in the background while it fires up the YouTube player to play the video. After the video finishes playing (or when the user hits "Done"), the user is automatically taken back to your app. This experience is very similar to watching embedded YouTube videos in the iPhone Safari browser and is just as seamless.

Have fun writing the next killer iPhone app, and don't forget to list your app in the YouTube Project Gallery once it goes live in the App Store!

Coming up: Adding YouTube content to Android apps

Show Me the Money

2009-02-04T18:00:00.000-08:00

Posted by Kuan Yong, YouTube APIs Product Manager

Money: it's on everyone's mind lately, and we know developers are no different. We understand that developers aren't just satisfied with creating the coolest YouTube mashup out there. They also want a way to sustain their efforts financially, and the trick is figuring out how to do so appropriately. That's why we've published a document that provides clear guidance on how you can monetize the apps you've built with the YouTube APIs. While it is not a substitute for reading our Terms of Service, it should point you to the clauses you should pay attention to and hopefully even give you some ideas for your next YouTube API-powered project.

So go ahead, launch the next great YouTube mashup, and monetize the hell out of it. And don't forget to tell us about your app at the YouTube Project Gallery.

Next IRC Office Hours: Wednesday, Feb. 4th, 1:00 - 3:00pm PST

2009-01-29T14:55:00.000-08:00

Posted by Stephanie Liu, YouTube APIs and Tools Team

Last week, we had a grand ol' time troubleshooting some issues, chatting about the player, making some new friends, and salivating over a Dark Chocolate Bacon Cupcakes recipe. So, we'll be holding office hours again next week, same bat time, same bat channel.

Where: irc.freenode.net#youtube-api
When: Wednesday, February 4th, 1:00 - 3:00 pm PST
Who: Look for xirzec, stephliu, and jh_youtube

Let us know if you'd prefer a different time for future office hours, or just post your questions in our discussion forum.

Inaugural IRC Office Hours: Wed, Jan. 21st, 1-3pm PST

2009-01-14T10:11:00.000-08:00

Posted by Stephanie Liu, YouTube APIs and Tools Team

Starting next week, we'll be hosting live office hours on IRC (irc.freenode.net channel #youtube-api). Come ask your questions, give feedback, gossip about the latest Atom Pub news, share best practices, or just hang out.

Where: irc.freenode.net#youtube-api
When: Wednesday, January 21st, 1:00 - 3:00 pm PST
Who: Look for xirzec, stephliu, and jh_youtube, we'll be the cool kids in the back :)

If you can't make it, no worries, you can still post, as always, in the discussion forum. You can also let us know what times would work better for you in the future. See you there!

UPDATE: Small change. We'll be hosting hours 1-3 PST, not PDT :) Also, for those of you who don't have IRC clients installed, you may want to use a web-based client like mibbit.com. Choose "Freenode" as the server, pick a nickname, and use #youtube-api as the channel.

Flex + the Embedded Player: A Christmas Story

2009-01-07T10:48:00.000-08:00

Posted by Pamela Fox, Maps API Team

Hey YouTube folks! My name is Pamela Fox, and I hail from the Maps API world. I was charged with the task this year of creating the map for the NORAD Santa Tracker (yes, Google even indexes Santa), and I decided to convert last year's JavaScript map into a Flex map. This meant converting every feature into Flex, including arguably the most important feature: displaying YouTube-hosted Santa Cam videos in the infowindows. The kiddies get a kick out of seeing Santa soaring, tumbling, and freewheeling through the endless diamond sky.

I wanted what I thought was a basic feature: using the embedded player to play 23 different YouTube videos in the same Flex app. I started with a straightforward implementation - using the SWFLoader Flex component with the source set to the URL of the YouTube video. But I noticed some funny behavior - the first video would load, but none after that. After some searching around, I discovered the reason for this: if the first loaded YouTube SWF isn't properly removed by calling its destroy method(), any subsequently loaded YouTube SWF won't play correctly. The solution is to call destroy() on the YouTube SWF - but wait a second, it's not that easy. Flex/AS3 SWFs cannot call methods on AS2 SWFs, and YouTube SWFs are indeed written in AS2.

After harassing various YouTube engineers and reading through the AS3 Chromeless Player wrapper code, I came up with the solution shown in the diagram below.

The Flex app uses SWFLoader to load in an AS2 SWF, which I call the "YouTube bridge". The YouTube bridge creates a LocalConnection, which is a way for any SWF to invoke methods on any other SWF that's open simultaneously on a computer. The bridge specifies what connection it can receive commands from, and then defines two functions that other SWFs can call - loadMovie() and dispose(). The loadMovie() function takes in a YouTube ID, creates a MovieClip and loads the YouTube movie into it. The dispose() function calls destroy() on that MovieClip, and then does various other cleanup operations. The Flex app then tells that same connection what method names it wants to invoke, either "loadMovie" or "dispose". Some snippets of the LocalConnection code are shown below:


// Flex
outBox = new LocalConnection(); 
outBox.send(outBoxName, "dispose");
outBox.send(outBoxName, "loadMovie", ids[counter]);

// AS2
var inbox = new LocalConnection();
inbox.connect(_root.boxName);
inbox.dispose = function () {
  youtubeMC.destroy();
  ...
};

When I first coded this, I hard-coded a name for the connection name in the Flex + AS2. This meant that my app couldn't be used in multiple browsers at the same time, since all instances of the app would be sending and receiving messages from the same inbox, and they'd get awfully confused. To remedy that, I generate a random ID in the Flex app, pass that into the query string when loading the YouTube bridge, and then have the bridge use the value of the query parameter as the inbox name. A snippet of that code is shown below:


// Flex
outBoxName = String(new Date().getUTCMilliseconds()); 
swfLoader.load("youtubebridge.swf?boxName=" + outBoxName);

// AS2
inbox.connect(_root.boxName);

The full code (MXML + FLA) is available, and you can test out the demo app. Now that I've made it easy for you all, I hope to see some nifty YouTube/Flex mashups.. and maybe even some Youtube/Flex/Maps mashups!

YouTube Developer Happiness Survey

2008-12-17T13:53:00.005-08:00

Posted by Stephanie Liu, YouTube APIs and Tools Team

It's that time again -- survey time. If you're a YouTube API
developer, we'd love to know how it's going and what we can do better. Take a few minutes and fill out our survey.

We always welcome feedback in the discussion forum of course, but this is a good way for the team to look at some aggregate data and determine where to put resources next year.

YouTube Google Desktop Gadget

2008-12-09T11:00:00.000-08:00

Posted by James Yum, Google Desktop Team

Google Desktop just got its own Desktop gadget for YouTube. It relies on Data API feeds to search YouTube and retrieve a feed of the day's most popular videos. It's also open source, so browse the source code to learn how to build a desktop app that uses the YouTube APIs. If have any questions or feedback, send an email to gd-developer AT gmail DOT com.

YouTube Integration in Games

2008-12-01T18:39:00.000-08:00

Guest Post by Claus Höfele, Software Developer at Team Bondi

We have a guest blog post today by Claus Höfele, an Engine Programmer at Team Bondi, an independent game developer based Down Under. He has a detailed article featured in Gamasutra.com about how to integrate YouTube upload into a game, much like how it's integrated in Spore. In addition to working with game consoles, Claus has a long history in developing software for mobile devices and is the author of Mobile 3D Graphics: Learning 3D Graphics with the Java Micro Edition.

For some time now, I've been interested in how social networks can be incorporated into games. With the rise of multiplayer games, I believe this will be the next big thing for network-enabled games. Watching videos on YouTube is a favourite pastime of mine, so it didn't take long for me to decide that I wanted to check out the steps necessary to add a video recording feature to my games and share the recordings on YouTube.

Games are often written in C/C++, which allows a programmer to structure the code in a modular way, but also to program to the bare metal when needed. Although YouTube announced a partnership with Sony in which it offered its APIs on the PLAYSTATION 3, there's no publicly available C/C++ API to access YouTube. Fortunately, with the help of the developer documentation, YouTube's HTTP based protocol is straightforward to implement yourself. I used libcurl (HTTP processing), OpenSSL (HTTPS), and TinyXML (XML parsing) to help me with this task.

Wrapping my head around the available authentication options was probably the most difficult task. In the end, ClientLogin was the method of choice because my game demo is distributed as a standalone desktop application.

I was glad to see support for videos encoded in the Theora format on YouTube. Because Theora is a free and open video compression format, it avoids the licensing issues usually involved with video codecs.

I expect more games to follow in the footsteps of Spore's Creature Creator, PixelJunk Eden, and Mainichi Issho, which already include YouTube support. The code that comes with my article on Gamasutra.com [http://www.gamasutra.com/view/feature/3855/share_your_experience_youtube_.php] should provide an excellent start if you want to access YouTube from a game or application written in C/C++.

Application Gallery Launched - Submit Your Own!

2008-11-24T14:30:00.001-08:00

Posted by Jeff Fisher, YouTube APIs and Tools Team

We launched a new Application Gallery to feature projects that integrate with YouTube. This supersedes our previous forum wiki page and now also allows you to rate and comment on your favorite applications.

The new gallery is self-service so submit your application for inclusion today! Don't worry if your listing does not show up right away. We need a few days to review your app before including it in the gallery. If your app is rejected, please be sure to review our API Terms of Service again. Keep it classy, guys.

If you haven't written a YouTube app yet, this will be a great place to peruse examples and get inspiration.

Try Before You Buy

2008-11-17T10:12:00.000-08:00

Posted by Stephanie Liu, YouTube APIs and Tools Team

We launched a great tool to help you play around with the Data API and wrap your head around all the basic API operations before diving into code.

Check it out:
http://gdata.youtube.com/demo/index.html

Build query strings, experiment with the different feeds, and even make authenticated queries using AuthSub. This is also a great way to help debug problems with the API and compare responses against what you are seeing in your code.

Let us know if you have any feedback in the forum.

A Mandate for Change

2008-11-13T15:18:00.000-08:00

Posted by Andy Diamondstein, YouTube APIs and Tools Team

In the past few months, thousands of you posted questions in our API forum, many for the very first time in your lives, because you believed that your voice could make a difference. You know that the YouTube API can change, and you've asked if we can change it by adding new features and fixing bugs. Yes we can.

What we have already achieved gives us hope for what we can and must achieve tomorrow. But there is so much more to do. And we want to be sure that we don't break your applications when we do it. And that's why we've released new backward compatibility guidelines to help ensure that your applications handle API changes gracefully.

All The World's A Stage

2008-11-12T14:18:00.000-08:00

Posted by Jeff Fisher, YouTube APIs and Tools Team

I know as a developer it is frustrating when your code that was previously working suddenly breaks because of someone else's changes. In order to help catch new API bugs before they show up in our production API, we have added a new staged version of our API running on stage.gdata.youtube.com.

To use the staged instance, simply retrieve a feed from the different hostname. For example, instead of retrieving

http://gdata.youtube.com/feeds/api/videos

you would retrieve

http://stage.gdata.youtube.com/feeds/api/videos

For uploads you can use:

http://uploads.stage.gdata.youtube.com/

This staged instance is not supported and will not have the reliability of the live API, so please do not use it in any live site. It is only to be used for testing your application against upcoming versions of the API to ensure that nothing is broken.

Go ahead and test your applications right now for the upcoming November release. In the future, we will pre-announce new versions of the API on stage once they are available on our announcement-only forum:

http://groups.google.com/group/youtube-api