Blogger Developers Network

Customising Threaded Comments

2012-01-21T17:40:00.000-08:00

Recently we released an update to Blogger’s commenting system that enables people to directly respond to comments. This capability is known as Threaded Comments. We are pleased to see quite a few people diving in and writing tutorials, including a screencast. It’s wonderful to see the enthusiasm of our developers!

In this post we will look at what are the changes required to modify a custom template to enable Threaded Comments, once you have fulfilled the requirements outlined in the Threaded Comments announcement post on Buzz.blogger.com. We will then look at how to customise the look and feel of the Threaded Comments using just CSS, and also have a quick peek at alternatives.

Please note, these instructions may not work if your blog’s template is heavily customised. Your template may possibly missing some of the b:includables that the instructions below depend on. Please try the following instructions on your template, but if they don’t work come to our Blogger Developer forum and get some help with patching your template.

The first step is to Edit the HTML for your Template, which can be found inside Settings under the Template tab. You must make sure to expand the Widget Templates, as we need to modify the main Blog Widget Template. To find the main Blog Widget code, search for the following Blogger Layouts Template code:

<b:widget id='Blog1' locked='true' title='Blog Posts' type='Blog'>

Inside the b:widget are a series of b:includable blocks. These act a lot like functions in programming languages, in that they can be called from other b:includable blocks to insert chunks of HTML. The only special block is the includable called main, which is where the Layout Template engine starts when rendering the Widget’s content. If you don’t see content inside the b:widget, you need to click the Expand Widget Templates radio button above the edit area.

The Layout Template should include the following code:

<b:if cond='data:post.showThreadedComments'>
  <b:include data='post' name='threaded_comments'/>
<b:else/>
  <b:include data='post' name='comments'/>
</b:if>

The interesting part is that we have a fork here, implemented as a b:if conditional block, that decides whether to render the comments as threaded or not. The need for this split can be seen on the Threaded Comments announcement on Buzz.blogger.com.

As a quick aside, if you don’t have this code, but instead just have something like the following:

<b:include data='post' name='comments'/>

Then you can get threaded comments by replacing this b:include with the above logic block, assuming you fulfill the requirements laid out in the Threaded Comments announcement post on Buzz.blogger.com.

Now you can look at the implementation of the threaded_comments includable by searching for the following line of code:

<b:includable id='threaded_comments' var='post'>

This code is responsible for rendering the actual threaded comments to screen. You can choose to override this code block to customise the look of your comments, but it is worth noting that if you do, you won’t get updates to this functionality as we change the implementation in the future.

There are two new data members we have introduced with this feature release that you can use to render comment threads:

data:post.commentSrc This is the source to the javascript library that handles actions
data:post.commentHtml This is the rendered HTML for the comment thread

If you want to change the look and feel of your comments, we strongly recommend you use the Template Designer to set custom CSS to style the Threaded Comments. We suggest you customise the comments by modifying the property "Advanced > Add CSS". For example, you can add the following CSS code to change the look:

.comments blockquote { 
    border: 1px solid black; color: white; font: Helvetica;
} // draws a border around comment bodies, sets the text font and colour
.comments .inline-thread li { list-style-type: decimal; } // numbers replies

Finally, you can implement your own version of Threaded Comments by walking the data:post.comments directly. This will contain all the comments, ordered by time of comment, now with an optional extra field data:comment.inReplyTo which will contain the id of the parent comment, if there is one.

If you have any questions about how to customise your Blogger Comments, please feel free to drop by the Blogger Developer Forum. We’re glad to help!

An easier to use interface for the Blogger JSON API

2012-01-04T22:06:00.000-08:00

As I have been reviewing the applications to use the Blogger JSON API, I have noticed that a fair number of you appear to be integrating with Blogger JSON API using JavaScript. So, in the interests of making things easier for all of you, here is a walk through of using the just released JavaScript Client Library for Google APIs to access the Blogger JSON API.

The first step is exploring the methods we can call in the Google APIs Explorer. The method in the Blogger JSON API collection that most people use, understandably, is the method to list the most recent posts for a Blog - posts.list. This method takes one required field - the blogId that identifies a particular blog - and a number of optional arguments that allow us to tune what information is returned.

The information I am requesting from the Blogger JSON API is the post titles and content for the code.blogger.com blog which has a blogId of 3213900. To limit the returned data to just the post titles and content, we use the optional argument fields with the value of items(content,title). Here is a link to the Google APIs Explorer with the appropriate information pre-filled so you can see both the underlying query that is sent to the Google APIs servers, as well as the shape of the returned JSON data.

The next step is the JavaScript required to request this data and make use of it. I am using the JavaScript Client Library to both construct the query, as well as navigate the results, reducing the complexity of the code.

To load the library, all we have to do is include a script in our HTML that loads the library as follows:

<script src="https://apis.google.com/js/client.js?onload=init"></script>

The part of this code to pay attention to is the argument onload=init. This nominates the init function to be called once the JavaScript Client Library has loaded. The init function is where we configure the client key and the API we want to work with:

function init() {
  gapi.client.setApiKey('YOUR_API_KEY');
  gapi.client.load('blogger', 'v2', function() {
    // ...  
  }
}

You can retrieve the API Key from your project on the Google APIs Console, once you have requested that I enable the Blogger API for your project. The gapi.client.load function takes the API name, and version, of the API you want to use, and a callback function to run once the API support code has been loaded. In this code, we are loading the Blogger v2 API.

Inside the gapi.client.load callback, we have the following code to configure a request to the Google APIs servers:

var request = gapi.client.blogger.posts.list({
  'blogId': 3213900,
  'fields': 'items(content,title)'
});

Note how we now no longer need to construct our own query url. The JavaScript Client Library deals with all the messy issues of making sure the arguments are correctly escaped. Next, we can issue the request to the servers as follows:

request.execute(function(response) {
  // ...
});

The execute method takes a callback function that will be executed once the Google APIs servers respond. The most important part of this callback function is the data that is handed to us in the response argument. In the body of the callback function, I iterate over the items member to pull out the titles and contents of all the returned posts:

for (var i = 0; i < response.items.length; i++) {
  $("#target").append("<h2>" + response.items[i].title + "</h2>");
  $("#target").append(response.items[i].content);
  if (i+1    $("#target").append("<hr>");
  }
}

The eagle eyed among you will have noticed that I am using jQuery to insert the returned HTML into the DOM. I am using the latest stable jQuery hosted on Google’s Libraries API.

You can see the results on code-blogger.appspot.com. I have used HTML5 Boilerplate as the starting point for building this example, to get all the latest HTML5 magic. If you have any questions about this sample, please post them to the Blogger Developers Group.

Changes to ProfileID for Google+ profile users

2011-12-18T22:40:00.000-08:00

It’s wonderful to see a lot of our users taking us up on our offer to merge our Blogger Profile with the Google+ Profile. For developers this means that there is one small wrinkle to worry about - the format of the ProfileId for these migrated users has changed.

What’s a ProfileId, and what’s it used for?

The ProfileId is a component of the path for the Retrieving a List of Blogs Blogger GData protocol call, which can either be the value default, which is the recommended value and means the currently authenticated user, or alternatively it can be the profile identifier of the current authenticated user. Up until now, the profile identifier has always been numeric, but for the converted Google+ Profile Blogger users, this is no longer the case.

For users that have converted to using Google+ Profiles on Blogger, the ProfileId can be derived as follows. Take the Google+ profile url for a user that has chosen to convert, for example https://plus.google.com/114895967455102275039/, then take the numeric portion at the end of the URL, prepend it with a g, and like magic, you have the new Blogger ProfileId.

If you have any questions, please do not hesitate to ask on the Blogger Developers group, and if you are on Google+, have a look at our Blogger Google+ Page.

Introducing custom mobile templates

2011-11-08T16:24:00.000-08:00

Many Bloggers put a lot of time and effort into creating a unique look for their blog, so today we’re excited to announce that custom templates are now also viewable from mobile devices.

If you have a custom template for your blog and want it to appear on mobile browsers as well, visit the “Template” tab of your dashboard, click on the gear icon beneath the mobile template preview.

Then select “Custom” from the “Choose mobile template” pulldown.

Your template may not look exactly the same on a mobile browser, so click “Preview” to make sure it appears the way you want it to before you save it.

If you have gadgets on your blog, you can also control which of them will be available in mobile view, using this new attribute: mobile in <b:widget> tag. It can be 'default', 'yes', 'no', or 'only'.

The widgets that display on mobile by default are the following:

Header
Blog
Profile
PageList
AdSense
Attribution

The following widget will not be available in mobile view, because it’s a BlogArchive widget.


<b:widget id='BlogArchive1' title='Blog Archive' type='BlogArchive'>

To make it available in mobile view, add mobile=’yes’ attribute to it.


<b:widget id='BlogArchive1' mobile='yes' title='Blog Archive' type='BlogArchive'>

Setting mobile to 'no' makes a widget not display in mobile view, even if available in mobile view by default.


<b:widget id='Attribution1' mobile='no' title='Attribution' type='Attribution'>

You can also make a widget available only in mobile view by setting it to 'only'.


<b:widget id='BlogArchive1' mobile='only' title='Blog Archive' type='BlogArchive'>

The content of a widget can modified for mobile view with the boolean variable data:blog.isMobile.


<div class="widget-content">
  <b:if cond="data:blog.isMobile">
    <!-- Show a text link in mobile view.-->
    <a href="http://www.blogger.com">
      Powered By Blogger
    </a>
  <b:else/>
    <!-- Show an image link in desktop view.-->
    <a href="http://www.blogger.com">
      <img expr:src="data:fullButton" alt="Powered By Blogger"/>
    </a>
  </b:if>
</div>

The above template HTML shows different contents between desktop view and mobile view, depending on the value of the data:blog.isMobile variable.

You can conditionally give different CSS properties to a same class between desktop view and mobile view, as the <body> tag of Blogger mobile templates has mobile as its class. First, make sure the <body> tag of your custom template is same as the following one.


<body expr:class='&quot;loading&quot; + data:blog.mobileClass'>

Then, you can define different CSS properties for desktop and mobile view.


/* For desktop view */
.date-posts {
  margin: 0 -$(separator.outdent);
  padding: 0 $(separator.outdent);
}

/* For mobile view */
.mobile .date-posts {
  margin: 0;
  padding: 0;
}

We hope you will enjoy making your very own mobile templates.

Updated: Changed data:mobile to data:blog.isMobile

Template Change: Analytics Section

2011-10-13T17:51:00.000-07:00

Today we have made a change to the Layouts Template language to improve Google Analytics coverage. We have added the following includable section.


<b:includable id='google-analytics' var='blog'>
  <b:if cond='data:blog.analyticsAccountNumber'>
    <script type='text/javascript'>
      var _gaq = _gaq || [];
      _gaq.push(['_setAccount', '<data:blog.analyticsAccountNumber/>']);
      _gaq.push(['_trackPageview']);
      (function() {
        var ga = document.createElement('script');
        ga.type = 'text/javascript';
        ga.async = true;
        ga.src = (document.location.protocol == 'https:' ?
                  'https://ssl' : 'http://www') + '.google-analytics.com/ga.js';
        var s = document.getElementsByTagName('script')[0];
        s.parentNode.insertBefore(ga, s);
      })();
    </script>
  </b:if>
</b:includable>

This now allows you to include analytics tracking on your blog by adding the following include call to your template, preferably right before the close body tag so it doesn’t delay the visible page being rendered:


<b:include name='google-analytics' data='blog'/>

For more details on the benefits you get from using Google Analytics, see this post on Blogger Buzz. If you have any questions about this new functionality, please join in the discussion on the Blogger Developer Group.

Trying on the new Dynamic Views from Blogger

2011-09-27T16:42:00.001-07:00

As you may have noticed, the Blogger Development Network Blog looks a lot different today. That’s because we—along with a few other Google blogs—are trying out a new set of Blogger templates called Dynamic Views.Launched today, Dynamic Views is a unique browsing experience that makes it easier and faster for readers to explore blogs in interactive ways. We’re using the Classic view, but you can also preview this blog in any of the other six new views by using the view selection bar at the top left of the screen.We’re eager to hear what you think about the new Dynamic Views. You can submit feedback using the “Send feedback” link on the bottom right of this page. If you like what you see here, and we hope you do, we encourage you to try out the new look(s) on your own blog—read the Blogger Buzz post for more info.

Blogger JSON API now available

2011-09-08T01:59:00.000-07:00

Today we’re announcing the public availability of the Blogger JSON API we spoke about at this year’s Google I/O. The focus of this release is to make it easier to build applications that interoperate with Blogger by using a lightweight JSON syntax.

One of the driving reasons for this release is to recognize how much the world has changed during the lifetime of Blogger. Where once we built everything as desktop applications, we now spend our time building full-blown applications inside the browser frame using JavaScript and HTML5 apps.

To start using the Blogger JSON API, sign in to the Google API Console and request Blogger API access. This will take you to a form that asks you to explain how you intend to use the API, and an estimate of your daily traffic levels. This information helps us evaluate your request for approval and give us a better understanding of how the community is using our APIs as we work to improve them.

To demonstrate how much easier this API is to use, especially for JavaScript mashups, here is a JavaScript renderer for the Blogger Buzz blog.

<html>
  <script src="https://ajax.googleapis.com/ajax/libs/jquery/1.6.2/jquery.min.js"></script>
  <script>
  // Request an API Key for the Blogger API from 
  // https://code.google.com/apis/console/
  var apikey = "YOUR API KEY HERE";
  
  // You can find the blogId in the HTML source of a blog
  var blogId = "2399953";
  
  // When the document is loaded
  $(document).ready(function() {
   
    // Make a JSONP request for the Posts on the Blogger Buzz blog
    $.ajax({
      url:"https://www.googleapis.com/blogger/v2/blogs/”+
        blogId+”/posts?key="+apikey,
      dataType: "jsonp",
      success: function(data, textStatus, jqXHR) {
        var items = [];   
        // Construct a chunk of HTML for each post
        // containing the Post title, content, and a 
        // link to the post author.
        $.each(data.items, function(index, value) {
          items.push("<h2>"+value.title+"</h2>"+value.content+
            "<p>Posted by <em><a href='"+value.author.url+"'>"+
            value.author.displayName+"</a></em></p>");
        });

        // And finally, append the generated content to the page body.
        $(items.join('')).appendTo('body');
      }
    });
  });
  </script>
</html>

It is important to understand that this release is the first step on a journey of discovery, as we work with all of you to build a better API for using Blogger. Please review the documentation, and join in the discussion on Blogger Developer Group and let us know what we can add to the API to make it more useful for you!

Clarifying recent changes to Blogger’s feed access

2011-06-15T19:20:00.000-07:00

Recently we updated Blogger’s authorization system to be more consistent with regards to the difference in roles between blogger.com and blogspot.com. As a result, some third-party integrations that depended on an unintended quirk of our previous system broke. This post explains the issue and how to update your implementation to be compliant with the correct authorization behavior.

The Blogger Developer’s Guide explains how to authenticate to our services on the URLs under http://www.blogger.com/feeds/profileID/. The unintended quirk allowed authentication requests against public feed URLs hosted on the blogspot.com domain. Under the updated system, this is no longer permitted.

Now, authorization is only permitted against https://www.blogger.com/feeds/ and http://www.blogger.com/feeds/. The feeds are not going away; instead we are separating the read-only, unauthenticated subscriptions from authenticated access to Blogger’s read-write APIs.

We apologize that the impact of this behavior change was not made more clear initially. If you have any further questions on this matter — or Blogger development in general — please post a question in our BloggerDev forum.

Using OACurl to explore Blogger’s API

2011-03-25T12:05:00.001-07:00

Blogger’s GData API is now available over HTTPS using OAuth 2. These changes result in less code, increased productivity, and enhanced security. Let’s take a look at how it works using OACurl, a wrapper for the curl command line tool that authenticates you using OAuth.

Prerequisites

First up you need to install Mercurial and Maven. Mercurial is the source revision control software used by the OACurl project. Maven is a java build system used to download and include the dependencies required by OACurl. Once we begin using oacurl we will use HTML Tidy to make the returned XML readable.

Getting OACurl

Now that you have installed Maven and Mercurial, you can checkout oacurl and build it as follows.

$ hg clone https://oacurl.googlecode.com/hg/ oacurl

$ cd oacurl

$ mvn assembly:assembly

Once you have done this you will have a shell script in your current directory called oacurl that you can use to invoke oacurl with all the appropriate Java class paths set for you.

Logging into Blogger

Logging into Blogger using OAuth involves doing a round trip to Google’s servers to grant access for third parties. In the case of oacurl, this involves invoking a web browser that shows you that oacurl is requesting access to your Blogger account.

$ ./oacurl login --blogger

Once you have granted access, then you will be able to explore Blogger’s API using oacurl.
Retrieving a list of your Blogger blogs

A good place to start is to list out your blogs. This is an Atom feed where each item in the list is a blog owned by the user who requested it.

$ ./oacurl https://www.blogger.com/feeds/default/blogs

To see the blogs of a specific user you can change the default for a specific user’s profile id instead. For instance, here is a list of my blogs.

$ ./oacurl https://www.blogger.com/feeds/16258312240222542576/blogs

To make the output XML readable, I suggest piping the output from the commands through tidy like this:

$ ./oacurl https://www.blogger.com/feeds/default/blogs | tidy -xml -quiet -indent

I will leave that off the following commands for readability.

Retrieving the feed of a specific Blogger blog

To retrieve the content of a blogger blog, we select the blog we want from the list of blogs in the blog feed, and then follow the appropriate link. In this case we are using the post link as it stays within the scope of our OAuth authorisation.

<link rel='http://schemas.google.com/g/2005#post'

    type='application/atom+xml' href= 'http://www.blogger.com/feeds/4967929378133675647/posts/default' />

Posting a new entry to a feed

If I wanted to post a new entry to my test blog, all I need to do is create a new entry in Atom format, and post it to the above url. So, I create a file with the following content called post.xml:

<entry xmlns='http://www.w3.org/2005/Atom'>

  <title type="text">Posting via OACurl</title>

  <content type="xhtml">And some <b>content</b>.</content>

</entry>

I can submit this to Blogger to create a new post like this:

$ cat post.xml | ./oacurl -X POST https://www.blogger.com/feeds/4967929378133675647/posts/default

This, of course, won’t work for you, as my test blog is only set up for me to post to. Modify the post URL in the command to match the one from one of the Blogger blogs you own. The result from the command is the fully expanded Atom entry for the post that was just created.

This Atom entry contains the information you need to modify it. The link with rel='edit' is the magic entry. For blogger, this is the same as the rel='self' link. To edit the content for the blog post I just created, first I retrieve the content at the edit URL:

$ ./oacurl https://www.blogger.com/feeds/4967929378133675647/posts/default/2170959137511831372 > post-edit.xml

We can now modify the title and content using a text editor, and then PUT it back, in proper REST style.

$ vi post-edit.xml

$ cat post-edit.xml | ./oacurl -X PUT https://www.blogger.com/feeds/4967929378133675647/posts/default/2170959137511831372 

The Atom representation also contains the information required to create, retrieve, and delete the comments on this entry. See if you can spot the appropriate URLs in the output XML.

Using the libraries

You can use various libraries with the Blogger GData APIs, for example the Java GData client, but it is very useful to understand what the library is doing for you under the covers. And exploring is fun!

If you have any questions after reading this post, please feel free to post your questions to the Blogger Dev Google Group.

References

OACurl: http://code.google.com/p/oacurl/
OAuth: http://oauth.net/
Mercurial: http://mercurial.selenic.com/
Maven: http://maven.apache.org/
Atom overview: http://en.wikipedia.org/wiki/Atom_(standard)
Atom Specification: http://www.atomenabled.org/developers/syndication/atom-format-spec.php
HTML Tidy: http://www.w3.org/People/Raggett/tidy/
Java GData Client: http://code.google.com/p/gdata-java-client/
Blogger Dev Google group: http://groups.google.com/group/bloggerdev

Bug Fixes for 6/15

2009-06-16T06:52:00.000-07:00

Late last week we fixed a few bugs in Blogger’s Data API implementation:

POSTs to the feed on the blog’s domain (rather than www.blogger.com) now correctly return the entry XML in the 201 response. This was the cause of a variety of strange errors, particularly when using the client libraries.
Posts created via the API now correctly reflect the blog’s “Comments Default for Posts” setting. [Issue 1242]
The tracker image in feed entries is now consistently served over HTTPS, instead of leaving the scheme relative, to fix a crash with Microsoft Outlook.

Having a reproducable problem? Please file a report in the issue tracker and we’ll investigate.

Bug Fixes and Changes for 3/12

2009-03-13T14:16:00.000-07:00

Last night we pushed two Blogger Data API bug fixes:

With these fixes you should see more reliable results for authenticated and V2 feeds.

We have also started to include a <div class="blogger-post-footer"> in each feed entry’s content element. Apologies if this has disrupted your app. We’re working on preventing this from appearing in authenticated requests, and that fix should be rolled out early next week.

API clients can and should in general ignore the “blogger-post-footer” element however, as it will be present if a blog admin specifies a Post Feed Footer in Settings > Site Feed.

Google Blog Converters 1.0 Released

2009-01-09T17:12:00.000-08:00

JJ writes on the Open Source at Google blog:

Blog authors around the world, Google would like to remind you that it's your blog, your data. Now that Blogger allows users the ability to export all contents of their blog, the Data Liberation team would like to announce the Google Blog Converters project. This new Open Source project provides the ability to easily move blog posts and comments from service to service. This initial release provides Python libraries and runnable scripts that convert between the export formats of Blogger, LiveJournal, MovableType, and WordPress.

Give it a spin. We’ve also released templates to run the converters on Google App Engine.

Bug Fixes for October 1

2008-10-01T16:45:00.000-07:00

We released a few bug fixes tonight for regressions introduced last week:

Issue 795: Blog metafeed did not contain rel="self" links in entries. This had the even more unfortunate side effect of breaking some of our sample code, which was using these links to derive blog IDs.
Issue 798: Query parameters were being repeated in the rel="next" and rel="prev" links in feeds, leading to invalid duplicate parameters.
Issue 803: Unable to fetch blog documents.

We apologize for these regressions, and hope that they’ve been fixed satisfactorily.

Feeds now include Media RSS thumbnails

2008-09-23T10:26:00.000-07:00

With the most recent release of Blogger we’ve added Media RSS <media:thumbnail> elements to both Atom and RSS feeds.

The <media:thumbnail> element links to a 72x72 pixel version of the first image in the post. Only images uploaded through Blogger to PicasaWeb are available as thumbnails.

We hope that you’ll be able to find fun uses for this new element. We’ve added thumbnail support to Blogger’s Blog List page element as a new option: Blog Lists can now display the most recent thumbnail from Blogger and other Media RSS–enabled feeds.

Atom Threading, Profile URLs, and RSS Validation

2008-05-09T09:45:00.000-07:00

We’ve just launched three additions / fixes to Blogger’s site feeds:

<thr:in-reply-to> elements from Atom Threading Extensions (RFC 4685). These elements point from comment feed entries to the post feed entry that they’re commenting on. They’re especially useful for associating comments from the per-blog comment feed with the relevant posts.
Profile URLs in <person> entries. We’re now adding <uri> elements to <person> elements that point to the person’s Blogger profile or homepage. This matches the behavior on Blogger’s HTML comment pages. We’re also adding these elements to post <entry>s, but only if the author of the post lists the blog on his profile.
RSS 2.0 feeds now validate. We’ve added dummy noreply@blogger.com email addresses to <person> entries so that they validate in RSS 2.0, which requires an email address.

How are these working out for you? Let us know in the Blogger API Google Group.

Atom Publishing Protocol Interop Meeting, November 13–14

2007-11-08T08:47:00.000-08:00

Blogger and Google Data API developers will be participating in the November 2007 Atom Publishing Protocol interoperability meeting, happening this coming Tuesday and Wednesday, November 13–14. This is a chance for implementers of servers and clients to squash any remaining bugs in their APP code to make sure that they match the upcoming standard.

Take a look at the wiki page for instructions on how you can participate!

Video: Pamela Fox and Ryan Boyd talk about the Blogger JavaScript client library

2007-10-22T12:49:00.000-07:00

(Or, watch on YouTube)

Blogger JavaScript Client Library Released

2007-10-20T08:32:00.000-07:00

Paul McDonald just announced the new Blogger JavaScript client library over on the Google Data APIs Blog:

The Blogger GData JS Client library enables developers to read and write blog posts using calls to our JavaScript library. This is a full client library, with support for authenticated access to private data and read-write capabilities. Now you can create Blogger applications and mashups that can read and write data from your Blogger blogs. No server-side programming is required. Your application can run on any domain, too. No proxying is required.

We have a new developer guide for JavaScript and some code samples to give you ideas and get you started.

Reporting and tracking Blogger API bugs

2007-10-19T13:40:00.000-07:00

Hopefully, you’re really enjoying the Blogger API and the flexibility of being able to post to your blog using your own custom software. Sometimes things don’t work quite the way you’d expect or like and we want to hear about it.

If you find a bug in our Google Data API implementation, or something that we could do better, please file an issue in our tracker.

We use this to keep track of issues with all of the Google data APIs, so be sure to mention that you’re talking about Blogger when writing your description. While you’re at it, I’d like to hear about it on the discussion group too.

We’re going to start coordinating this external issue tracker with our internal development, so we’ll update the relevant issues if we ship fixes to them.

Blogger API Update

2006-08-15T16:04:00.000-07:00

Hi folks,

Just posting to let subscribers to this blog's feed know that new Blogger/GData documentation is available on code.google.com; please stay tuned to the bloggerDev discussion list for updates.

Thanks,
-Eric and the Blogger Team at Google

Blogger + Emacs = Crazy Delicious

2006-01-12T11:33:00.000-08:00

(sorry, I've been fully infected)

emacsgeek:

"Announcing atom-blogger.el atom-blogger.el found at atom-blogger.tar.bz2 is a light-weight Emacs client for posting and editting blogger.com entries. It uses curl to handle the HTTP side of the blogger ATOM API, and relies on Emacs' support for editting XML --- either via nxml-mode or Emacs' vanila xml-mode."

[via bloggerDev]

PHP Atom API Library

2005-11-23T14:52:00.000-08:00

Beau Lebens recently informed bloggerDev that he's posted a PHP library for interacting with Atom APIs (like Blogger's): http://dentedreality.com.au/phpatomapi/

PHP Atom API Code

2005-10-14T10:38:00.000-07:00

In case you're ever looking for example code for posting to Blogger's Atom API from PHP, see this post on bloggerDev: "Working PHP code to post to Blogger"

Photolightning

2005-10-14T10:35:00.000-07:00

Our friends at Photolightning just released their latest version, which incorporates some nifty Blogger functionality — it can post photos to blogs, which can then be purchased at ClubPhoto. Here's an example blog with some Photolightning posts.

API of the week!

2005-08-19T11:46:00.000-07:00

FeedBurner just announced their RESTful Feed Management API:

Tired of coming to FeedBurner to analyze your stats? Use the API. Tired of "logging in" via a "browser" to "edit" your feed "settings"? Use the API.

What can't you do with the API? Nothing, with one exception. The API has a built-in limit of 20 burned feeds per user id. We will ratchet this down even lower if it's abused, but that seems like a reasonable number to get started.

BlogMarks support

2005-08-03T11:26:00.000-07:00

François Hodierne recently implemented Blogger Atom API support on blogmarks.net:

"The good news is that this PHP/PEAR implementation is open source and immediately available. Be careful, this is not very seriously tested."

You can get it from here:

the class: blogmarks.net/files/Services_Blogger_03.zip

a package with all dependencies: blogmarks.net/files/Services_Blogger_03-package.zip

for documentation and feedback, i started a wiki page on the blogmarks.net wiki about it: dev.blogmarks.net/wiki/ServicesBloggerPhpClient

Two Minor Updates

2005-07-29T13:27:00.000-07:00

We've just added two new sections to Blogger's Atom API documentation:

Draft is what you'd expect it to be. Extensions is where we'll be documenting Blogger-specific additions to the API, such as Line Break Status (the only one listed at the moment).

Please post any questions or comments to bloggerDev.

PowerBlog

2005-07-06T11:43:00.000-07:00

Jon Davis just wrote in to let us know that PowerBlog (a Windows-based desktop blogging client) has gone Open Source:

http://sourceforge.net/projects/pwrblog/

EVDB API

2005-06-27T11:24:00.000-07:00

EVDB just launched their API.

I like Step 3: "Go make something cool!"

API from FeedBurner

2005-06-21T13:50:00.000-07:00

Dick just announced FeedBurner's Feed Awareness API, which "enables any 3rd party to query feed statistics on FeedBurner feeds."

"AwAPI uses a straightforward web-based protocol to receive requests and return data. Known as REST, it allows anyone to request feed traffic data using URLs submitted via HTTP. The data is returned as plain text XML which can be repurposed, transformed, and displayed by applications that you build. Using XML as the output format means testing and exploring AwAPI is as simple as composing an AwAPI URL and then requesting it with a web browser."

RadioAtomBridge

2005-06-13T09:18:00.000-07:00

Scott Lemon just wrote in to let us know he's released RadioAtomBridge, a tool that enables Radio Userland to post to Blogger blogs:

"A while back I realized that I really wanted to use Radio to be able to post to some of my blogs that are hosted at Blogger.com and Blogspot.com..."

"So this is it ... the new and improved RadioAtomBridge Tool ... a derivative of the xManilaBloggerBridge Tool which was a derivative of the ManilaBloggerBridge Tool. I'm giving all of this code to Userland to incorporate this into a future version of Radio."

FotoFlix

2005-04-25T16:57:00.000-07:00

The folks at FotoFlix just wrote in to let us know that they've added Blogger support to their photo-sharing site.

"We are very excited to offer this service and Blogger is the first blogging site which we are supporting directly using an API... We are anticipating for it to be well received due to it's uniqueness and simplicity."

It's great to see innovative new Atom API uses from the web community!

Textamerica API

2005-04-14T16:33:00.000-07:00

Another webapp/blogging API with which to tinker: Textamerica Developer API

JavaScript Blog

2005-04-04T14:02:00.000-07:00

Scott Andrew is blogging all about AJAX and JavaScript at The Strange Zen of JavaScript. Just added it to the blogroll...

[via PhilR]

Zoundry Updated

2005-03-30T21:13:00.000-08:00

We just heard from Lawrence Lee of Zoundry that their Blog Writer app has been updated to support SSL and Blogger's AtomAPI. It's a Windows app for doing WYSIWYG blogging from the desktop.

PocketBlogger Updated

2005-03-21T10:59:00.000-08:00

Steve Novoselac just wrote in to let us know that PocketBlogger's been updated to support Blogger's Atom API and secure authentication via SSL.

PocketBlogger is a PocketPC Blogger client.

43Things API

2005-03-17T17:31:00.000-08:00

Our friends at The Robot Co-op just released Web Services. for 43Things. Fun!

Google Code

2005-03-17T10:46:00.000-08:00

Google Code launched today; here's DiBona's Google Blog post:

We're very happy to be launching code.google.com today. To begin, we're releasing some developer-oriented libraries and tools. Google developers use these every day to make their programs easier to debug, faster, and more reliable. A number of engineers have used their 20% time to ready these tools for release, and will also help build the communities we hope will form around them.

We're also featuring links to all current Google APIs. Come check them out and if you'd like more information, please join our group, subscribe to our feeds, or if you're shy, email us directly. And happy coding!

Ecto

2005-03-16T10:54:00.000-08:00

Nice! Adriaan just released an updated version of Ecto for both Mac and Windows, which supports SSL authentication.

Atom API Update

2005-03-14T17:25:00.000-08:00

A long-overdue Atom API update just went live. Aside from lots of bug fixes, full i18n support is present via UTF-8, and authentication now works securely via Basic HTTP Auth over SSL at the Atom endpoint: https://www.blogger.com/atom

Documentation is live too, and feel free to post to the BloggerDev list if you need technical assistance. Be sure to search the list archives first however, in case your issue has already been addressed. Note that Post Titles now work seemlessly via the API.

We've already been testing an updated version of Adriaan Tijsseling's Ecto, and we'd love to hear from anyone else making progress with their Blogger/Atom apps. You can email us at support AT blogger.com, subject=BDN.

Thanks for your patience as we've worked on shipping this API milestone!

Desktop Clients Updated

2005-01-13T14:23:00.000-08:00

Marcelo Cabral just updated w.bloggar to v4.0, and Dmitry Chestnykh released BlogJet v1.5 — both now support SSL for posting to Blogger blogs.

Nokia Lifeblog spec

2004-12-21T15:40:00.000-08:00

The Lifeblog Posting Protocol spec is available for download from Nokia:

"This is the technical document that explains how we use Atom to post multimedia content online. Use this document to figure out how to adapt your servers to use Lifeblog 1.5."

MarsEdit to get Atom API support

2004-12-20T10:00:00.000-08:00

Atom support for the excellent MarsEdit is on the way, according to Brent:

"MarsEdit doesn’t yet support titles for Blogger."

"It will—but it requires implementing the Atom weblog editing API first. This is MarsEdit’s top priority."

BuzzNet Developers

2004-12-07T15:17:00.000-08:00

Our friends over at BuzzNet recently launched their Developer Network. Along with the usual stuff (docs, feed list), they've also got a nice Community Wishlist of apps & tools for folks to hack on. We're assembling a similar list for Blogger's API — stay tuned for details.

APIs and SSL

2004-10-18T15:41:00.000-07:00

Remain calm and do not panic. We're switching to a more secure Google-wide account system. What does this mean? Basically, it means that our APIs are all going to be available over SSL. We're not turning off the old API endpoints, but tools not using SSL won't be able to send usernames and passwords over the clear. Which pretty much means they will seem broken.

The good news is, we're not just gonna leave you hanging. We're building a special PIN system for use with non SSL tools. Blogger 1.0, 2.0, and Atom 0.3 are all going to be available over SSL. Since our Atom 0.3 support is still beta, we will switch to only support HTTP Basic Authentication over SSL. As our Blogger API support is considered stable, we will support both regular passwords over SSL and a new PIN system over non-SSL connections.

So users of non SSL tools will be able to visit Blogger.com and get a special password but you'll agree this is not optimal. What we recommend and encourage is that you, gentle Blogger developer, switch to an XML-RPC toolkit that can do SSL and make the appropriate changes to your fine offerings.

We're planning on initiating this move in a few weeks and we'll work to make sure our user base understands what's going on as well. We'll keep you updated on the BDN blog with any significant news. Please accept our apologies if this switch messes up your weekend or causes you any trouble but ultimately, it's for the best--think of the
possibilities!

[originally posted by Shellen]

Blogger gets AtomEnabled

2004-01-22T17:24:00.000-08:00

Today, we launched support for Atom in Blogger. This means that all Blogger users now have the ability to syndicate their blog content in a rich XML format (see What is Atom?). In addition, we have rolled out beta support for the Atom API. This means a more robust API for you to use in creating new blogging applications. Some of the benefits of the new API are:

support for titles
tighter integration with the
syndication format and editing tools
extensibility
easy-to-use WSDL file to work with most SOAP toolkits
higher security authentication using WSSE
more robust Blogger endpoint
support for SOAP and REST

More documentation will follow in the next few weeks as the Atom API moves to version 1.0. In the meanwhile, you may want to try the SOAP Atom API client in C# and this WSDL file. You should be able to drop this WSDL file into most developer tools. You can test this client against our Atom API endpoint at: http://www.blogger.com/atom/. You should enter the endpoint where it currently says http://localhost/AtomApi.asmx in the WSDL. For more general Atom information visit AtomEnabled.org.

As always, feedback and comments are appreciated.

[originally posted by Shellen]

Atom feed limited beta

2003-11-30T21:44:00.000-08:00

Since the Atom syndication format is nearing a spec revision, we thought we should point to examples of the feeds we are currently planning to output via Blogger. Some of the Blogger team members have graciously agreed to use their personal blogs as Atom syndication test blogs, below are a handful for testing purposes. Please remember that these are not the final output, probably close though, and should validate at FeedValidator.org. Enjoy and please leave any comments on the Atom-syntax list.

Jason Goldman : http://www.goldtoe.net/atom.xml
Steve Jenson : http://www.saladwithsteve.com/atom.xml
Jason Shellen : http://www.shellen.com/atom.xml
Evan Wiliams : http://www.evhead.com/atom.xml

Next step: Atom syndication for you!

[originally posted by Shellen]

Proposal for post creation request

2003-07-01T21:50:00.000-07:00

Misha has put up a proposal on the new API wiki for how a post request might work. Feedback welcomed there.

[originally posted by Ev]

Blogger API Update

2003-07-01T20:20:00.000-07:00

Here is an update for developers interested in writing tools that integrate with Blogger.

First, a little background: As you may know, the original Blogger API was put up almost two years ago, with the disclaimer that it was in an "experimental" and "alpha" state with no guarantees about its future. It was designed hastily by myself in a couple days, and we had very little resources to do much with it at the time.

Despite these drawbacks, people built cool stuff and other blogging tool vendors supported the Blogger API for compatibility.

It is now (past due) time to do a major revamp of our API. In fact, we've been working on the next version for quite a while. We posted a preliminary spec to our developers list late last year and got a lot of feedback. But we were not that confident in the direction and still didn't really have the extra cycles necessary to put into to it—until recently.

As the first post to this blog (which also inaugurated this new developer's section of blogger.com) indicates, we became very interested in a new proposal that has recently been in the works by a bunch of smart engineer-types of the blogging world. We felt, if it worked out, this new spec (code-named "Atom"), would solve a lot of potential problems with our API, as well as with the blog syndication format we support, RSS. It would do so in an elegant way, specifically designed for blogging. And, even better, a way that was unified with other major blogging tool vendors.

Consequently, our developers got involved with the Atom project to make sure we felt it would work for our needs, as well as everyone else's. We are very pleased with the technical progress made so far and are committed to help the project reach conclusion.

What this means for Blogger developers:

We will continue to support the Blogger API 1.0. (Technically, we are supporting it for the first time—as in, taking off the disclaimers and making sure it is up and running more reliably.) In fact, we have written a new implementation of it, along with the new, more robust, Blogger codebase. However, that spec is frozen and will not be developed further.
We will not be implementing or supporting the Blogger API 2.0. We apologize for having that out there in a semi-final looking spec for so long. We know it was frustrating for developers. But please forget that ever happened.
We are moving away from XML-RPC. If you choose to take advantage of the capabilities of the new API, you will need to use SOAP instead of XML-RPC. This was a difficult decision (made collectively by the designers of Atom), because there is a lot of investment in XML-RPC in the blogging tool space, and it is great for getting things done quickly. But we felt the technical advantages offered by SOAP were worth the effort. (See SixApart link below for details.)
The syndication format and API format will be unified. This is one of the nice aspects of Atom that could not have been easily accomplished without starting from scratch. It generally simplifies getting data into and out of blogging apps.
Interoperability. This is a biggie. At least two other major blogging tool and service companies (SixApart and Live Journal) have pledged their support for this new initiative, and we're working with them (as well as others) to define the spec up-front. This means your tools will be usable by as many people as possible, with minimal effort. And since the API/format will be vendor-neutral, no one's needs can be more important than users and developers.

In general, our goal is to make it as painless as possible to develop neat stuff that plugs into Blogger, and we feel we are very close to having the best direction for that to happen. The technical folks in the blogging world have learned a lot of the past few years about RSS and the blogging APIs—about what works well and what doesn't. And, despite the efforts that have gone into certain directions, we feel it'd be unfortunate this early in the game to be married to a certain direction just because we started out that way when we didn't know as much.

As mentioned, the project is still in the works, and there is no final spec, but there are lots of smart people working on getting it right. And it's an open process: You can get involved by visiting the wiki, posting to your blogs and mailing lists, etc.

Lastly, I didn't go into much of the technical reasons behind the decisions in the Atom project here. But they have been well-articulated by Ben Trott of SixApart. I encourage checking out that if you're interested.

Thanks for your patience (and contributions) in getting this all worked out.

[originally posted by Ev]

The future of blogging APIs?

2003-06-24T16:37:00.001-07:00

Sam Ruby and friends have been working on a new format and API for content syndication and editing. Visit the Log Format Roadmap to view the details and current supporters of this effort. We at Blogger would like to cast our vote in favor of this process and commend Sam on his efforts. We are spending a considerable amount of time thinking about how this will integrate with Blogger and plan to become more active participants in the discussion. We have the utmost faith that with his direction this will become a format and API that we will support in our current and future product line.