Skip to main content
skill CX Codex

blogger — Claude Code skill: publishing and setup

Use Blogger API v3 to publish posts, inspect blogs and entries, or update an existing post. The skill handles these tasks from Claude Code.

Apache-2.0 221 installs ★ 17 updated 2026-10-25

Install into Claude Code · Skills CLI (Vercel) All methods and platforms ↓
npx skills add AceDataCloud/Skills --skill blogger -a claude-code
Open on GitHub

What blogger does

The skill starts by fetching the account’s blogs to obtain a blogId, then uses curl and jq to call Blogger API v3. It can publish a post, list or read entries, and update an existing one. A publish request goes live unless the user explicitly asks for a draft. Afterward, the agent reports the URL returned by Blogger.

Requests need an OAuth token in $GOOGLE_BLOGGER_TOKEN, and the Blogger API must be enabled in the Google Cloud project behind the OAuth client. Post content must be HTML; raw Markdown appears as literal text. An expired token returns 401; an empty token can lead to 403, while a disabled API produces an accessNotConfigured error.

Install with npx skills add AceDataCloud/Skills --skill blogger -a claude-code. Without an OAuth connection, the skill cannot access the blog. Post listing supports pagination using nextPageToken.

What it helps with

  • publish a post to Blogger
  • find blogs owned by the connected account
  • read published posts
  • update an existing entry
  • convert Markdown content to HTML before posting

Example prompts for the agent

  • Publish this article to my Blogger blog as a live post.
  • List my blogs and show the latest published entries.
  • Update the post with ID 12345 using this HTML content.

How to install blogger

1Skills CLI (Vercel)

npx skills add AceDataCloud/Skills --skill blogger -a claude-code

2Manually: put the files in place

~/.claude/skills/blogger/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/blogger/

Step by step, with commands for each platform: How to install skills in Claude Code: five ways

Questions about blogger

How do I install blogger in Claude Code?

Run npx skills add AceDataCloud/Skills --skill blogger -a claude-code. The skill file is at ~/.claude/skills/blogger/SKILL.md.

What does the blogger skill do?

It uses Blogger API v3 to find account blogs, publish and read posts, and update existing entries. Posts go live when requested unless the user asks for a draft.

What does blogger need to publish a post?

It needs an OAuth token in $GOOGLE_BLOGGER_TOKEN, and Blogger API must be enabled in the OAuth client’s Google Cloud project. Post content must be HTML, so convert Markdown before sending it.

Source text

SKILL.md · Apache-2.0
---
name: blogger
description: Publish posts to your Blogger blog and read your blogs / posts via the Blogger API v3. Use when the user mentions Blogger, blogspot, publishing a post to their blog, listing their blogs, or updating an existing Blogger post.
when_to_use: |
  Trigger when the user wants to publish a post to their Blogger blog,
  list their blogs, list / read posts on a blog, or update an existing
  post. The connector grants the Blogger scope (read + write). When the
  user asks to "publish" / "post" / "发布" / "发出去", publish it LIVE
  (isDraft=false) directly — only stage a draft when the user explicitly
  asks for a draft or says they want to review it first.
connections: [google/blogger]
allowed_tools: [Bash]
license: Apache-2.0
metadata:
  author: acedatacloud
  version: "1.0"
---

Call the **Blogger API v3** with `curl + jq`. The user's OAuth bearer token is
in `$GOOGLE_BLOGGER_TOKEN`; every call needs
`Authorization: Bearer $GOOGLE_BLOGGER_TOKEN`. Base URL:
`https://www.googleapis.com/blogger/v3`.

Errors are `{"error": {"code": ..., "message": ...}}` — show them verbatim.
`401` → token expired, re-connect the Blogger connector.

**Always start by listing the user's blogs** to get a `blogId`:

```bash
curl -sS -H "Authorization: Bearer $GOOGLE_BLOGGER_TOKEN" \
  "https://www.googleapis.com/blogger/v3/users/self/blogs" \
  | jq '.items[] | {id, name, url}'
```

## Publish a post

When the user asks to publish / post / 发布 / 发出去, publish it **live**
with `?isDraft=false` (the default below) — do NOT silently save a draft
and stop. Only pass `?isDraft=true` when the user explicitly asks for a
draft or to review before going public. After publishing, always report
the returned live `url` back to the user.

```bash
BLOG_ID="1234567890"
jq -n --arg t "My title" --arg c "<p>HTML content of the post…</p>" \
  '{kind:"blogger#post", title:$t, content:$c, labels:["ai","video"]}' \
| curl -sS -X POST \
    "https://www.googleapis.com/blogger/v3/blogs/$BLOG_ID/posts/?isDraft=false" \
    -H "Authorization: Bearer $GOOGLE_BLOGGER_TOKEN" \
    -H "Content-Type: application/json" \
    -d @- \
| jq '{id, url, status}'
```

`content` is **HTML** (not Markdown) — convert Markdown to HTML first
(e.g. with `pandoc -f markdown -t html` or a simple converter).

- Publish a staged draft: `POST /blogs/{blogId}/posts/{postId}/publish`.
- Update a post: `PUT /blogs/{blogId}/posts/{postId}` with the same shape.

## List / read posts

```bash
curl -sS -H "Authorization: Bearer $GOOGLE_BLOGGER_TOKEN" \
  "https://www.googleapis.com/blogger/v3/blogs/$BLOG_ID/posts?maxResults=20&status=live" \
  | jq '.items[] | {id, title, url, published}'
```

## Gotchas

- **Enable the Blogger API** on the Google Cloud project backing the OAuth
  client, or calls 403 with `accessNotConfigured`.
- A `403 "Method doesn't allow unregistered callers"` means the request
  carried no token (empty `$GOOGLE_BLOGGER_TOKEN`) — ask the user to
  (re)connect the Blogger connector, don't blame their Google Cloud setup.
- An empty `{"kind":"blogger#blogList"}` (no `items`) means the connected
  Google account owns no blog — tell the user to create one at blogger.com
  or reconnect with the account that has the blog.
- `content` must be HTML; passing raw Markdown will render literally.
- Paginate with `&pageToken=$PAGE_TOKEN` from the previous `.nextPageToken`.


## Record the output

After you successfully publish and obtain the live result URL, call the built-in
`publish_artifact` tool ONCE so the user can track this deliverable in **My Outputs**:

```
publish_artifact(kind="article", channel="blogger", title="<title>", url="<the REAL returned URL>", status="delivered")
```

Use the real returned URL — never fabricate one. Call it once per published item,
only after delivery is confirmed; skip it (or use `status="failed"`) if publishing failed.
See `_shared/artifacts.md`.

© acedatacloud · Apache-2.0 · AceDataCloud/Skills

Similar skills

SKILL.md skills catalog →

From the same set67

The whole set →

Project sponsors

Companies that keep this analytics open