Skip to content

Custom destination

Publishing through a webhook

For teams whose site is code. The pipeline hands you a finished article and its structured data; where it lands is entirely up to your receiver.

No card · 30 credits on signup

Published to WebhooksLive
  • Body, headings and internal links
  • Meta title & description
  • JSON-LD structured data
  • Canonical URL & a named author
  • Featured image with alt text

Every article, formatted for Webhooks — nothing to paste.

Connecting Webhooks

Live in a few minutes.

  1. Step 1

    Stand up an endpoint that answers quickly

    Create a route that accepts a POST with a JSON body and returns a 2xx status within a couple of seconds.

  2. Step 2

    Register the URL and store the signing secret

    Point the project at the webhook destination and enter your endpoint URL, which must be HTTPS.

  3. Step 3

    Verify every request before you trust any of it

    Compute the signature over the exact raw bytes you received, not over a re-serialized version of the parsed JSON, because whitespace and key ordering will not survive a round trip through your JSON library.

  4. Step 4

    Make the write idempotent before you go live

    Assume at-least-once delivery: your endpoint will occasionally receive the same publish event twice, usually because your acknowledgement was lost rather than because anything went wrong upstream.

  5. Step 5

    Map the payload into your content model and render the graphs verbatim

    Translate the fields into whatever your front end reads: frontmatter keys for a static site, a document shape for a headless CMS, columns for a database.

  6. Step 6

    Send a test publish, inspect the built page, then raise the autopilot mode

    Put the project in approve-each mode and push a single article all the way through: delivery, verification, write, build, live URL.

What lands where

Every field maps cleanly.

SEOPulserWebhooks
  • Article title and slugWhatever your model calls them — plus your idempotency key
  • Article bodyMarkdown source, rendered HTML, or both
  • Meta description and excerptYour page metadata fields
  • Featured image URL and alt textYour image field, after you have copied the file
  • Author entityAn author record, not a name string
  • TagsYour taxonomy, after normalization
  • Publish state and timestampsYour published flag and date field
  • JSON-LD graphs and canonical URLScript tags in your page head, and your canonical link

Worth knowing first

The honest limitations.

Every destination constrains something. These are the ones worth knowing before you commit a content program to Webhooks.

  • Reliability of the last mile is yours.
  • Delivery is at-least-once, not exactly-once.
  • There is no round trip unless you build one.
  • Static sites are not live at delivery time.
  • The payload shape can evolve.

From content chaos to search results

Without a system

  • Content takes forever, or costs a fortune
  • Generic AI drafts never rank
  • No schema, no author, no canonical
  • Publishing is a manual copy-paste chore
  • Scaling too fast gets you flagged

With SEOPulser

  • Research to publish, fully on autopilot
  • Your answers make every draft original
  • JSON-LD and a named author on each
  • One-click publishing to your CMS
  • Cadence ramped to your site's age

What's different

Built to rank, not just to publish.

Structured data on every article

Article, FAQ, HowTo and Breadcrumb JSON-LD are generated inside the pipeline and stored with the piece, so they travel to whatever you publish to.

Real named authors

Every article is bylined to a named person with a bio and a profile page — not the brand as a schema.org Person, which Google advises against.

Your first-hand experience

Before drafting, you answer a few questions only you can, and the answers go into the piece as material a model could never have inferred.

An MCP server for the loop

Claude, Codex or your own agent reads the calendar, answers questions, queues generation and controls autopilot — over the same API the dashboard uses.

Pace matched to site age

Publishing cadence ramps against when your site was first seen, so a young domain never ships at a volume that reads as scaled content abuse.

Search Console improvements

Connect GSC and it finds near-miss rankings, CTR gaps and thin pages, then rewrites them as accept-or-reject hunks — on posts we didn't write, too.

Pricing

Start free. Pay when it’s working.

Thirty credits on signup — three full articles, published to your own site. No card.

Professional

Most popular

$69/mo

Billed annually

  • 100 articles a month
  • 3 projects
  • Search Console improvement loop
  • MCP server and REST API keys
  • Article, FAQPage, HowTo and BreadcrumbList JSON-LD on every piece

Questions people actually ask

What exactly is in the webhook payload?

The finished article and everything generated alongside it: title, slug, Markdown and rendered HTML, excerpt, meta description, canonical URL, featured image and alt text, the author entity as a structured object, tags, the intended publication time, and the JSON-LD graphs. The precise field names and nesting are documented in the app, and that is what you should code against rather than any description on a marketing page.

How do I know a request really came from SEOPulser?

The destination is configured with a signing secret, and deliveries carry a signature computed over the request body. Verify it against the raw bytes you received rather than a re-serialized parse, use a constant-time comparison, and reject requests whose timestamp falls outside a short tolerance window. The exact header names and signing scheme are in the current documentation — implement from there, not from memory.

Will I ever receive the same article twice?

Yes, and you should design for it. Delivery is at-least-once, so a lost acknowledgement or a timeout on your side produces a retry carrying the same event. Key your write on the stable article identifier and upsert. Approved rewrites also arrive as a fresh delivery for an existing article, so the update path is not an edge case — it is how the improvement loop reaches your site.

Can I publish to a static site that needs a build?

Yes, and it is one of the two common receiver shapes. Your endpoint commits a Markdown or MDX file with frontmatter and lets your existing deploy pipeline do the rest. The trade is that publication becomes asynchronous: the article is live when the build finishes, not when the delivery succeeds, and a failing build blocks it. Decouple the commit from the deploy so content is never lost to a broken pipeline.

Does the JSON-LD really come through intact?

It does, because nothing between generation and your endpoint modifies it. The graphs are stored on the article record and travel with the event. The risk is entirely on your side: reconstructing schema from your own fields instead of rendering what you were sent, or leaving a layout-level Article graph in place so the page carries two conflicting descriptions of itself.

How do I get the published URL back into SEOPulser?

Through the REST API with a scoped key. The publishing queue records that a delivery succeeded, which is not the same as knowing where the page ended up — on a build-based receiver, the URL does not exist yet at delivery time. If you want permalinks recorded against articles, have your receiver call back once the page is live. The MCP server exposes the same operations if an agent is driving.

Other destinations

Connect in minutes

Publish to Webhooks without touching a draft.

Connect once, confirm the brief, and articles arrive on your Webhooks site with structured data and a real author attached. Keep the review gate on until you trust it.

3

Free articles on signup

  • No credit card
  • Published to your own site
  • JSON-LD and a named author
  • Cancel anytime