> For the complete documentation index, see [llms.txt](https://docs.coupler.io/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.coupler.io/sources/category/social-media/blogger.md).

# Blogger

Connect Blogger to Google Sheets, BigQuery, or AI tools via Coupler.io. Pull posts, comments, pages, and blog metadata automatically.

Blogger is Google's free blogging platform that lets individuals and organizations publish content, manage readers, and host static pages. It's one of the longest-running blogging tools on the web, used by hobbyists and content creators worldwide.

Connecting Blogger to Coupler.io lets you move your blog data into spreadsheets, databases, or AI tools — without manual exports or copy-pasting.

## Why connect Blogger to Coupler.io?

* **Centralize your content data** — pull posts, pages, comments, and user info into one place
* **Track engagement over time** — monitor comment activity and publication frequency across your blogs
* **Combine with other sources** — join Blogger data with analytics or social media metrics using Coupler.io's Append or Join transformations
* **Feed AI tools** — send post content and metadata to ChatGPT, Claude, Gemini, or other AI destinations for summarization, tagging, or analysis

## Prerequisites

* A Google account with access to at least one Blogger blog
* A **Google Cloud API key** with the Blogger API v3 enabled
* Your **Blog ID** (found in your Blogger dashboard URL or blog settings)

{% hint style="info" %}
To create an API key, go to the [Google Cloud Console](https://console.cloud.google.com/), enable the Blogger API v3 under APIs & Services, and generate a new API key under Credentials.
{% endhint %}

## Quick start

{% hint style="success" %}
If you want a broad view of your blog activity, start with the **Posts** entity — it includes titles, publication dates, labels, and engagement metadata all in one report.
{% endhint %}

{% stepper %}
{% step %}
**Create a new data flow in Coupler.io.** Log in to your Coupler.io account and click **Add data flow**. Search for and select **Blogger** as your source.
{% endstep %}

{% step %}
**Enter your API key and Blog ID.** Paste your Google Cloud API key into the API key field. Then enter your Blog ID — you can find this in your Blogger dashboard under Settings, or in the URL when you're managing your blog (it's the number after `blogID=`).
{% endstep %}

{% step %}
**Select an entity.** Choose what data you want to pull: Posts, Pages, Comments, Blogs, or Users.
{% endstep %}

{% step %}
**Choose a destination.** Pick where your data should go — Google Sheets, Excel, BigQuery, Looker Studio, or an AI destination like ChatGPT, Claude, Gemini, Cursor, Perplexity, or OpenClaw.
{% endstep %}

{% step %}
**Run your data flow.** Click **Run** to execute a manual sync and confirm your data loads correctly.
{% endstep %}
{% endstepper %}

## Available entities

| Entity       | What it contains                                                       |
| ------------ | ---------------------------------------------------------------------- |
| **Posts**    | Published post content, titles, dates, labels, and engagement metadata |
| **Pages**    | Static pages like About or Contact, with content and metadata          |
| **Comments** | Reader comments on posts, including author details and timestamps      |
| **Blogs**    | Blog-level metadata: name, description, URL, and settings              |
| **Users**    | Author and administrator profile information                           |

## Blogger data overview

Coupler.io pulls five types of data from Blogger, each corresponding to a different part of your blog. Here's a breakdown of what's available in each entity and the fields you can work with.

## Entities

| Entity       | Description                                                            |
| ------------ | ---------------------------------------------------------------------- |
| **Posts**    | Published blog posts with content, titles, dates, labels, and metadata |
| **Pages**    | Standalone static pages within a blog                                  |
| **Comments** | Reader comments attached to posts                                      |
| **Blogs**    | Top-level blog configuration and metadata                              |
| **Users**    | Profile data for blog authors and admins                               |

***

#### Posts fields

| Field                | Description                          |
| -------------------- | ------------------------------------ |
| `id`                 | Unique post identifier               |
| `title`              | Post title                           |
| `content`            | Full HTML content of the post        |
| `published`          | Publication date and time            |
| `updated`            | Date the post was last updated       |
| `url`                | Permalink to the post                |
| `labels`             | Tags/categories assigned to the post |
| `author.displayName` | Name of the post author              |
| `author.id`          | Author's Google user ID              |
| `blog.id`            | Blog the post belongs to             |
| `replies.totalItems` | Total number of comments on the post |
| `status`             | Post status (live, draft, scheduled) |

#### Pages fields

| Field                | Description                   |
| -------------------- | ----------------------------- |
| `id`                 | Unique page identifier        |
| `title`              | Page title                    |
| `content`            | Full HTML content of the page |
| `published`          | Publication date              |
| `updated`            | Last updated date             |
| `url`                | Permalink to the page         |
| `author.displayName` | Page author name              |
| `status`             | Page status (live or draft)   |

#### Comments fields

| Field                | Description                           |
| -------------------- | ------------------------------------- |
| `id`                 | Unique comment identifier             |
| `content`            | Text of the comment                   |
| `published`          | Date and time the comment was posted  |
| `updated`            | Date comment was last updated         |
| `author.displayName` | Commenter's display name              |
| `author.id`          | Commenter's Google user ID            |
| `post.id`            | ID of the post the comment belongs to |
| `blog.id`            | Blog the comment belongs to           |
| `status`             | Comment status (live, spam, pending)  |

#### Blogs fields

| Field              | Description                     |
| ------------------ | ------------------------------- |
| `id`               | Unique blog identifier          |
| `name`             | Blog display name               |
| `description`      | Blog description                |
| `url`              | Blog homepage URL               |
| `published`        | Date the blog was created       |
| `updated`          | Last activity date              |
| `posts.totalItems` | Total number of published posts |
| `pages.totalItems` | Total number of static pages    |

#### Users fields

| Field         | Description                            |
| ------------- | -------------------------------------- |
| `id`          | Google user ID                         |
| `displayName` | User's display name                    |
| `url`         | Link to the user's Google profile      |
| `blogs`       | List of blogs associated with the user |

***

## Common field combinations

* **Content audit:** Posts `title` + `published` + `labels` + `replies.totalItems` — see what topics get the most engagement
* **Comment moderation log:** Comments `content` + `author.displayName` + `published` + `status` — review recent or flagged comments
* **Blog health snapshot:** Blogs `posts.totalItems` + `pages.totalItems` + `updated` — quickly assess activity across multiple blogs

## Use cases by role

{% tabs %}
{% tab title="Content creators" %}

* Export all posts with labels and comment counts to understand which topics resonate most
* Track your publishing cadence by pulling `published` dates into a Google Sheets calendar
* Use the **Append** transformation to combine posts from multiple blogs into a single content inventory
  {% endtab %}

{% tab title="Marketers" %}

* Pull post metadata into Looker Studio to visualize publishing frequency and topic distribution
* Join Blogger post data with Google Analytics exports to connect content performance to traffic
* Send post titles and content to ChatGPT or Claude for automatic tagging, SEO summaries, or content repurposing
  {% endtab %}

{% tab title="Developers & agencies" %}

* Sync blog and post data into BigQuery for long-term archiving and trend analysis
* Use the Users and Blogs entities to audit multi-author or multi-blog setups
* Automate comment moderation reporting by exporting Comments with status filters into a shared spreadsheet
  {% endtab %}
  {% endtabs %}

## Platform-specific notes

* The Blogger API returns post content as raw HTML — you may need to clean this in your destination if you're analyzing text
* `replies.totalItems` in the Posts entity reflects the total comment count but does not include individual comment details — pull the **Comments** entity separately for that
* Blogger's API does not return draft posts by default; only published content is accessible via the standard API key flow
* If you manage multiple blogs, each blog requires its own Blog ID — use the **Append** transformation in Coupler.io to consolidate data from several blogs into one dataset

## Blogger common issues

### Connection issues

<details>

<summary>"Invalid API key" or authentication error on setup</summary>

This usually means the API key was entered incorrectly, or the Blogger API v3 hasn't been enabled in your Google Cloud project. Go to the [Google Cloud Console](https://console.cloud.google.com/), open **APIs & Services > Library**, search for "Blogger API v3", and make sure it's enabled. Then check that the API key you're using was created in the same project.

</details>

<details>

<summary>Data flow fails with a "Blog not found" error</summary>

Double-check your Blog ID. The Blog ID is a numeric string — it's not the same as your blog's URL slug or custom domain. You can find it in the Blogger dashboard under **Settings > Basic**, or in the URL of your Blogger admin panel (look for the number following `blogID=`).

</details>

### Missing data

<details>

<summary>Draft posts are not appearing in the Posts entity</summary>

The Blogger API only returns published posts via a standard API key. Draft, scheduled, and private posts are not accessible through this authentication method. If you need draft data, you would require OAuth-based access, which is not currently supported for this source.

</details>

<details>

<summary>Comments are missing or incomplete</summary>

Comments are pulled at the blog level, not per post. If you're seeing fewer comments than expected, check whether some comments have a `status` of `spam` or `pending` — these may be filtered by the API. Also confirm you're using the correct Blog ID, not a post ID.

</details>

<details>

<summary>Labels (tags) are empty for some posts</summary>

Labels are optional in Blogger — if a post was published without any labels assigned, the `labels` field will be empty. This is expected behavior and not a sync error.

</details>

### Permission errors

<details>

<summary>API key works but returns a 403 Forbidden error</summary>

Your API key may have HTTP referrer or IP restrictions applied in the Google Cloud Console. Go to **APIs & Services > Credentials**, click your API key, and check the **Application restrictions** section. For use with Coupler.io, set restrictions to "None" or add Coupler.io's IP range if you want to keep restrictions in place.

</details>

### Data discrepancies

<details>

<summary>Comment count in Posts doesn't match the Comments entity</summary>

The `replies.totalItems` field in the Posts entity is a snapshot count from the post metadata. The Comments entity pulls individual comment records and may reflect a slightly different number depending on comment status (live vs. spam vs. pending). Use the Comments entity for the most accurate and filterable count.

</details>

### Rate limits

<details>

<summary>Sync fails or returns partial data during large exports</summary>

The Blogger API has a default quota of 10,000 requests per day per project. If you're pulling data from a high-volume blog with thousands of posts and comments, you may hit this limit. You can request a quota increase in the Google Cloud Console under **APIs & Services > Quotas**. For large blogs, consider running individual entity syncs rather than all entities at once.

</details>

## Blogger FAQ

<details>

<summary>Can I pull data from multiple Blogger blogs in one data flow?</summary>

Each Blogger source connection is tied to a single Blog ID, so you'll need to add multiple sources within the same data flow — one per blog. Then use the **Append** transformation to merge all the data into a single output. This works well for combining posts or comments across several blogs into one reporting table.

</details>

<details>

<summary>Where do I find my Blog ID?</summary>

Your Blog ID is a long numeric string. You can find it in two places:

* In your **Blogger dashboard**, go to Settings > Basic — it's listed under "Blog ID"
* In the URL when you're in the Blogger admin panel: look for the number that appears after `blogID=` or as part of the path like `/blog/posts/XXXXXXXXXX`

Don't use your blog's public URL or Blogspot address — those won't work.

</details>

<details>

<summary>Why can't I see my draft or scheduled posts?</summary>

The Blogger API v3 only returns published posts when using an API key. Draft, scheduled, and private posts require OAuth-level access, which is not supported in the current Blogger source configuration. Only live, public posts will appear in your data flow.

</details>

<details>

<summary>How often can I refresh Blogger data?</summary>

You can schedule refreshes as frequently as your Coupler.io plan allows. However, the Blogger API has a default quota of 10,000 requests per day per Google Cloud project. If you're running frequent refreshes across multiple entities and multiple blogs, monitor your quota in the Google Cloud Console to avoid hitting the limit.

</details>

<details>

<summary>Can I use Blogger data with AI tools like ChatGPT or Claude?</summary>

Yes — Coupler.io supports AI destinations including ChatGPT, Claude, Gemini, Cursor, Perplexity, and OpenClaw. You can route your Blogger post content directly to these tools for tasks like summarization, content classification, SEO metadata generation, or drafting follow-up content. Keep in mind that post content arrives as raw HTML, so prompt your AI tool accordingly.

</details>

<details>

<summary>Can I join Posts with Comments in Coupler.io?</summary>

Yes. Add both Posts and Comments as separate sources in the same data flow, then use the **Join** transformation to connect them on the `post.id` field (from Comments) and `id` field (from Posts). This gives you a combined view of each post alongside its comments — useful for engagement analysis or moderation workflows.

</details>

<details>

<summary>The comment count in my Posts export doesn't match what I see in the Comments entity — why?</summary>

The `replies.totalItems` field in the Posts entity is a cached count from post metadata and includes all comment statuses (live, spam, pending). The Comments entity returns individual records and may differ slightly depending on which statuses the API exposes. For accurate, filterable comment data, rely on the Comments entity rather than the count field in Posts.

</details>

{% hint style="info" %}
For a full breakdown of available fields per entity, see the [Data Overview](#blogger-data-overview) page. For connection errors or missing data, check [Common Issues](#blogger-common-issues).
{% endhint %}


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation by asking a question.

Perform an HTTP GET request on the following URL with the `ask` and `goal` query parameters:

```
GET https://docs.coupler.io/sources/category/social-media/blogger.md?ask=<question>&goal=<user_goal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is what the user is ultimately trying to achieve, the reason they need the answer. Sharing it helps GitBook give you a better, more relevant answer. A goal is most helpful when it describes the outcome the user wants rather than restating the question. For example, with `ask=how do I create an API token`, a goal like `automate deployments from our CI pipeline` lets GitBook tailor the answer to that use case.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.
