---
title: How to publish blog posts to Webflow CMS with the Data API
description: Publish blog posts to a Webflow CMS collection with the Data API v2: token scopes, field mapping, drafts versus live items, images, rate limits and scheduling.
canonical: https://www.postbing.com/blog/how-to-publish-blog-posts-to-webflow-cms
published: 2026-11-16
updated: 2026-11-16
author: The Postbing Team
---

# How to publish blog posts to Webflow CMS with the Data API

To publish blog posts to Webflow CMS automatically, create a site API token with the `cms:read` and `cms:write` scopes, map your article fields to the blog collection's fields, and send each post to the Webflow Data API v2: either as a staged draft that you publish later, or as a live item that appears on the site at once. The API cannot schedule items, so scheduling has to live in your own code or tool.

Last updated: November 16, 2026

## The three routes into a Webflow blog

You can get posts into a Webflow collection by hand, with your own script against the Data API, or through a connector that does the API work for you. This guide covers the API route step by step, because every automated option runs on it.

| Route | Who it suits | What you maintain |
|---|---|---|
| Manual entry in the Webflow Editor | A few posts a month, non-technical team | Nothing, but every post is copy and paste |
| Your own script on the Data API v2 | Developers with a custom collection or workflow | Code, token, error handling, scheduling |
| A connector (for example Postbing) | Teams that want planning, writing and publishing together | Field mapping and review settings |

For the wider choice between platforms and automation styles, start with the [auto publishing guide](/blog/how-to-auto-publish-blog-posts).

## Step 1: Prepare the blog collection

Before writing any code, decide which collection fields an automated post will fill. Webflow requires every item to have a `name` and a `slug`; everything else depends on your collection's schema.

A typical blog collection and the API field types behind it:

| Collection field | Webflow field type | Value the API expects |
|---|---|---|
| Name (title) | Plain Text | String, required |
| Slug | Plain Text (slug) | String, required, unique in the collection |
| Post body | Rich Text | HTML string |
| Summary | Plain Text | String |
| Main image | Image | `{ "url": "...", "alt": "..." }` |
| Published on | Date/Time | ISO 8601 string |
| Category | Reference | Item ID of a category item |
| Featured | Switch | true or false |
| Topic | Option | Option ID, not the label text |

Two field types catch people out. Option fields need the option's ID, which you get from the collection details endpoint, not the label you see in the Designer. Reference and Multi-Reference fields need item IDs, so you must create or look up the category item first.

Rich Text has one documented limit worth knowing before you migrate technical posts: Webflow's field type reference says "The API doesn't currently support code blocks in Rich Text fields. Passing code blocks will result in an empty string."

## Step 2: Create a site API token

Site tokens are created per site, and only site administrators can create one. In Webflow, open the site's settings, go to **Apps & integrations**, find **API access**, choose **Generate API token**, name it and pick its scopes.

For blog publishing you need at least `cms:read` (to list collections and read the schema) and `cms:write` (to create, update and publish items). Add `sites:write` only if your code will trigger a full site publish. Each site can have up to 5 tokens, and Webflow says tokens "expire after 365 consecutive days of inactivity", so a blog that goes quiet for a year needs a fresh token.

Send the token as `Authorization: Bearer <token>` on every request, and keep it on the server, never in front-end code.

## Step 3: Find the collection and its field slugs

List the site's collections with `GET  then fetch the blog collection's details to read each field's slug and type. Your code should map to these slugs, not to the display names, because display names can be edited in the Designer without changing the slug.

Store the collection ID and the option and reference IDs you need in configuration, and re-read the schema when a post fails with a validation error. Someone renaming or deleting a field is the most common reason a working integration suddenly breaks.

## Step 4: Create the item as a draft or as live

This is the decision that matters most. Webflow's CMS has two states: **staged** ("Draft content that can be previewed but isn't visible on the live site") and **live** ("Content that's published and visible on your site").

- **Draft first:** create the item with the Create Items endpoint (`POST /v2/collections/{collection_id}/items/insert`), let an editor review it in Webflow, then publish it with `POST /v2/collections/{collection_id}/items/publish`. Publishing "automatically sets `isDraft` to `false`".
- **Straight to live:** create it with `POST /v2/collections/{collection_id}/items/live`, which creates items "that will be immediately published to the live site", without a full site publish.

Always send `isDraft` explicitly. Webflow's own pages disagree: the create items guide says items are created as drafts "unless the request sets `isDraft: false`", while the endpoint reference lists `isDraft` as defaulting to false. A staged item with `isDraft: false` that has never been published will go live "on the next site-wide publish", which can surprise an editor who publishes the site for an unrelated change.

A minimal draft request body looks like this:

```json
{
  "isDraft": true,
  "isArchived": false,
  "fieldData": {
    "name": "How to choose a standing desk",
    "slug": "how-to-choose-a-standing-desk",
    "post-body": "<p>Pick a desk whose height range fits...</p>",
    "main-image": { "url": "https://cdn.example.com/desk.jpg", "alt": "Standing desk at full height" }
  }
}
```

Field slugs like `post-body` are examples; use the slugs from your own collection. Whether you should review before publishing at all is covered in [draft first vs autopublish](/blog/draft-first-vs-autopublish).

## Step 5: Handle images

Image fields take a public URL, and Webflow uploads the file from there. Its field reference says images "must be hosted on a publicly accessible URL to be uploaded via the API" and the maximum file size "is 4MB". Resize large images before sending, and do not use signed URLs that expire before Webflow fetches them.

The `skipInvalidFiles` query parameter defaults to true, so an invalid image is skipped and the item is still created. Set it to false if you would rather the request fail than publish a post without its main image.

## Step 6: Respect rate limits and handle errors

Webflow applies rate limits per API key. Its rate limit reference lists 60 requests per minute on Starter and Basic, 120 on CMS, eCommerce and Business, and custom limits on Enterprise; those plan names are older than the current pricing page, so check your plan. A full site publish is limited to "one successful publish per minute".

Practical rules for a blog integration:

1. On a 429 response, wait for the `Retry-After` value before retrying.
2. Batch where you can: the create endpoints accept up to 100 items per request.
3. Do not publish the whole site after every post; publish the items instead.
4. On a validation error, log the field and stop rather than retrying the same bad payload.

## Step 7: Schedule posts outside Webflow

The Data API cannot schedule items. Webflow's publishing guide says scheduled content "can not be controlled by the CMS API". The Designer and Editor can schedule CMS items, but that is a manual action, and the pricing page shows scheduled publishing is not included on the Starter and Basic site plans (checked 16 November 2026).

So an automated blog keeps its own calendar: a cron job, queue or tool decides when a post is due and calls the create or publish endpoint at that time. Set your "Published on" date field yourself if your template displays it.

## Updating and removing posts

Store the Webflow item ID next to each post in your own system so updates go to the same item and the URL never changes. To take a post down, unpublish it: Webflow says this "doesn't delete the item from the CMS; it unpublishes it and sets its `isDraft` property to `true`". Archiving with `isArchived: true` also removes it from the live site, at the next full site publish. Note that "Setting `isDraft: true` doesn't unpublish an item" on its own.

## Plan limits to check first

The number of items a collection can hold depends on your Webflow plan. As of November 2026, the Webflow pricing page lists 50 CMS items on the free Starter plan, no CMS on Basic, and 20,000 items on Premium. A daily publishing schedule fills a Starter site within two months, so check the plan before you automate.

## Using Postbing instead of your own script

If you would rather not maintain the code, Postbing connects to Webflow through the same Data API v2, maps its article fields to your collection's fields, and publishes as a draft or live item depending on the publish mode you choose (draft, approval or auto). It plans and writes the articles too. The connector setup screens are walked through in [Webflow blog automation](/blog/webflow-blog-automation). For fields the connector does not map, a [signed webhook](/blog/publish-blog-posts-with-a-webhook) to your own endpoint gives you full control. Plans and limits are on the [pricing page](/pricing).

## FAQ

### Can the Webflow API schedule a blog post for later?
No. Webflow's publishing guide says scheduling "can not be controlled by the CMS API". Keep the schedule in your own code or tool and call the create or publish endpoint when the post is due.

### What is the difference between a staged and a live Webflow item?
A staged item is draft content you can preview but that is not on the live site. A live item is published and visible. The `/items/live` endpoint creates items that go live immediately, while staged items need the publish items endpoint or a site publish.

### Which API scopes does a Webflow blog integration need?
At least `cms:read` and `cms:write`. Add `sites:write` only if your code triggers a full site publish.

### Why did my Webflow post appear without its image?
The image URL was probably not public, the file was over 4MB, or it was skipped because `skipInvalidFiles` defaults to true. Host the image at a public URL, keep it under 4MB, and set `skipInvalidFiles` to false if you want the request to fail instead.

### How many blog posts can a Webflow site hold?
It depends on the plan. As of November 2026 the Webflow pricing page lists 50 CMS items on Starter and 20,000 on Premium, with no CMS on Basic.

## Sources

- Webflow developer docs, working with the CMS: create items, publishing, staged and live states, scheduling not controllable by the CMS API, accessed 16 November 2026
- Webflow developer docs, API reference: list collections, create item, create live item, publish items, isDraft and isArchived, skipInvalidFiles, accessed 16 November 2026
- Webflow developer docs, field types and item values: field types, Rich Text code block limit, image URL and 4MB rule, accessed 16 November 2026
- Webflow developer docs, site token authentication and scopes: who can create tokens, 5 per site, 365 day inactivity expiry, accessed 16 November 2026
- Webflow developer docs, rate limits: requests per minute by plan, per key, one site publish per minute, accessed 16 November 2026
- Webflow pricing page: CMS items per site plan and scheduled publishing availability, checked 16 November 2026
- Postbing product documentation, checked 16 November 2026: Webflow connector uses Data API v2 with field mapping, publish or draft, publish modes

## Related reading

- [How to auto publish blog posts: the full guide](/blog/how-to-auto-publish-blog-posts)
- [Webflow blog automation with Postbing](/blog/webflow-blog-automation)
- [Publish blog posts with a webhook](/blog/publish-blog-posts-with-a-webhook)
- [Draft first vs autopublish](/blog/draft-first-vs-autopublish)
