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
npx skills add AceDataCloud/Skills --skill blogger -a claude-codeWhat 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
12345using this HTML content.
How to install blogger
1Skills CLI (Vercel)
npx skills add AceDataCloud/Skills --skill blogger -a claude-code2Manually: put the files in place
~/.claude/skills/blogger/SKILL.mdCopy the whole skill folder; for one project use .claude/skills/blogger/
1Skills CLI (Vercel)
npx skills add AceDataCloud/Skills --skill blogger -a codex2Manually: put the files in place
.agents/skills/blogger/SKILL.mdFor all projects use ~/.agents/skills/
1Skills CLI (Vercel)
npx skills add AceDataCloud/Skills --skill blogger -a cursor2Manually: put the files in place
.cursor/skills/blogger/SKILL.mdCursor also reads .agents/skills/ and .claude/skills/
1GitHub CLI
gh skill install AceDataCloud/Skills skills/blogger2Manually: put the files in place
.github/skills/blogger/SKILL.md1Skills CLI (Vercel)
npx skills add AceDataCloud/Skills --skill blogger -a gemini-cli2Platform CLI
gemini skills install https://github.com/AceDataCloud/Skills --path skills/bloggerManually: put the files in place
.devin/skills/blogger/SKILL.mdThe legacy .windsurf/skills/ path still works
Skills CLI (Vercel)
npx skills add AceDataCloud/Skills --skill blogger -a opencodeClaude.ai
Zip the folder and upload it in Settings → Capabilities → Skills
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