Programmableweb.com, started and maintained by Jon Musser, is an excellent resource for learning about what APIs are available, the basic parameters for the APIs, and the mashups that use any given API. Some noteworthy sections are as follows:

I highly recommend a close and periodic study of Programmableweb.com for anybody wanting to learn about web APIs and mashups. Let me show some of the things you can learn from the website, based both on what is directly presented on the site and on data that John Musser has sent me. Although web APIs and corresponding mashups are rapidly changing, the data (and derived results), accurate for August 11, 2007, demonstrates some trends that I think will hold for a while yet.

The first thing to know is that of the 494 web APIs in the database, we get the distribution of number of APIs by protocol supported shown in Table 7-2. Note that some APIs are multiply represented.

Some other observations drawn from the database are as follows:

The following are my conclusions based on this data:

It’s therefore useful to know how to use SOAP and XML-­RPC, even if they are not your first choice.

	Note
	A large number of APIs list JavaScript as a protocol. I’ll cover such APIs in the next chapter.

Table 7-3 lists the top 20 APIs on Programmableweb.com by mashup count and also lists the type of protocols supported by the API.

What can you do with this information? To learn about popular APIs, one approach would be to go down the list systematically to figure out how each works. Indeed, through the rest of the book, I’ll cover many of the APIs in the table. The Flickr API is the second most used API in mashups and is a main subject throughout this book. I’ll cover the JavaScript-­based maps (first and foremost Google Maps but also Yahoo! Maps and Virtual Earth) first in Chapter 8 and then in depth in Chapter 13. I’ll cover the Yahoo! Geocoding API extensively also in Chapter 13. I’ll cover various search APIs (Google Search, Yahoo! Search, Yahoo! Image Search, and Windows Live Search) in Chapter 19. Finally, I’ll cover the del.icio.us API in Chapter 14 on social bookmarking. Indeed, the fact that I cover many APIs clustered by subject matter indicates that it is a natural way to think about APIs.

YouTube is probably the most famous video-­sharing site on the Web—and it also uses tagging as one way of organizing content. The YouTube API is documented at http://www.youtube.com/dev.

The YouTube API supports both a REST interface and an XML-­RPC interface. The examples I give in this section use the REST interface. You can find a list of methods at http://?www.youtube.com/dev_docs.

To use the API, you need to set up your own development profile; see http://www.youtube.com/ ?my_profile_dev.

An interesting feature of the registration process is that you enter your own secret (instead of having one set by YouTube). When you submit your profile information, you then get a “developer ID.” The following are some sample calls. To get the user profile for a user (for example, rdhyee), you do an HTTP GET on the following:

http://www.youtube.com/api2_rest?method=youtube.users.get_profile&dev_id={youtube-key}&user=rdhyee
         

YouTube will send you a response something like this:

<?xml version="1.0" encoding="utf-8"?>
<ut_response status="ok">
  <user_profile>
    <first_name>Raymond</first_name>
    <last_name/>
    <about_me/>
    <age>40</age>
    <video_upload_count>2</video_upload_count>
    <video_watch_count>102</video_watch_count>
    [....]
  </user_profile>
</ut_response>
         

To get the list of rdhyee’s favorite videos, use this:

http://www.youtube.com/api2_rest?method=youtube.users.list_favorite_videos&dev_id={youtube-key}&user=rdhyee
         

To get details of a video with an ID of XHnE4umovw4, use this:

http://www.youtube.com/api2_rest?method=youtube.videos.get_details&dev_id={youtube-key}&video_id=XHnE4umovw4
         

To get videos for the tag HolidayWeekend, use this:

http://www.youtube.com/api2_rest?method=youtube.videos.list_by_tag&dev_id={youtube-key}&tag=HolidayWeekend&page=1&per_page=100
         

There’s more to the API, but you can get a feel for how it works through these examples.

	Caution
	Expect the YouTube API to evolve into something more like the rest of Google’s APIs: http://?code.google.com/apis/youtube/overview.html.

The Atom Publishing Protocol (APP), a companion to the Atom Syndication Format (Atom 1.0) described in Chapter 2, represents the next generation of the blogging APIs. APP is currently a draft IETF proposal:

http://tools.ietf.org/wg/atompub/draft-ietf-atompub-protocol/

which is linked from here:

http://tools.ietf.org/wg/atompub/

One of APP’s biggest supporters thus far has been Google, which has implemented GData, which is based on Atom 1.0 and RSS 2.0 feeds, combined with APP. GData, which incorporates Google-­specific extensions, is the foundation of the APIs for many of its services, including Google Base, Blogger, Google Calendar, Google Code Search, and Google Notebook:

http://code.google.com/apis/gdata/index.html

The API for Blogger is documented here:

http://code.google.com/apis/blogger/developers_guide_protocol.html

In the following sections, you’ll learn the basics of the API for Blogger as a way of understanding GData and APP in general.

curl -v -X POST -d "Passwd={passwd}&source=mashupguide.net-Chap7-v1&Email=raymond.yee%40gmail.com&service=blogger" https://www.google.com/accounts/ClientLogin
            

curl -X PUT -v --data-binary "@blogger.message.2.xml" -H "Content-Type:application/atom+xml " -H "Authorization: GoogleLogin  auth=[AUTH-TOKEN]" http://www.blogger.com/feeds/{blogID}/posts/default/{postID}
            

curl -X POST -v --data-binary "@blogger.message.2.xml" -H "X-HTTP-Method-Override:PUT"  -H "Content-Type: application/atom+xml " -H "Authorization: GoogleLogin auth=[AUTH-TOKEN]" http://www.blogger.com/feeds/{blogID}/posts/default/{postID}
            

curl -X DELETE -v -H "Content-Type: application/atom+xml " -H "Authorization: GoogleLogin  auth=[AUTH-TOKEN]" http://www.blogger.com/feeds/{blogID}/posts/default/{postID}
            

Now that you have seen how to use the Blogger API to retrieve feeds of blogs and blog entries, create new blog entries, update an entry, and delete an entry, you should notice how all these actions are performed while hewing closely to HTTP methods as they are actually defined in the HTTP specification. This pattern of using the HTTP methods as the fundamental methods of the API, in fact, repeats itself in all the APIs that are based on the Atom Publishing Protocol and therefore GData. Thus, the uniform interface of GData is the full collection of standard HTTP methods.