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 fielddata: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!
Posted Yesterday by Brett Morgan
JAN
5
An easier to use interface for the Blogger JSON API
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");
  }
}
```
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 theBlogger Developers Group.
Posted 3 weeks ago by Brett Morgan
DEC
19
Changes to ProfileID for Google+ profile users
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 examplehttps://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.
Posted 19th December 2011 by Brett Morgan
NOV
9
Introducing custom mobile templates
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">
    
    <a href="http://www.blogger.com">
      Powered By Blogger
    </a>
  <b:else/>
    
    <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
Posted 9th November 2011 by Brett Morgan

Template Change: Analytics Section

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.

Posted 14th October 2011 by Brett Morgan

SEP
28
Trying on the new Dynamic Views from Blogger
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.
Posted 28th September 2011 by Brett Morgan
SEP
8
Blogger JSON API now available
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!
Posted 8th September 2011 by Brett Morgan
JUN
16
Clarifying recent changes to Blogger’s feed access
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 underhttp://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/ andhttp://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.
Posted 16th June 2011 by Brett Morgan
MAR
26
Using OACurl to explore Blogger’s API
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 invokeoacurl 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
Posted 26th March 2011 by Brett Morgan
JUN
16
Bug Fixes for 6/15
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.
Posted 16th June 2009 by Pete
MAR
14
Bug Fixes and Changes for 3/12
Last night we pushed two Blogger Data API bug fixes:
- Drafts intermittently not appearing in the authenticated ATOM feed
- Blogger v2 feeds do not contain gd:etag elements
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.
Posted 14th March 2009 by Pete
JAN
10
Google Blog Converters 1.0 Released
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 thatBlogger 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, andWordPress.
Give it a spin. We’ve also released templates to run the converters on Google App Engine.
Posted 10th January 2009 by Pete
OCT
2
Bug Fixes for October 1
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.
Posted 2nd October 2008 by Pete
SEP
24
Feeds now include Media RSS thumbnails
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.
Posted 24th September 2008 by Pete
MAY
10
Atom Threading, Profile URLs, and RSS Validation
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.
Posted 10th May 2008 by Pete
NOV
9
Atom Publishing Protocol Interop Meeting, November 13–14
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!
Posted 9th November 2007 by Pete
Labels: atom atom publishing protocol
OCT
23
Video: Pamela Fox and Ryan Boyd talk about the Blogger JavaScript client library

(Or, watch on YouTube)
Posted 23rd October 2007 by Pete
OCT
20
Blogger JavaScript Client Library Released
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.
Posted 20th October 2007 by Pete
OCT
20
Reporting and tracking Blogger API bugs
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.
Posted 20th October 2007 by Jeffrey Scudder
Labels: feature requests issues
AUG
16
Blogger API Update
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
Posted 16th August 2006 by Eric
JAN
13
Blogger + Emacs = Crazy Delicious
(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]
Posted 13th January 2006 by Eric
NOV
24
PHP Atom API Library
Beau Lebens recently informed bloggerDev that he's posted a PHP library for interacting with Atom APIs (likeBlogger's): http://dentedreality.com.au/phpatomapi/
Posted 24th November 2005 by Eric
OCT
15
PHP Atom API Code
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"
Posted 15th October 2005 by Eric
OCT
15
Photolightning
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.
Posted 15th October 2005 by Eric
AUG
20
API of the week!
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.
Posted 20th August 2005 by Eric
AUG
4
BlogMarks support
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
Posted 4th August 2005 by Eric
JUL
30
Two Minor Updates
We've just added two new sections to Blogger's Atom API documentation:
- Save a Post as Draft
- Blogger Extensions
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.
Posted 30th July 2005 by Eric
JUL
7
PowerBlog
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/
Posted 7th July 2005 by Eric
JUN
28
EVDB API
EVDB just launched their API.

I like Step 3: "Go make something cool!"
Posted 28th June 2005 by Eric
JUN
22
API from FeedBurner
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."
Posted 22nd June 2005 by Eric
JUN
14
RadioAtomBridge
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."
Posted 14th June 2005 by Eric
APR
26
FotoFlix
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!
Posted 26th April 2005 by Eric
APR
15
Textamerica API
Another webapp/blogging API with which to tinker: Textamerica Developer API
Posted 15th April 2005 by Eric
APR
5
JavaScript Blog
Scott Andrew is blogging all about AJAX and JavaScript at The Strange Zen of JavaScript. Just added it to the blogroll...

[via PhilR]
Posted 5th April 2005 by Eric
MAR
31
Zoundry Updated
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.
Posted 31st March 2005 by Eric
MAR
22
PocketBlogger Updated
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.
Posted 22nd March 2005 by Eric
MAR
18
43Things API
Our friends at The Robot Co-op just released Web Services. for 43Things. Fun!
Posted 18th March 2005 by Eric
MAR
18
Google Code
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!
Posted 18th March 2005 by Eric
MAR
17
Ecto
Nice! Adriaan just released an updated version of Ecto for both Mac and Windows, which supports SSL authentication.
Posted 17th March 2005 by Eric
MAR
15
Atom API Update
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!
Posted 15th March 2005 by Eric
JAN
14
Desktop Clients Updated
Marcelo Cabral just updated w.bloggar to v4.0, and Dmitry Chestnykh released BlogJet v1.5 — both now support SSLfor posting to Blogger blogs.
Posted 14th January 2005 by Eric
DEC
22
Nokia Lifeblog spec
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."
Posted 22nd December 2004 by Eric
DEC
21
MarsEdit to get Atom API support
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."
Posted 21st December 2004 by Eric
DEC
8
BuzzNet Developers
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.
Posted 8th December 2004 by Eric
OCT
19
APIs and SSL
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]
Posted 19th October 2004 by Eric
JAN
23
Blogger gets AtomEnabled
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]
Posted 23rd January 2004 by Eric

Minggu, 22 Januari 2012

semua

Tidak ada komentar:

Posting Komentar