Mike's Notes
On a Sandy Beach is a publication of Ajabbi Research.
Changes needed
Enable other people at Ajabbi Research to also contribute to On a Sandy Beach using the Workspaces for Research UI.
It looks very straightforward. This job will be done once the Workspaces for Research are available for researchers to use.
Preparation
Last year, all existing blog posts were reformatted.
New setup
The Pipi CMS Engine (cms) will format, store in a database, and export content
to On a Sandy Beach, hosted on Google Blogger, using the Blogger API ver 3.
Either XML/Atom or JSON can be used.
Steps
-
Import the existing blog posts into the CMS Engine via the Blogger API
- Reformat every post (see 4th resource link below)
- Store in the CMS database
-
Render posts
- Export back to Blogger via the Blogger API.
- All future posts will be created by a human using a workspace, transferred to the CMS Engine, processed, and then published to Google Blogger.
Notes
Here are some initial notes taken from the Google Blogger API documentation and other sites, tweaked using Gemini and rewritten by Grammarly.
These notes will be presented using slides at tomorrow night's online Open Research Group meeting.
Resources
References
Repository
-
Home > Ajabbi Research > Library >
-
Home > Handbook >
Last Updated
09/02/2026
Using Google Blogger API v3
By: Mike Peters
On a Sandy Beach: 07/02/2026
Mike is the inventor and architect of Pipi and the founder of
Ajabbi.
Blogger supports manual import and export of blog content via the
Blogger dashboard or the Blogger API. The export file format for both
methods is Atom, an XML-based format that includes all posts and
comments.
Blogger API for Import/Export
Developers can use the Blogger API (v3 is the current version) to
programmatically manage blog content. The export file generated via the
manual process uses the same Atom format as the API's feed
requests.
Key Points for API Use
-
Authentication: All operations for private data (including
import/export) require authentication, typically using OAuth 2.0.
-
Format: The API uses REST APIs and JSON for standard
operations. The specific import/export functions rely on the raw
XML/Atom format described in the developer guides.
-
Functionality: The API allows retrieving, creating, updating,
and deleting posts, comments, and pages, enabling the creation of custom
import/export tools. For example, you can use API clients for Python,
Java, or Node.js to manage content programmatically.
-
Custom Import Scripts: Developers can write scripts (e.g., in
PHP or Python) to import content from other sources into Blogger via the
API, which involves parsing the source data and making POST requests to
Blogger API endpoints.
For detailed API documentation, refer to the Blogger API Developer
site.
REST
The Blogger API is a RESTful interface provided by Google that allows
developers to integrate Blogger content and functionality into their own
applications. It enables programmatic access to resources such as blogs,
posts, comments, pages, and users via HTTP requests and JSON.
Key Features and Concepts
-
Resources: The API revolves around five core resource
types:
-
Blogs: The central container for all content and metadata.
- Posts: The primary published content items, meant to be
timely.
- Comments: User reactions to specific posts.
- Pages: Static content (e.g., about me, contact info).
- Users: Represents a non-anonymous person interacting with
Blogger, as an author, admin, or reader.
-
Operations: Developers can perform various operations on these
resources, including list,
get,
insert (create),
update,
patch, and
delete.
-
Authentication:
-
Public Data: Requests for public data (e.g., retrieving a
public blog post) only require an API key.
-
Private Data: Operations involving private user data (e.g.,
creating a post, editing a comment) must be authorised using OAuth 2.0
tokens.
-
API Version: The latest recommended version is Blogger API v3.
Support for the older v2.0 API ended on September 30, 2024, so
applications must be updated to continue functioning.
How to Access the API
Google recommends using their client libraries, which handle much of the
authorisation and request/response processing for you. Libraries are
available for a variety of programming languages:
-
Go
-
Java (get started with the Java client library)
-
JavaScript
-
.NET (install the Google APIs NuGet package)
-
Node.js
-
PHP
-
Python (install the client library using
pip install google-api-python-client)
-
Ruby
Alternatively, you can interact with the API directly using RESTful HTTP
requests. The Google APIs Explorer tool lets you test API calls in your
browser.
-
Pipi API Engine (api) using CFML
- BoxLang API using BX
For full documentation and developer guides, visit the official Blogger
API documentation site on Google for Developers.
Older Data API (v1/v2) Format: Atom XML
The previous versions of the Blogger API relied heavily on the
Atom Publishing Protocol (AtomPub) and
Google Data API feeds for managing blog content. The API used
standard HTTP methods (GET, POST, PUT, DELETE) to transport Atom-formatted
XML payloads.
Important: Support for the v2.0 Google Data API ended on September
30th, 2024, so applications must use the latest version to continue
functioning.
Exporting and Accessing Feeds via XML
Blogger still uses Atom XML for blog syndication and content
backup:
-
Public Blog Feed: Every Blogger blog has a public Atom feed,
typically at an address like
yourblogname.blogspot.com/feeds/posts/default
or://yourblogname.blogspot.com.
-
Content Backup: Users can back up their blog's posts and
comments as a single .xml file from the Blogger dashboard.
- Sign in to Blogger.
- Select your blog.
-
Go to Settings > Manage Blog.
-
Click Back up content and Download XML file.
-
This downloaded file is in a specific Atom format for import and
export.
REST in the Blogger API
The supported Blogger operations map directly to REST HTTP verbs, as
described in Blogger API operations.
The specific format for Blogger API URIs are:
-
https://www.googleapis.com/blogger/v3/users/userId
-
https://www.googleapis.com/blogger/v3/users/self
-
https://www.googleapis.com/blogger/v3/users/userId/blogs
-
https://www.googleapis.com/blogger/v3/users/self/blogs
-
https://www.googleapis.com/blogger/v3/blogs/blogId
-
https://www.googleapis.com/blogger/v3/blogs/byurl
-
https://www.googleapis.com/blogger/v3/blogs/blogId/posts
-
https://www.googleapis.com/blogger/v3/blogs/blogId/posts/bypath
-
https://www.googleapis.com/blogger/v3/blogs/blogId/posts/search
-
https://www.googleapis.com/blogger/v3/blogs/blogId/posts/postId
-
https://www.googleapis.com/blogger/v3/blogs/blogId/posts/postId/comments
-
https://www.googleapis.com/blogger/v3/blogs/blogId/posts/postId/comments/commentId
-
https://www.googleapis.com/blogger/v3/blogs/blogId/pages
-
https://www.googleapis.com/blogger/v3/blogs/blogId/pages/pageId
The full explanation of the URIs used and the results for each supported
operation in the API is summarised in the Blogger API Reference
document.
Examples
List the blogs that the authenticated user has access rights to:
-
GET
https://www.googleapis.com/blogger/v3/users/self/blogs?key=YOUR-API-KEY
Get the posts on the code.blogger.com blog, which has blog ID
3213900:
-
GET
https://www.googleapis.com/blogger/v3/blogs/3213900?key=YOUR-API-KEY
REST from JavaScript
You can invoke the Blogger API from JavaScript using the callback query
parameter and a callback function. When the browser loads the script, the
callback function is executed, and the response is passed to it. This
approach allows you to write rich applications that display Blogger data
without requiring server-side code.
The following example retrieves a post from the code.blogger.com blog,
after you replace YOUR-API-KEY with your API key.
<html>
<head>
<title>Blogger API Example</title>
</head>
<body>
<div id="content"></div>
<script>
function handleResponse(response) {
document.getElementById("content").innerHTML
+= "<h1>" + response.title + "</h1>" + response.content;
}
</script>
<script
src="https://www.googleapis.com/blogger/v3/blogs/3213900/posts/8398240586497962757?callback=handleResponse&key=YOUR-API-KEY"></script>
</body>
</html>
Data format
JSON (JavaScript Object Notation) is a common, language-independent data
format that provides a simple text representation of arbitrary data
structures. For more information, see json.org.
Blogger API operations
You can invoke a number of different methods on collections and resources
in the Blogger API, as described in the following table.
| Operation |
Description |
REST HTTP mappings |
| list |
Lists all resources within a collection.
|
GET on a collection URI.
|
| get |
Gets a specific resource.
|
GET on a resource URI.
|
| getByUrl |
Gets a resource, looking it up by URL.
|
GET with the URL passed in as a parameter.
|
| getByPath |
Gets a resource by looking it up by its path.
|
GET with the Path passed in as a parameter.
|
| listByUser |
Lists resources owned by a User.
|
GET on a user owned collection.
|
| search |
Search for resources, based on a query parameter.
|
GET on a Search URL, with the query passed in as a parameter.
|
| insert |
Create a resource in a collection.
|
POST on a collection URI.
|
| delete |
Deletes a resource. |
DELETE on a resource URI.
|
| patch |
Update a resource, using Patch semantics.
|
PATCH on a resource URI.
|
| update |
Update a resource. |
PUT on a resource URI.
|
The table below shows which methods are supported by each resource type. All
list and get operations on private blogs require authentication.
| Resource Type |
Supported Methods
|
|
list
|
get
|
getByUrl
|
getByPath
|
listByUser
|
search
|
insert
|
delete
|
patch
|
update
|
| Blogs |
N |
Y |
Y |
N |
Y |
N |
N |
N |
N |
N |
| Posts |
Y |
Y |
N |
Y |
N |
Y |
Y |
Y |
Y |
Y |
| Comments |
Y |
Y |
N |
N |
N |
N |
N |
N |
N |
N |
| Pages |
Y |
Y |
N |
N |
N |
N |
N |
N |
N |
N |
| Users |
N |
Y |
N |
N |
N |
N |
N |
N |
N |
N |
