---
title: Blog webhook publishing: send posts to any CMS with a signed POST
description: How webhook publishing works for a blog: the JSON payload, verifying an HMAC SHA-256 signature, retries, duplicates, and recipes for Wix, Framer and Next.js.
canonical: https://www.postbing.com/blog/publish-blog-posts-with-a-webhook
published: 2026-11-16
updated: 2026-11-16
author: The Postbing Team
---

# Blog webhook publishing: send posts to any CMS with a signed POST

Webhook publishing means the writing tool sends each finished article to a URL you own as a signed JSON POST, and your code creates or updates the post in your CMS. It is the route for sites with no native connector: Wix, Framer, a Next.js or Astro site, or a custom CMS. You write one small endpoint that checks the signature, upserts the post and returns its URL.

Last updated: November 16, 2026

## When should you publish blog posts with a webhook?

Use a webhook when your site has no ready-made connector, or when you want full control over how a post is stored and rendered. If you run WordPress, Shopify, Webflow or Ghost, a native connector is less work, because someone else already wrote the code that talks to that CMS.

The overview of every publishing route is in our [guide to automatic blog post publishing](/blog/how-to-auto-publish-blog-posts). For Postbing specifically, the routes look like this:

| Your site | Native Postbing connector | Route |
|---|---|---|
| WordPress, Shopify, Webflow, Ghost, Notion | Yes | Use the connector |
| Wix | No | Webhook recipe that calls the Wix Blog API |
| Framer | No | Webhook recipe that uses Framer's server API (open beta) |
| Next.js, Astro, Remix, static sites | No | Webhook into your own route handler or build pipeline |
| Zapier, Make, n8n | No native app | Webhook into a "catch hook" trigger |
| No blog yet | Not needed | Postbing hosted blog |

The tradeoff is ownership. A webhook gives you control over storage, templates and URLs, but you also own the code, its uptime and its bugs.

## What does a blog webhook payload contain?

A good payload carries everything needed to render the post without a second API call: title, slug, the body in HTML and markdown, meta tags, FAQ, structured data and images. Postbing sends version 2 of its payload with the shape below (trimmed for length).

```json
{
  "event": "article.publish",
  "version": 2,
  "id": "<delivery uuid>",
  "created_at": "2026-11-16T09:00:00Z",
  "idempotency_key": "...",
  "mode": "publish",
  "article": {
    "id": null,
    "postbing_id": "...",
    "type": "article",
    "title": "How to choose a wood stove for a small cabin",
    "slug": "choose-wood-stove-small-cabin",
    "html": "<h2>...</h2><p>...</p>",
    "markdown": "## ...",
    "excerpt": "...",
    "meta_title": "...",
    "meta_description": "...",
    "faqs": [],
    "schema_jsonld": "...",
    "tags": ["wood stoves"],
    "categories": ["Buying guides"],
    "language": "en",
    "scheduled_date": "2026-11-16",
    "featured_image": {"url": "...", "alt": "..."},
    "images": [{"url": "...", "alt": "...", "kind": "featured"}]
  }
}
```

The events you need to handle:

| Event | What your endpoint should do |
|---|---|
| `article.publish` | Create the post, or update it if the `postbing_id` already exists |
| `article.update` | Overwrite the existing post at the same URL |
| `article.unpublish` | Hide or delete the post |
| `page.publish` and `page.update` | Same as above for standalone pages, such as service area pages |
| `ping` | Return 200. Sent by the "Test connection" button |

`article.id` is your own ID for the post, echoed back once you have returned one (it is `null` on the first delivery). If you never return an ID, later edits arrive as `article.publish` again rather than `article.update`, which is one more reason to upsert on `postbing_id`.

Pick one body field and stick to it. If your CMS takes HTML, use `html`, which already includes the JSON-LD block. If your site renders markdown (many Next.js and Astro blogs do), use `markdown` and render `schema_jsonld` yourself in the page head.

## How do you verify the webhook signature?

Recompute the HMAC SHA-256 of the exact bytes you received, using your shared secret, and compare it to the signature header in constant time. Do this before you parse the JSON, because parsing and re-serialising changes the bytes and breaks the check.

Postbing signs `<timestamp>.<raw body>` with your secret and sends three headers you need:

- `X-Postbing-Timestamp`: Unix seconds when the delivery was signed.
- `X-Postbing-Signature`: `v1=<hex>`. For 24 hours after you rotate the secret it carries two comma-separated values, one per secret, so accept either.
- `Idempotency-Key`: the same value on every retry of the same delivery.

A minimal Python check (Flask), mirroring the snippet on the Postbing webhook docs:

```python
import hashlib, hmac, os, time
from flask import request

def verify(secret=os.environ["POSTBING_WEBHOOK_SECRET"]):
    ts = request.headers.get("X-Postbing-Timestamp", "")
    if not ts.isdigit() or abs(time.time()-int(ts)) > 300:
        return False
    body = request.get_data()  # raw bytes, before JSON parsing
    expected = hmac.new(secret.encode(), ts.encode() + b"." + body, hashlib.sha256).hexdigest()
    sigs = request.headers.get("X-Postbing-Signature", "").split(",")
    return any(hmac.compare_digest(s.strip().removeprefix("v1="), expected) for s in sigs)
```

Three details matter. The 300 second window rejects replayed requests. `hmac.compare_digest` (or `crypto.timingSafeEqual` in Node, `hash_equals` in PHP) avoids leaking the signature through timing. And in Express you must mount `express.raw()` on this route, or the body arrives already parsed.

## How should your endpoint respond?

Return any 2xx status within 30 seconds and, ideally, a JSON body with the post's ID and live URL, such as `{"id": "123", "url": " Postbing stores the ID and shows the URL as the live link in your dashboard.

How Postbing reads your response, from its code as of November 2026:

| Your response | What happens |
|---|---|
| Any 2xx | Delivered |
| 408, 409, 425, 429 or any 5xx | Retried later with a backoff |
| Other 4xx (400, 401, 404, 422) | Not retried. The article is marked failed and shows up in the daily "needs attention" email |
| No answer in 30 seconds | Treated as a timeout and retried |
| 3xx redirect | Not followed, so point the webhook at the final URL |

If your CMS is slow (some image uploads take longer than 30 seconds), accept the delivery, return 202, and do the work in a background job.

## How do you avoid duplicate posts on retries?

Upsert on a stable key instead of inserting. Store `article.postbing_id` alongside each post, and on every `publish` or `update` event look it up first: update if found, create if not.

Two headers help you tell deliveries apart. `Idempotency-Key` stays the same across retries of one delivery, so you can drop a retry you already processed. `X-Postbing-Delivery` is new on every attempt, which is useful for logs. A retry can arrive even when your first response was a success that got lost on the network, which is why the upsert matters more than the header check.

## How do you set it up in Postbing?

Setup takes a few minutes once your endpoint exists.

1. In Postbing, open the site's publishing settings and choose Webhook.
2. Paste the "Address that receives articles". It must be a public URL: addresses on private or internal networks are refused.
3. Copy the signing secret. It is shown once, so store it in your environment variables straight away.
4. Deploy your endpoint with the signature check.
5. Click "Test connection". Postbing sends a signed `ping` with `test: true`. Your endpoint should return 200.
6. Choose when articles go live: "Auto-publish", "Approve first" or "Drafts only". The tradeoffs are covered in [draft first vs autopublish](/blog/draft-first-vs-autopublish).
7. Set the cadence: publishing days, the time articles go live, the time zone and how many days ahead to write.

Note that with a webhook, "Drafts only" and "Approve first" happen inside Postbing. By the time your endpoint receives `article.publish`, the article is meant to go live. If you want a second review inside your own CMS, save it as a draft there and return the draft URL.

## Recipes for Wix, Framer, Next.js and automation tools

The Postbing webhook docs include tested starting points. Each one does the same three things: verify, upsert by `postbing_id`, return the URL.

| Target | What the recipe does |
|---|---|
| Wix | Converts the body to Wix's rich content format, creates and publishes a post through the Wix Blog API, replies with ID and URL |
| Framer | A small Node service that uses Framer's server API (open beta) to upsert a CMS item by `postbing_id`, then publishes the site |
| Next.js | A route handler that reads the raw body, verifies, upserts, calls `revalidatePath` and returns the URL |
| Zapier or Make | A raw catch hook, a code step for the signature, then field mapping. Updates find the existing item by `postbing_id` |
| Node, Python, PHP | Signature check snippets you can drop into any framework |

For a step by step Framer walkthrough, see [how to publish blog posts to Framer](/blog/how-to-publish-blog-posts-to-framer).

## What webhook publishing does not do for you

A webhook moves content. Everything that happens after the post lands is your code's job.

- **Sitemaps and indexing.** Postbing pings IndexNow only for its own hosted blog. On a webhook site, your sitemap must include new posts with an accurate lastmod, and IndexNow is up to you. Our [IndexNow explainer](/blog/what-is-indexnow) shows the request.
- **Rendering.** If your framework renders posts only in the browser, crawlers may see an empty page. Server render the article HTML.
- **Schema placement.** The `html` field includes JSON-LD. If you use `markdown`, you must add `schema_jsonld` to the page head yourself.
- **Images.** The featured image comes as a URL. Copy it into your own storage if you do not want to depend on an external host.

If maintaining an endpoint sounds like more than you want, the [hosted blog vs subfolder vs subdomain](/blog/hosted-blog-vs-subfolder-vs-subdomain) guide covers the no-code option.

## FAQ

### Do I need a developer to publish blog posts with a webhook?

For Wix, Framer or a custom site you need someone who can deploy a small endpoint; the signature check itself is about ten lines. Zapier or Make can replace the endpoint, but you still map fields and add a code step for the signature.

### Why does my signature check fail even with the right secret?

Almost always because the body was parsed before hashing. Hash the raw bytes exactly as received, include the timestamp and the dot before the body, and strip the `v1=` prefix before comparing.

### What happens if my endpoint is down when an article is due?

Timeouts, 429s and 5xx responses are retried with a backoff. If the retries run out, the article is marked failed and appears in the daily "needs attention" email, and you can publish it again once your endpoint is back.

### Can a webhook update a post that is already live?

Yes. When you edit a live article or a scheduled refresh rewrites it, Postbing sends `article.update` with the same `postbing_id`. Your endpoint should overwrite the existing post so the URL stays the same.

### Does Postbing have a native Zapier or Make app?

No. Zapier, Make and n8n work through the webhook by catching the raw POST. There is also no native Wix, Framer, HubSpot or Squarespace connector as of November 2026.

## Sources

- [Postbing webhook documentation](https://www.postbing.com/docs/webhooks): headers, signature scheme, recipes and test ping, accessed 16 November 2026
- Postbing product code (publishing connectors and job queue), checked 16 November 2026: payload version 2 fields, 30 second timeout, retryable status codes, upsert by `postbing_id`, IndexNow only on the hosted blog
- [RFC 2104, HMAC: Keyed-Hashing for Message Authentication](https://www.rfc-editor.org/rfc/rfc2104.txt): definition of HMAC, accessed 16 November 2026
- [Shopify developer docs, verify a webhook](https://shopify.dev/docs/apps/build/webhooks/verify-deliveries): an independent example of HMAC SHA-256 webhook verification on the raw body, accessed 16 November 2026

## Related reading

- [How to auto-publish blog posts: every route compared](/blog/how-to-auto-publish-blog-posts)
- [How to publish blog posts to Framer](/blog/how-to-publish-blog-posts-to-framer)
- [Draft first vs autopublish: which review flow fits](/blog/draft-first-vs-autopublish)
- [Hosted blog vs subfolder vs subdomain](/blog/hosted-blog-vs-subfolder-vs-subdomain)
- [Postbing webhook docs](/docs/webhooks)
