YouTube API Blog

A New Format for JSON Results

2010-02-01T11:38:00.000-08:00

It's been two and a half years since we announced JSON as an alternative output format to Atom XML for YouTube API responses. As illustrated in the developer's guide and codelab, JSON-formatted data is a natural choice when writing web applications – after all, who wants to parse XML from JavaScript?

Our existing JSON format isn't perfect, however. It's very much a literal translation from Atom. As is often the case with literal translations, the current JSON format is wordier than it needs to be, and it lacks some of the elegance that a native dialect would offer.

We've rethought out current JSON implementation, and moved away from a literal representation of the Atom data to a format that we hope will be more pleasing to those who are fluent in JSON. The vestigial XML namespace prefixes are no more, and we've removed many pieces of metadata specific to Atom documents that come across as noise in JSON. Repeating data elements are always structured as true JSON lists, and useful video metadata that exist as XML attributes in Atom have been rearranged to make more sense in the JSON document. You'll also find that the new JSON results are more compact than Atom XML, which is of special importance to code running from limited-bandwith mobile applications.

We call this new format JSON-C, and you can read about all the technical details in our documentation and see it in action in our live demo.

With the release of JSON-C, we consider the legacy JSON format officially deprecated. All new development should prefer JSON-C to JSON, and if you have existing YouTube API code that relies on JSON-formatted results, you'll need to upgrade your code to use the new format. We will be supporting legacy JSON-formatted output in accordance with the deprecation policy outlined in our Terms of Service.

Cheers,

-Jeff Posnick, YouTube API Team

YouTube's APIs and Refresher on our Terms of Service

2010-01-14T14:55:00.000-08:00

It's been a busy 2009 and we're excited to be back in 2010 to work on all the cool features we have planned for the YouTube APIs in the coming months.

Opening up our API has led to some really cool and fun commercial applications, far beyond what anyone here at YouTube could ever have imagined. Tens of thousands of developers have created great apps and websites that not only entertain and delight users in creative ways but give our content partners more choice and reach in distributing their videos. For example, we recently announced YouTube Direct, an open-source video uploading platform that is built entirely on top of the YouTube APIs and is available to any commercial website that wants to solicit video submissions from their users.

We thought it would be a good idea to start the year by revisiting a subject that many of you have had questions about since the APIs were born: the API Terms of Service.

Launched back in 2007, the YouTube APIs provide access to some of YouTube's core features (uploading, searching and playing videos, organizing playlists, etc.) for your websites and apps. Before using the API, we ask that you do one thing: carefully read through our Terms of Service (TOS). Here are a few things contained in our TOS that you should be aware of.

Videos belong to their owners - YouTube is a hosting platform. The videos themselves belong to the content owner (anyone from a major studio to a mother recording her son's graduation). In all cases, the content owner decides how and where their YouTube videos are distributed. Sometimes, video owners don't want others to profit from their work, or sometimes they may want to restrict where their videos are shown. While you may disagree with this decision, we need to respect the content owners' wishes.

Standard YouTube video player is key - Consistency in terms of quick video loads and playbacks is a hallmark of the YouTube experience. We therefore ask that you don't enable videos for download, modify a video in any way, or enable playback through means other than other official embeddable players.

Don't serve or strip ads from the video - Serving your own ads against a video without sharing revenue with the content creator, or YouTube, is against the TOS. So is using technology that strips out the ads we're serving on videos. Doing this deprives the uploader from legitimate earnings from his or her work. If you want to learn more about monetizing your YouTube apps, check out our API monetization guide.

It's ok to charge customers to access your application - Creating a subscription, or a one-time access/download fee to use your website or app is fine. But if you do, make it clear that it's you who's charging for access to the video, not YouTube. If you don't make this clear, you're very likely violating the TOS.

Occasionally, we update our TOS to make things even clearer, or to evolve as new features become available on the Web. But rest assured that the core guidelines in our TOS related to advertising, downloading videos, and using an official player have been there since the TOS's inception.

Our hope is that this post can serve as a reference point to clear up any confusions you might have surrounding our TOS. We're always looking to do more to make the API better for our developers and we are eager to hear your ideas and feedback. If you haven't already, do drop by our YouTube APIs Developer Forum and get in touch with us.

Posted by Kuan Yong, YouTube APIs and Tools Team

Enrich your site with YouTube Direct

2009-11-17T07:16:00.000-08:00

Today we announced the launch of YouTube Direct, a new tool built on top of YouTube's public APIs that enables any developer to solicit video submissions on their website, powered by YouTube.

Users upload their videos directly on the developer's website, after which the developer can review the submissions and select the best ones to showcase. Since these videos live on YouTube, users are able to reach YouTube's large user base directly while also getting broader exposure and editorial validation for the videos they create.

Although YouTube Direct was originally created with our news partners in mind, we believe that other developers and website owners can benefit from it as well. To put YouTube Direct in the hands of as many developers as possible, we open sourced the bulk of the code and designed it to run on Google App Engine - Google's scalable hosting platform. This enables developers to easily deploy their own instance of the tool and take advantage of App Engine's scalability and low cost. The videos themselves are served from the same infrastructure that powers YouTube.com.

Visit YouTube Direct for Developers page to read more about it or go directly to the project page to download the code. As always, we'd love to hear your feedback on this new tool. Drop us a line in YouTube's Developer Forum.

New YouTube API Version Available for Testing

2009-11-10T13:31:00.000-08:00

While we don't normally call out new releases of the Google Data YouTube API on this blog, we wanted to draw specific attention to the version that has just been pushed out to our staging servers. There are two specific changes that we'd like to give our developers and partners a chance to test before they go live. Both changes affect important areas of the API: ClientLogin authentication, and playback URLs in media:content entries.

We fully intend for the changes to be backwards compatible, and from the developer's perspective you should not have to change any code. But testing your code is always a best practice, so if you rely on ClientLogin or retrieving media playback URLs from the Google Data YouTube API, please repoint your code to http://stage.gdata.youtube.com and confirm functionality.

Any incompatibilities should be reported as soon as possible in our YouTube API Developer Forum. We expect to move the changes from the staging environment into production on November 17.

Final Decommission Notice for the Legacy YouTube API

2009-11-04T13:03:00.000-08:00

It's been several years since we've released the Google Data-based YouTube API, and in that time we've been encouraging developers who used the legacy YouTube API to upgrade before we pull the metaphoric plug on that older version. At this point, all but a handful of holdouts have upgraded, and as of November 11, 2009, the legacy YouTube API will cease operation.

If you're using one of our YouTube API client libraries, then you're definitely making use of the modern Google Data YouTube API. If you're manually making HTTP requests to a URL whose hostname contains gdata.youtube.com, then you're also good to go. If you think you might still be using the legacy YouTube API but aren't sure, take a look at some of the example legacy API calls in this migration guide. If it turns out that you are still using the older API, then the migration guide will give you the information you need to upgrade – and be sure to do so before November 11!

Cleaning Up Our Embeds

2009-10-30T13:13:00.000-07:00

For the longest time, official YouTube video embed codes have contained embarrassingly malformed URLs; the first URL parameter (at the end of URLs) should always start with a ? character, but our URL parameters begin with &. That looks something like this:

http://www.youtube.com/v/0XjwoVqM_qE&feature=player_embedded&fs=1 (incorrect)

http://www.youtube.com/v/0XjwoVqM_qE?feature=player_embedded&fs=1 (correct)

Fortunately, we've found a way to use correct URLs without breaking old browsers and we can't wait to do it.

Speaking of changes to the embed code, we'll also be tweaking the HTML content. The new YouTube embed code is leaner and still works on everything from ancient desktop browsers to modern smart phones. You won't find another snippet of HTML that's as battle-tested and mother-approved! Here's a preview of the new, streamlined format:

And here's what the HTML looks like:

If you grab YouTube embed codes by hand from YouTube.com, or from the YouTube Player APIs or oEmbed, you'll start getting this updated HTML soon. As for all the embeds already on the web: worry not, those will continue to work forever.

The ActionScript 3 YouTube Chromeless Player is Now Live

2009-10-14T15:31:00.000-07:00

We have some good news for developers who integrate YouTube videos into their ActionScript 3 Flash applications: the official YouTube Chromeless Player API has been updated to natively support ActionScript 3!

Previous to this release, ActionScript 3 developers had to rely on wrapper libraries that bridged the gap between the native ActionScript 2 API and their own ActionScript 3 code. We're thrilled that intrepid developers were able to patch things together on their own and share their code with the rest of the community. Now that there's official support for using the chromeless player from ActionScript 3, everyone should have more time to focus on writing compelling Flash applications, rather than dealing with the unique issues that cross-language coding entails.

Please check out our ActionScript 3 documentation, and let us know what you think of the new API in our developer forum.

With the launch of ActionScript 3 support, we're officially deprecating the ActionScript 2 YouTube Chromeless Player API. As per our YouTube API deprecation policy, detailed in our Terms of Service, we will continue to operate the ActionScript 2 API for a period of three years (until October 14, 2012).

Cheers,

-The YouTube API Team

Direct Uploads Server Migration

2009-10-12T11:20:00.000-07:00

We first announced our new API upload infrastructure back in June and asked developers to test their YouTube API code against our staging environment.

Since then, we've started deploying the new upload infrastructure to production machines in a phased manner. Last month, we transitioned browser-based API uploads to the new servers, and have been closely monitoring performance and error rates to ensure that there were no unintended side effects.

We're now ready to begin the transition for direct uploads. Starting today, a small percentage of direct uploads traffic will automatically be routed to our new servers. We will be monitoring traffic over the next few weeks and gradually increasing the traffic that the new servers receive until we have fully completed the migration.

As a developer, you won't have to make any changes in your code to take advantage of the increased reliability and bug fixes found in the new infrastructure. While we do expect that this new infrastructure will be fully backwards compatible, if you do notice any change in your application's behavior with regard to direct uploads, please let us know in our developer group.

Cheers,

-The YouTube API Team

oEmbed support

2009-10-09T08:54:00.000-07:00

oEmbed is a pretty slick way to embed multimedia for a link. For example with a request like this:

http://www.youtube.com/oembed?url=http%3A//www.youtube.com/watch%3Fv%3DbDOYN-6gdRE&format=json

You get a response like this:

{"provider_url": "http://www.youtube.com/",
"title": "Auto-Tune the News #8: dragons. geese. Michael Vick. (ft. T-Pain)",
"html": "embed code",
...}

The value for the "html" key is all you need to insert into your webpage to render an embedded YouTube video:

Check out the documentation at oEmbed.com for more information.

New Reporting Dashboard for Developers

2009-09-16T13:30:00.000-07:00

Getting your YouTube web or client application up and running is only half the battle. We know that you'll also want to monitor your application to see how it's performing. Our new Developer Dashboard shows you at a glance the number of API requests, playbacks, uploads and errors that your app is generating. You can visualize the data using our interactive chart or download a file to process the data offline. To use the dashboard, you'll need to provide a developer key in your API requests and then pass the media URLs from the API responses to the standard embedded player or the chromeless player.

You can log into the new Developer Dashboard at http://code.google.com/apis/youtube/dashboard/

Posted by Kuan Yong, YouTube APIs and Tools Team

Caption your videos with the YouTube API

2009-08-14T11:30:00.000-07:00

In August last year, we launched the ability to add captions to your videos on YouTube. Now, you can do the same using the YouTube Data API.

With the new captions API, developers can create third-party apps that help users create, upload and manage the caption tracks of their YouTube videos. Each video can have multiple caption tracks, and multiple subtitle formats are supported.

Find out more in our Developer's Guide.

Posted by Christoph Schwab-Ganser, YouTube Engineering

New Video Portal For Film Buffs, Powered by YouTube

2009-07-23T16:00:00.000-07:00

Attention film buffs!

The American Film Institute (AFI) just launched a new video portal on AFI.com featuring hundreds of videos from its vast archives. AFI is utilizing YouTube's APIs in order to stream videos directly from AFI's YouTube channel, as well as other great clips curated from YouTube. In addition to accessing the video content, users can post comments on the AFI.com video site as well as embed the videos on other sites, blogs and social networking pages.

The collection will be regularly augmented with videos selected from the AFI Archive, which contains 10,000 hours of material produced during AFI's 42-year history, much of which has never been seen by the general public. Be sure not to miss great clips such as "Alfred Hitchcock On Mastering Cinematic Tension" or "Steven Spielberg: The Toughest Thing For A Director".

We're thrilled that the YouTube APIs can help unlock such amazing material. Nice work, AFI!

Posted by George Strompolos, YouTube Partner Team

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!