How to Auto Publish Posts to Blogger Using Python and the Blogger API

Want to publish blog posts to Blogger automatically using Python — without ever opening the Blogger dashboard? In this step-by-step guide, you will learn how to use the Google Blogger API v3 with OAuth2 to programmatically create and publish posts from a Python script.

By the end of this tutorial, you will have two working scripts: get_blog_id.py to discover your Blog ID, and a production-ready publish_post.py that publishes posts directly to your Blogger blog.

✅ What You Need Before Starting

• A Google account with a Blogger blog already created
• Python 3.8+ installed on your system
• A Google Cloud project with the Blogger API enabled
• OAuth 2.0 credentials: Client ID and Client Secret
• A Google Refresh Token obtained from the OAuth flow

1 Install Required Python Packages

Open your terminal and install the necessary Google API client libraries and dotenv support:

pip install google-auth google-auth-oauthlib google-auth-httplib2 google-api-python-client python-dotenv

Here is what each package does:

2 Create Your .env File

Create a file named .env in your project folder. This file will store all your credentials securely, so they never appear directly in your Python code.

GOOGLE_CLIENT_ID=xxxxxxxxxxxxxxxx.apps.googleusercontent.com
GOOGLE_CLIENT_SECRET=GOCSPX-xxxxxxxxxxxxxxxxxxxx
GOOGLE_REFRESH_TOKEN=1//0xxxxxxxxxxxxxxxxxxxxxxxxxxxx
BLOGGER_BLOG_ID=1234567890123456789

echo ".env" >> .gitignore

3 Find Your Blogger Blog ID

Before you can publish posts, you need your Blog ID — a unique numeric identifier for your Blogger blog. You can find it in two ways.

Method 1: From the Blogger Dashboard

1. Open the Blogger Dashboard
2. Select your blog
3. Go to Settings → Basic
4. Copy the Blog ID shown on the page

Method 2: Using get_blog_id.py (Recommended)

Create a file named get_blog_id.py and paste the following code:

import os
from dotenv import load_dotenv
from google.oauth2.credentials import Credentials
from google.auth.transport.requests import Request
from googleapiclient.discovery import build

load_dotenv()

creds = Credentials(
    None,
    refresh_token=os.getenv("GOOGLE_REFRESH_TOKEN"),
    token_uri="https://oauth2.googleapis.com/token",
    client_id=os.getenv("GOOGLE_CLIENT_ID"),
    client_secret=os.getenv("GOOGLE_CLIENT_SECRET"),
)

creds.refresh(Request())

service = build("blogger", "v3", credentials=creds)

blogs = service.blogs().listByUser(userId="self").execute()

print("\nYour Blogs:\n")

for blog in blogs.get("items", []):
    print(f"Title: {blog['name']}")
    print(f"Blog ID: {blog['id']}")
    print(f"URL: {blog['url']}")
    print("-" * 50)

Run it with:

python get_blog_id.py

Expected output:

Your Blogs:

Title: My Blog
Blog ID: 1234567890123456789
URL: https://myblog.blogspot.com
--------------------------------------------------

Copy the Blog ID and add it to your .env file:

BLOGGER_BLOG_ID=1234567890123456789

4 Create publish_post.py

Now create the main script. This is a production-ready version of publish_post.py with:

• Environment variable validation with clear error messages
• Automatic token refresh using the stored refresh token
• Full error handling for API errors and network failures
• HTML content support for rich blog posts
• Optional draft mode — publish live or save as draft
• Clean success output with post URL and ID

Create a file named publish_post.py and paste the following:

import os
import sys
from dotenv import load_dotenv
from google.oauth2.credentials import Credentials
from google.auth.transport.requests import Request
from googleapiclient.discovery import build
from googleapiclient.errors import HttpError

# ------------------------------------------------------------------
# Load environment variables
# ------------------------------------------------------------------
load_dotenv()

CLIENT_ID = os.getenv("GOOGLE_CLIENT_ID")
CLIENT_SECRET = os.getenv("GOOGLE_CLIENT_SECRET")
REFRESH_TOKEN = os.getenv("GOOGLE_REFRESH_TOKEN")
BLOG_ID = os.getenv("BLOGGER_BLOG_ID")

# ------------------------------------------------------------------
# Validate configuration
# ------------------------------------------------------------------
required_vars = {
    "GOOGLE_CLIENT_ID": CLIENT_ID,
    "GOOGLE_CLIENT_SECRET": CLIENT_SECRET,
    "GOOGLE_REFRESH_TOKEN": REFRESH_TOKEN,
    "BLOGGER_BLOG_ID": BLOG_ID,
}

missing = [key for key, value in required_vars.items() if not value]

if missing:
    print("\n❌ Missing environment variables:")
    for item in missing:
        print(f"   - {item}")
    sys.exit(1)

# ------------------------------------------------------------------
# Create Google credentials using refresh token
# ------------------------------------------------------------------
try:
    creds = Credentials(
        token=None,
        refresh_token=REFRESH_TOKEN,
        token_uri="https://oauth2.googleapis.com/token",
        client_id=CLIENT_ID,
        client_secret=CLIENT_SECRET,
    )

    creds.refresh(Request())

except Exception as e:
    print(f"\n❌ Failed to authenticate with Google: {e}")
    sys.exit(1)

# ------------------------------------------------------------------
# Build Blogger API service
# ------------------------------------------------------------------
try:
    service = build(
        "blogger",
        "v3",
        credentials=creds,
        cache_discovery=False
    )

except Exception as e:
    print(f"\n❌ Failed to initialize Blogger API: {e}")
    sys.exit(1)

# ------------------------------------------------------------------
# Blog post content
# ------------------------------------------------------------------
TITLE = "My First Automated Blogger Post"

CONTENT = """
<h2>🚀 Blogger Automation Test</h2>

<p>Hello Blogger!</p>

<p>
This post was published automatically using Python,
Google OAuth, and the Blogger API.
</p>

<p>
If you can read this, your Blogger automation setup
is working successfully.
</p>

<hr>

<p><strong>Published via Python Script</strong></p>
"""

# Set to True if you want to create a draft instead of publishing
IS_DRAFT = False

post_body = {
    "title": TITLE,
    "content": CONTENT
}

# ------------------------------------------------------------------
# Publish post
# ------------------------------------------------------------------
try:
    response = service.posts().insert(
        blogId=BLOG_ID,
        body=post_body,
        isDraft=IS_DRAFT
    ).execute()

    print("\n✅ Post created successfully!")
    print("-" * 60)
    print(f"Title : {response.get('title')}")
    print(f"URL   : {response.get('url')}")
    print(f"ID    : {response.get('id')}")
    print("-" * 60)

except HttpError as e:
    print("\n❌ Blogger API Error")
    print(e)

except Exception as e:
    print(f"\n❌ Unexpected error: {e}")

5 Run the Script

Make sure your .env file contains all four required values, then run:

python publish_post.py

Expected output on success:

✅ Post created successfully!
------------------------------------------------------------
Title : My First Automated Blogger Post
URL   : https://yourblog.blogspot.com/2026/06/my-first-automated-blogger-post.html
ID    : 9876543210987654321
------------------------------------------------------------

🔄 How the Authentication Works

Understanding the token flow is important for debugging and scaling this automation.

1. Your .env file stores the Refresh Token permanently
2. When the script runs, it calls creds.refresh(Request())
3. Google's OAuth server exchanges the refresh token for a short-lived Access Token
4. The access token is used to authenticate all Blogger API requests
5. Access tokens expire after 1 hour — but the refresh token never expires (unless revoked)
6. The script can run again any time and will always get a fresh token automatically

🛠️ Troubleshooting Common Errors

📋 Complete .env Reference

Your final .env file should look like this:

GOOGLE_CLIENT_ID=123456789012-abcdefghijklmnop.apps.googleusercontent.com
GOOGLE_CLIENT_SECRET=GOCSPX-AbCdEfGhIjKlMnOpQrStUv
GOOGLE_REFRESH_TOKEN=1//0AbCdEfGhIjKlMnOpQrStUvWxYzAb
BLOGGER_BLOG_ID=1234567890123456789

🤖 Automate with GitHub Actions

Once your script works locally, you can run it automatically on a schedule using GitHub Actions — for free, without any server. The complete GitHub Actions workflow is already included in the autoblog-python repository for reference.

Create the file .github/workflows/publish.yml in your repository:

name: Auto Publish to Blogger

on:
  schedule:
    - cron: "0 6 * * *"   # Runs daily at 6:00 AM UTC
  workflow_dispatch:

jobs:
  publish:
    runs-on: ubuntu-latest

    steps:
      - uses: actions/checkout@v4

      - uses: actions/setup-python@v5
        with:
          python-version: "3.11"

      - run: pip install google-auth google-auth-oauthlib google-auth-httplib2 google-api-python-client python-dotenv

      - run: python publish_post.py
        env:
          GOOGLE_CLIENT_ID: ${{ secrets.GOOGLE_CLIENT_ID }}
          GOOGLE_CLIENT_SECRET: ${{ secrets.GOOGLE_CLIENT_SECRET }}
          GOOGLE_REFRESH_TOKEN: ${{ secrets.GOOGLE_REFRESH_TOKEN }}
          BLOGGER_BLOG_ID: ${{ secrets.BLOGGER_BLOG_ID }}

🎯 Customization Ideas