canonical: https://jentic.com/apis/blogger.googleapis.com/blogger

# Google Blogger API

The Blogger API manages blogs, posts, pages, and comments on Google's Blogger platform. It retrieves a blog by id or by URL, lists the blogs a user owns, and reports page-view statistics. It lists, retrieves, publishes, and reverts posts, searches a blog's posts, and fetches a post by its path. It manages the static pages attached to a blog and moderates comments, approving them, marking them as spam, or removing their content. Access runs over OAuth2, so an agent acts on the blogs the authorising Google account can reach.

## For AI agents

Manage Google Blogger blogs, posts, pages, and comments: publish and revert posts, search a blog, moderate comments, and read page-view stats over OAuth2.

## Scope

Does not handle blog theme design, ad monetisation, or Google account management. Use for Blogger post, page, and comment operations only.

## Capabilities

- Retrieve a blog by id or by its public URL and list a user's blogs
- List, publish, and revert posts on a blog
- Search a blog's posts and fetch a post by its path
- Manage the static pages attached to a blog
- Moderate comments: approve, mark as spam, or remove content
- Report page-view statistics for a blog

## Use cases

### AI agent blog publishing assistant

A content agent needs to draft and publish posts to a Blogger blog without a person opening the dashboard. Through Jentic the agent lists the target blog, publishes a prepared post, and can revert it to draft if a review flags an issue. Because the OAuth2 token is scoped to the authorising account, the agent only touches blogs that account owns.

Example prompt: Search Jentic for 'publish a Blogger post', call GET `/v3/users/{userId}/blogs` to find the blog id, then POST `/v3/blogs/{blogId}/posts` to publish the post.

### Comment moderation

A community workflow needs to keep a blog's comments clean. The comment operations list a post's comments and let an agent approve legitimate ones, mark spam, or remove content that violates policy. This lets a moderation agent triage a backlog and keep only vetted comments visible.

Example prompt: Call GET `/v3/blogs/{blogId}/posts/{postId}/comments` to list comments, then POST `/v3/blogs/{blogId}/posts/{postId}/comments/{commentId}/spam` on the ones that are spam.

### Content search and repurposing

A repurposing agent needs to find existing posts on a topic before writing something new. The post-search and get-by-path operations locate matching posts and pull their full content, so the agent can summarise, cross-link, or refresh older material instead of duplicating it.

Example prompt: Call GET `/v3/blogs/{blogId}/posts/search` with the query, then GET `/v3/blogs/{blogId}/posts/bypath` to pull the full body of a matching post.

### Blog traffic reporting

A reporting agent needs to fold Blogger traffic into a wider content dashboard. The page-views operation returns view counts for a blog, so the agent can pull the numbers on a schedule and report trends alongside other channels without a person exporting them by hand.

Example prompt: Call GET `/v3/blogs/{blogId}/pageviews` to read the blog's view statistics and pass them into the reporting pipeline.

## Key endpoints

| Method | Path | Description |
| --- | --- | --- |
| GET | `/v3/blogs/{blogId}` | Retrieve a blog by id |
| GET | `/v3/blogs/byurl` | Retrieve a blog by its public URL |
| GET | `/v3/blogs/{blogId}/posts` | List posts on a blog |
| POST | `/v3/blogs/{blogId}/posts` | Publish a post to a blog |
| GET | `/v3/blogs/{blogId}/posts/search` | Search a blog's posts |
| POST | `/v3/blogs/{blogId}/pages` | Add a static page to a blog |
| GET | `/v3/blogs/{blogId}/posts/{postId}/comments` | List a post's comments |
| POST | `/v3/blogs/{blogId}/posts/{postId}/comments/{commentId}/approve` | Approve a comment |

## Why Jentic

- **Setup:** Wiring the Blogger API by hand means registering an OAuth2 client, running the consent flow, and refreshing tokens yourself before the first post goes out. Through Jentic you install once, authorise your Google account, and import it from the API Directory, and your agent calls it without you writing the OAuth plumbing.
- **Permission scoping:** The Blogger API exposes read, publish, and moderation operations, so a rule bounds which of them the agent may call: searching and reading posts without the publish, revert, or comment-removal operations unless you add them. You choose the allowed set, so the agent only runs the operations you pick.
- **Credential handling:** You authorise your Google account once and Jentic holds the OAuth2 token server-side, so it never sits in the agent's prompt or context; the agent calls the Blogger operations and the token is attached out of band.
- **Discovery method:** Agents search Jentic by intent such as 'publish a Blogger post' or 'moderate a comment', and Jentic returns the matching Blogger operation with its input schema so the agent calls the right endpoint without reading the reference docs.

## Related APIs

- **Ghost** — Ghost is a publishing platform whose Admin API manages posts and pages as an alternative to Blogger
- **Contentful** — Contentful is a headless CMS for structured content across many front ends
- **DEV** — The DEV API publishes and manages articles on the DEV community platform

## FAQ

### Is there a Blogger API MCP server?

You don't need an MCP server to give your agent the Blogger API. Jentic connects it directly from the API Directory: import it, authorise your Google account once, and your agent calls the post, page, and comment operations on demand without loading another server's tool definitions into its context.

### What authentication does the Blogger API use?

The Blogger API authenticates with OAuth2: the agent acts on behalf of the Google account that granted access, and the token determines which blogs it can reach. When you connect it through Jentic, you authorise once and the token is stored server-side, so it stays out of the agent's prompt while the agent still makes the calls.

### Can I publish and revert posts through the Blogger API?

Yes. POST `/v3/blogs/{blogId}/posts` publishes a post to a blog and POST `/v3/blogs/{blogId}/posts/{postId}/revert` moves a published post back to draft, so an agent can push content live and pull it back if a review flags a problem.

### What are the rate limits for the Blogger API?

The OpenAPI spec does not state rate limits for the Blogger API; Google enforces per-project quotas on its APIs. Batch reads where you can and check the Google API console for your project's quota, which the spec does not carry.

### How do I moderate comments with the Blogger API through Jentic?

Search Jentic for 'moderate Blogger comments', load the matching operations, and call approve, spam, or remove-content on a comment id. To run it on your own infrastructure, install Jentic One from its GitHub repo.

### Can I limit what my agent is allowed to do with the Blogger API?

Yes. Because Jentic One is self-hosted, you decide which operations the agent may call: you might allow reading and searching posts with GET `/v3/blogs/{blogId}/posts` while withholding publish, revert, and comment-removal, and every call the agent makes is logged.