DEV Community: Kjetil Furås

How to Build a WordPress Content Pipeline with AI Agents

Kjetil Furås — Thu, 23 Apr 2026 20:44:54 +0000

A content pipeline is just the steps your post takes from idea to published. For most teams, those steps are: write → edit → format → upload images → set SEO → add featured image → publish. Each step is straightforward on its own. Together, they add up to an hour or more per post — and that's before you factor in the back-and-forth when something doesn't format correctly in Gutenberg.

AI can automate most of these steps — if you connect the right tools. The key word is “connect.” AI alone gives you a draft. AI connected to your WordPress site via the right publishing layer gives you a finished post. Here's how to build that pipeline.

What a Content Pipeline Looks Like Without Automation

Walk through what actually happens when a typical WordPress post gets published manually. The writer drafts in Google Docs or Notion. An editor reviews it and leaves comments. The writer incorporates feedback, then opens WordPress, creates a new post, and starts copying content across.

That copy-paste step is where time disappears. Gutenberg doesn't accept pasted text the way a word processor does. Bold and italic formatting usually survives, but heading levels shift, paragraph spacing breaks down, and any custom formatting gets dropped entirely. Code blocks come in as plain text. Tables either mangle or paste as unstyled HTML.

Then images. Each image needs to be downloaded from wherever it lives — Docs, Dropbox, an email attachment — and uploaded individually to the WordPress media library. Then inserted into the post at the right position. Then resized if the original is too large. A post with six images easily adds 15 minutes to the publishing process.

After images: the SEO fields. Yoast or Rank Math needs a meta title, a meta description, and a focus keyword. These get written by hand, usually in a rush right before publish. Then a featured image — either created from scratch or dug out of a stock site. Then categories and tags. Then the post gets scheduled or published, and someone checks it on the live site to make sure nothing broke.

A realistic estimate for a well-maintained WordPress blog: 45 minutes to an hour of non-writing work per post. For a team publishing three posts a week, that's two to three hours a week spent on mechanical tasks that produce no actual content value.

Where AI Fits Into the Pipeline

AI is genuinely useful for specific parts of the pipeline. It's not useful for all of them, and trying to use it everywhere leads to a mess. Being clear about where AI helps — and where it doesn't — is what separates a working pipeline from one that creates more problems than it solves.

AI is good at: drafting long-form content from an outline, rewriting for tone or reading level, generating SEO metadata (title variants, meta descriptions, focus keywords), summarizing content for social posts or email previews, and suggesting internal link targets based on a brief.

AI is bad at: making publishing decisions (when to publish, what channel to prioritize), knowing your brand voice without explicit instruction, catching factual errors in specialized domains, quality control on its own output, and anything that requires judgment about whether content will actually perform.

The pipeline that actually works is a hybrid: AI handles drafting and metadata generation, a human reviews and edits the draft, and automation handles the mechanical publishing steps. No one part replaces the other. The AI speeds up the slow writing parts; the human catches the things AI gets wrong; the automation eliminates the manual formatting work.

The Pipeline Architecture

A working AI content pipeline has four stages. Each stage has a clear owner and a clear output.

Prompt. You provide the AI with a topic, outline, or brief. The more specific this is — target audience, key points to cover, tone, word count — the better the output. A one-line topic produces a generic draft. A detailed brief produces something closer to a finished post.
Draft. The AI generates the post. This can happen in a chat interface (Claude, GPT-4, Gemini), via an API call from your own script, or through a tool like Notipo that has AI generation built in. The output is a markdown document: structured, formatted, but not yet reviewed.
Review. A human reads the draft in a markdown editor. They fix factual errors, adjust the voice, restructure sections that don't flow well, and add any context the AI missed. This is the quality gate. It takes 10–20 minutes for a well-drafted post, versus 45+ minutes for writing from scratch.
Publish. Automation takes the reviewed markdown and handles everything else: converting to HTML, uploading images, setting SEO metadata, assigning categories, generating a featured image, and pushing to WordPress. No Gutenberg. No manual image uploads. One action.

The bottleneck in most teams' pipelines is stage 4. Stages 1 through 3 are conceptually simple; it's the connection between reviewed markdown and published WordPress post where things fall apart. That's the gap the right tooling needs to close.

Connecting AI Agents to WordPress

AI agents can call APIs. WordPress has a REST API. On paper, this means an AI agent should be able to publish a post directly to WordPress. In practice, the WordPress REST API handles the basics — creating a post, setting a title, adding content — but stops short of everything a real post needs.

To publish a complete post programmatically, you need to handle: uploading each image and rewriting URLs in the content, setting the featured image via a separate media attachment call, writing SEO metadata through the Yoast or Rank Math REST API (each with its own authentication and field structure), assigning categories and tags by ID (which means first looking up whether they exist), and converting markdown to valid Gutenberg block HTML rather than raw HTML.

Each of these is a separate API call with its own failure mode. Building and maintaining this yourself is feasible for a developer, but it's not what you want an AI agent to reason about on every publish. The missing piece is a layer that abstracts all of this complexity into a single, reliable endpoint.

That's what Notipo's API does. An AI agent sends one POST request with the content and metadata. Notipo handles the WordPress-specific complexity: image upload, SEO fields, featured image, Gutenberg formatting. Here's what a realistic API payload from an AI agent looks like:

{
  "title": "How to Reduce Churn in B2B SaaS",
  "content": "# How to Reduce Churn in B2B SaaS\n\nChurn is the silent killer...",
  "status": "draft",
  "seo": {
    "meta_title": "How to Reduce Churn in B2B SaaS (Proven Strategies)",
    "meta_description": "A practical guide to identifying churn risk early and...",
    "focus_keyword": "reduce churn B2B SaaS"
  },
  "categories": ["Growth", "Retention"],
  "tags": ["churn", "saas", "customer success"],
  "featured_image": {
    "generate": true,
    "prompt": "Abstract illustration of customer retention funnel"
  }
}

The AI agent generates this payload based on the draft it wrote. Notipo receives it, processes the WordPress-specific work, and creates the post. The agent doesn't need to know how WordPress handles image attachments or how Rank Math stores SEO fields. It just needs to produce structured content and metadata — something AI is well-suited for.

Building the Pipeline Step by Step

Here's how to set up the full pipeline using Notipo as the publishing layer.

Step 1: Connect Notipo to your WordPress site. Create a Notipo account and go to Settings → WordPress. Enter your site URL and generate an application password in WordPress (Users → Profile → Application Passwords). Notipo will verify the connection and check which SEO plugin you have installed.

Step 2: Use Notipo's editor or API to receive AI drafts. You can write directly in Notipo's built-in markdown editor, or use the API to push drafts programmatically from an AI agent. If you're using the editor, there's an AI generation button that lets you provide a brief and get a draft inline. If you're building an automated pipeline, use the API endpoint with your API key.

Step 3: Review the draft in Notipo. The draft appears in Notipo's editor. Edit the markdown directly — fix anything the AI got wrong, adjust the structure, add images by pasting or uploading. The SEO fields panel on the right lets you set the meta title, meta description, and focus keyword. You can also set the featured image here: upload one, use an existing WordPress media library image, or let Notipo generate one.

Step 4: Publish. Click Publish. Notipo converts the markdown to clean HTML, uploads any images you added (and rewrites the URLs in the content), applies SEO metadata via the Rank Math or Yoast API, sets the featured image, assigns categories and tags, and creates the post in WordPress. The whole process takes a few seconds. The post appears in WordPress as a fully formatted draft or live post, depending on the status you set.

Advanced: Fully Automated Pipeline (No Human Review)

For teams that have validated their AI output quality on a specific content type, it's possible to remove the human review step entirely. This makes sense for high-volume, templated content: news summaries, product update announcements, weekly roundups, or SEO-targeted informational pages where factual accuracy is verifiable from a data source.

The typical approach for a semi-automated pipeline: the AI agent generates content and hits the Notipo API with "status": "draft". A human gets a notification, opens WordPress, spot-checks the draft (30 seconds, not 20 minutes), and clicks publish. The mechanical work is gone; only the judgment call remains.

For fully automated pipelines, set "status": "publish" in the API payload. The post goes live immediately. Use this only for content types where errors are low-stakes and easily corrected — not for long-form editorial content where a hallucinated fact or wrong attribution could damage credibility.

A production-grade automated pipeline typically adds a validation step before the publish call: a second AI pass that checks for obvious errors, a word count and structure check, and a duplicate content check against existing posts. These can be implemented as functions in the agent's workflow, called before the Notipo API request is made.

What Gets Automated in This Pipeline

To make it concrete, here's exactly what Notipo handles automatically when an AI agent sends it a content payload:

Markdown to HTML conversion — full spec including headings, lists, tables, blockquotes, code blocks with language tags, and inline formatting.
Image upload and URL rewriting — images referenced in the markdown (by URL or included in the payload) are uploaded to the WordPress media library. The image URLs in the content are rewritten to point to the uploaded copies.
Featured image generation — if no featured image is provided, Notipo generates one based on the post title and category. It's uploaded and set as the post thumbnail automatically.
Rank Math and Yoast SEO metadata — meta title, meta description, and focus keyword are written via the SEO plugin's REST API. No manual Yoast panel interaction needed.
Category and tag assignment — categories and tags are matched by name or created if they don't exist. No need to look up taxonomy IDs beforehand.
Scheduling support — set a future publish date in the payload and WordPress schedules the post automatically.
Gutenberg-compatible output — content is formatted as Gutenberg blocks, not raw HTML, so it's editable in the WordPress block editor if manual changes are needed after the fact.

What You Still Need to Do Yourself

Automation doesn't replace editorial judgment. There are parts of the content pipeline that work better with a human in the loop, and trying to fully automate them produces worse outcomes.

Topic selection and content strategy. AI can suggest topics based on keyword data or trends, but the decision about what to publish — what fits your audience, what moves your goals forward, what doesn't cannibalize existing content — is a strategic call. The best content strategies come from understanding the audience in a way AI currently can't replicate without a lot of guided input.

Accuracy review and brand voice. AI drafts are a starting point, not a finished product. For technical or specialized content, a subject matter expert needs to verify facts. For brand-sensitive content, someone who knows the voice needs to review the tone. This review can be fast (10 minutes) if the draft is good and the brief was specific — but it shouldn't be skipped.

Link building strategy. Notipo handles internal link formatting — if you add links in your markdown, they're preserved in the published post. But which posts should link to which, how to build external backlinks, and how to structure your internal link graph are decisions that require knowing your site's authority structure and SEO goals. That strategy is yours.

Getting Started

The fastest way to see this pipeline in action is to set up Notipo with your WordPress site and publish one post through it — manually, without any AI integration. Get the publishing step working cleanly first. Once you can take markdown from the editor to a fully formatted WordPress post in one click, adding AI to the drafting step is straightforward.

From there, you can layer in automation: use Notipo's built-in AI generation for drafts, or connect your own AI agent to the API. The pipeline doesn't need to be fully automated from day one. Start with the part that saves you the most time — usually the publishing step — and build from there.

Create a free Notipo account to connect your WordPress site and start publishing without the manual formatting work. The free tier covers five posts per month — enough to validate the pipeline before committing to it.

Publish to WordPress Without the Block Editor

Kjetil Furås — Thu, 23 Apr 2026 19:48:19 +0000

Gutenberg divides people. Some find the drag-and-drop block editor intuitive. Plenty of developers, technical writers, and content teams find it gets in the way — whether that's because it mangles markdown, doesn't work well with code-heavy posts, or simply doesn't fit into an existing review workflow. The good news is that WordPress has a REST API, and there are several legitimate ways to publish content without ever opening the block editor.

This guide covers each option in detail: what it does, where it falls short, and what kind of publisher it works best for.

Why People Skip Gutenberg

The block editor isn't bad for everyone. If you're building landing pages with custom layouts, or you enjoy clicking through block settings, it works well enough. But for writers and developers who live in other tools, it creates real friction:

Markdown gets mangled
You can't write in your own editor
Code-heavy posts are painful
No SEO automation from external tools
Slow for teams with external review workflows

None of these are reasons to abandon WordPress entirely. The platform has too much going for it — SEO plugins, hosting options, media management, plugin ecosystem. The fix is publishing through a different interface, not switching platforms.

Option 1 — Classic Editor Plugin

The simplest escape hatch: install the Classic Editor plugin from the WordPress repository. This replaces Gutenberg with the old TinyMCE-based editor that WordPress used before version 5.0. It's free, officially supported by the WordPress team, and takes about 30 seconds to set up.

Once active, you get a plain rich-text editing area and a sidebar with post settings. You can also switch individual posts between classic and block editor if you want to keep Gutenberg for some content.

Pros: Free, one-click install, officially supported, well understood.

Cons: You're still inside WordPress. Writing still happens in a browser textarea, not your preferred editor. No image automation, no SEO metadata from external sources, no code highlighting.

Option 2 — WordPress REST API

WordPress ships with a REST API at /wp-json/wp/v2/. You can create, update, and publish posts via standard HTTP requests — no browser required. This opens the door to automation: CI/CD pipelines, scripts triggered on Git push, scheduled publishing jobs, or any tool that can make HTTP calls.

Here's a minimal example using curl to create a draft post with Application Passwords authentication:

curl -X POST https://yourblog.com/wp-json/wp/v2/posts   -H "Content-Type: application/json"   -u "your-username:xxxx xxxx xxxx xxxx xxxx xxxx"   -d '{
    "title": "My Blog Post",
    "content": "<p>Post content as HTML.</p>",
    "status": "draft",
    "categories": [5],
    "tags": [12, 18]
  }'

Publishing a real post via the REST API isn't just one call. It's several: image uploads, featured image assignment, SEO metadata, and code highlighting.

Pros: Platform-agnostic, automatable, works in any language, free.

Cons: You're building and maintaining a publishing tool.

Option 3 — Desktop Markdown Editors

Several native Mac apps let you write in markdown and publish to WordPress directly. Ulysses and iA Writer are writing-focused apps with WordPress publishing built in. MarsEdit is a dedicated blog editor for macOS.

Pros: Native app performance, beautiful writing environments, no browser required, direct publish to WordPress.

Cons: Mostly Apple-only, limited automation, weak SEO support, weak code-block handling.

Option 4 — Static Site Generators with WordPress Headless

A more architectural approach: decouple the WordPress backend from the frontend entirely. Use WordPress purely as a headless CMS while building the public-facing site in Next.js, Astro, Hugo, or another static site generator.

Pros: Developers work entirely in their existing tools. Full control over rendering, performance, and code highlighting.

Cons: Significant upfront engineering investment.

Option 5 — Notipo (Write Markdown, Publish Everything)

Notipo is a markdown editor built specifically for WordPress publishing. You write in the built-in editor — or sync content from Notion — and Notipo handles the entire publishing pipeline via the WordPress REST API. You never open Gutenberg.

What gets handled automatically on each publish:

Markdown to HTML
Image uploads
Featured image handling or generation
SEO metadata for Rank Math or Yoast
Code highlighting
Categories and tags

The key difference from the REST API approach: Notipo is a complete tool, not a starting point. You don't build the image upload logic, the SEO connector, or the featured image pipeline yourself. It's already there.

Which One Should You Pick?

The right choice depends on what you're optimizing for:

Want a simpler editor inside WordPress? Use the Classic Editor plugin.
Want to automate publishing from scripts or CI? Use the REST API directly.
Want a beautiful Mac writing app? Use iA Writer or Ulysses.
Want a developer-focused headless setup? Use a static site generator.
Want the full pipeline automated without building anything? Use Notipo.

The Bottom Line

Gutenberg is optional. WordPress's REST API has been stable for years, and there are mature tools at every level of the stack — from a simple plugin swap to a fully automated publishing pipeline.

If you want to skip Gutenberg entirely and publish from a markdown editor with images, SEO, and featured images handled automatically, try Notipo free.

How to Use AI to Write and Publish WordPress Posts

Kjetil Furås — Thu, 23 Apr 2026 19:48:16 +0000

Most people use AI to write blog posts, then spend ten minutes copying the output into WordPress. They paste the text, watch Gutenberg mangle the formatting, re-upload the images, type out the SEO fields by hand, and finally hit publish. That's half the automation. The content is AI-generated — but the publishing is still fully manual.

The complete pipeline looks different: AI writes the content, then publishes it to WordPress directly. No copy-paste, no formatting fixes, no manual uploads. Here's what that pipeline actually involves, and how to build one.

What “AI Writing to WordPress” Actually Means

There are two separate things happening in a fully automated AI writing pipeline. The first is content generation: using a model like Claude or GPT-4 to draft the post. The second is publishing: taking that content and getting it into WordPress with all the metadata, images, and formatting intact.

The content generation part is easy. Any AI writing tool can do it. The publishing part is where most setups fall apart, because WordPress isn't a document you paste text into — it's an application with a database, a media library, SEO plugins, and a block editor that needs structured input.

Getting AI output into WordPress without manual steps requires connecting the AI to WordPress via an API. The AI doesn't log in to your admin panel. Instead, it calls the WordPress REST API (or a service that wraps it) to create the post, upload images, and set metadata programmatically. That's what turns AI writing into AI publishing.

The Manual Approach (and Why It Breaks Down)

The typical workflow for someone using AI to write WordPress posts goes like this: ask ChatGPT or Claude to write a 1,500-word post, copy the output, open the WordPress editor, paste it in. Then the work starts.

Gutenberg doesn't render AI output cleanly. Headings sometimes convert correctly, sometimes don't. Lists get wrapped in extra paragraph tags. Any markdown formatting — bold, italics, code blocks — either works partially or breaks entirely, depending on how you pasted it. You end up in the block editor fixing formatting for ten minutes before the post looks right.

Then there's everything else: find or generate an image, upload it to the media library, set it as the featured image. Open the Yoast or Rank Math sidebar, type the meta description, set the focus keyword, check the SEO score. Assign a category and tags. Set the publish date. Hit publish.

For a single post, that's manageable. For ten posts a week, it's a part-time job. The writing is automated, but the publishing overhead hasn't moved — and at scale, that overhead becomes the bottleneck.

How AI Agents Publish to WordPress Directly

Modern AI agents aren't just text generators. They can call external APIs as part of their workflow. An agent can generate content, then immediately make HTTP requests to publish that content — without any human in the loop.

WordPress exposes a REST API at /wp-json/wp/v2/. An AI agent can use it to create posts (POST /posts), upload images to the media library (POST /media), assign categories, and set featured images. SEO plugins like Rank Math and Yoast expose their own REST API extensions for setting meta descriptions and focus keywords.

In theory, an AI agent could call all of these endpoints in sequence after generating the content. In practice, assembling that pipeline yourself is significant engineering work: handling authentication, converting markdown to the right HTML format, re-uploading and re-linking images, calling SEO plugin APIs, and stitching the whole thing together reliably.

That's where a tool like Notipo fits in. Instead of building all of that yourself, the agent makes a single API call to Notipo. Notipo takes the content and handles the entire WordPress pipeline — markdown conversion, image upload, SEO metadata, featured image, publish. The agent doesn't need to know anything about how WordPress works internally.

Setting It Up with Notipo's API

Notipo exposes an API endpoint designed for exactly this use case. An AI agent — or any script — can send a single request with the post content and metadata, and Notipo handles everything else.

A typical request looks like this:

curl -X POST https://app.notipo.com/api/posts   -H "Authorization: Bearer YOUR_API_KEY"   -H "Content-Type: application/json"   -d '{
    "title": "10 Ways to Reduce Churn in SaaS",
    "content": "## Why churn happens

Most SaaS churn...",
    "seo_description": "Learn the top strategies for reducing SaaS churn and improving retention.",
    "focus_keyword": "reduce SaaS churn",
    "category": "Growth",
    "tags": ["churn", "retention", "saas"],
    "status": "publish"
  }'

The content field accepts markdown. Notipo parses it, converts it to clean HTML, extracts any image references, uploads them to your WordPress media library, and rewrites the image URLs to point to your site. The SEO fields get written to Rank Math or Yoast (whichever is active on your site). The category and tags are matched to existing taxonomy terms or created if they don't exist.

If you don't provide a featured image URL, Notipo can generate one automatically based on the post title and category. The generated image is uploaded to your media library and set as the post thumbnail before publishing.

From the agent's perspective, publishing a post is a single API call. Everything that used to require manual WordPress work happens inside that call.

Using AI Directly in Notipo's Editor

You don't need to build an API pipeline to use AI with Notipo. If you want to draft posts yourself — with AI assistance — Notipo has writing tools built into the editor.

You can open a new post, use the AI writing panel to generate a draft, edit it directly in the markdown editor, and publish to WordPress from the same interface. The AI-generated content flows into the editor, and you can refine it before it goes live. No switching between tabs, no copy-pasting, no reformatting.

This is the right flow for writers who want AI assistance without fully automating the process. You stay in control of the final content, but you don't lose time on the publishing mechanics. Write or edit in Notipo, click publish, and the post is live on WordPress with all metadata handled.

What the Pipeline Handles Automatically

Whether you're using the API or the editor, the publishing pipeline takes care of the same set of tasks that normally require manual work in WordPress:

Markdown to HTML conversion — headings, bold, italic, links, lists, tables, and code blocks all convert cleanly. No Gutenberg formatting issues.
Image upload — images referenced in the markdown are fetched and uploaded to your WordPress media library. The HTML is updated to use the new hosted URLs.
Featured image — set from a URL you provide, or auto-generated from the post title. Uploaded to WordPress and set as the post thumbnail.
SEO metadata — meta description, focus keyword, and SEO title written to Rank Math or Yoast via their REST APIs.
Code syntax highlighting — fenced code blocks are converted with language classes compatible with Highlight.js and Prism.js.
Categories and tags — matched to existing WordPress taxonomy terms or created on the fly.
Publish status — post to draft for review or straight to published, set per request.

The result is a fully formatted, SEO-ready post in WordPress — the same output you'd get from spending 20–30 minutes in the admin panel, but without the manual steps.

Who Is This For?

Automating the AI-to-WordPress pipeline makes the most sense in a few specific situations:

Content teams publishing multiple posts per week
Developers building AI writing tools
Solopreneurs running a blog alongside other work
Anyone tired of the copy-paste-fix cycle

The manual workflow isn't broken for occasional publishing. But the more you publish, the more the friction compounds. At some point, the time spent on publishing mechanics exceeds the time spent on writing — and that's when automation starts to make a real difference.

If you want to try the pipeline, sign up for Notipo and connect your WordPress site. The free tier covers up to 5 posts per month — enough to test the full workflow and see whether it fits how you publish.

WordPress Publishing Workflow: Draft to Live Post in Under 2 Minutes

Kjetil Furås — Thu, 23 Apr 2026 19:42:48 +0000

The WordPress Publishing Bottleneck

Most WordPress users spend 10 to 20 minutes per post on things that aren't writing. You paste your draft into the Block Editor, watch the formatting break, then fix headings one by one. You upload images manually, drag them into position, set alt text. You fill in SEO fields — meta title, description, focus keyword, slug. You pick a featured image or design one in Canva.

That's 10 to 20 minutes of overhead on every single post. If you publish twice a week, that's two hours a month spent on formatting and uploading — not writing. The WordPress publishing workflow is the bottleneck, not the writing itself.

The Block Editor was designed for page builders and site designers. For writers who just want to publish a blog post, it adds friction at every step. And the more often you publish, the more that friction compounds.

What a Fast WordPress Publishing Workflow Looks Like

A fast publishing workflow has three properties: you write in a clean editor, you publish in one action, and the output on WordPress looks exactly like what you wrote. No reformatting step in between.

Here's the target state:

Write in markdown. No Block Editor, no Gutenberg blocks, no formatting toolbar. Just text with headings, bold, links, code blocks, and images — the way developers and technical writers already work.
One click to publish. Formatting, image uploads, SEO metadata, featured image — all handled automatically. You don't touch the WordPress admin.
Under 2 minutes. From “final draft” to “live on your site.” Not 20 minutes of manual work. Two minutes.

That's not a theoretical ideal. It's what the workflow actually looks like when you remove the Block Editor from the process entirely.

Step by Step: Draft to Live Post With Notipo

Notipo is a markdown-to-WordPress publishing tool. You write in a clean markdown editor, and Notipo handles everything between your draft and a live WordPress post. Here's the actual flow:

1. Write Your Post in Markdown

Open the Notipo editor and write your post using standard markdown. Headings, paragraphs, bold, italic, links, images, code blocks — everything you'd use in any markdown file. The editor is distraction-free: no sidebar, no block palette, no formatting menus. Just your content.

If you prefer writing in a local editor like VS Code, iA Writer, or Obsidian, you can do that too. Notipo also syncs from Notion if that's where your content lives. The publishing step is the same regardless of where you write.

2. Preview What WordPress Will Show

Before publishing, the preview renders your markdown exactly as it will appear on WordPress. Headings are styled, code blocks have syntax highlighting, images are positioned. What you see is what gets published — no surprises after the fact.

3. Hit Publish

One click. Here's what happens behind the scenes:

Markdown is converted to clean WordPress HTML — proper heading hierarchy, semantic markup, no leftover formatting artifacts
Images are uploaded to your WordPress media library automatically — no manual drag-and-drop
SEO metadata is set: meta title, meta description, slug, focus keyword
A featured image is generated and attached to the post
The post goes live on your WordPress site

No copy-paste. No reformatting. No manual image uploads. No switching between tabs. The entire process from clicking “publish” to the post being live takes under 30 seconds.

What About Code Blocks?

If you write technical content, code blocks matter. In the Block Editor, getting syntax-highlighted code into WordPress is painful — you either install a plugin, paste into a “code” block that strips formatting, or manually add HTML classes.

With Notipo, code blocks in your markdown are automatically converted with syntax highlighting. Write a fenced code block with a language tag — `javascript — and it renders with full highlighting on WordPress. No plugins needed. The highlighting is baked into the HTML, so it works on any WordPress theme.

What About SEO?

SEO metadata is part of the publishing step, not a separate task. When you set a title, description, and focus keyword in Notipo, they're written directly to WordPress — including to Rank Math or Yoast fields if you use those plugins.

That means your meta title, meta description, and slug are set automatically. You don't need to open the WordPress admin, scroll to the SEO panel, and type them in manually. One less step, one less place to forget something.

The Time Difference Is Real

Here's what the traditional WordPress publishing workflow looks like, step by step:

Paste draft into Block Editor: 1 minute
Fix broken formatting (headings, lists, code blocks): 3–5 minutes
Upload and position images: 3–5 minutes
Fill in SEO fields: 2 minutes
Create and upload featured image: 3–5 minutes
Review and publish: 1 minute

Total: 13 to 19 minutes of overhead per post.

With Notipo, the same workflow:

Write in markdown editor: 0 extra minutes (you were going to write anyway)
Set SEO fields inline: 30 seconds
Click publish: 30 seconds

Total: under 2 minutes. The formatting, images, featured image, and SEO metadata are handled automatically.

If you publish twice a week, that's 26 to 38 minutes saved per week. Over a year, that's roughly 30 hours you get back — an entire work week that was spent copying, pasting, and reformatting.

Free Plan vs Pro

Notipo has a free tier: 5 posts per month, no credit card required. That's enough to test the workflow and see if it fits how you write.

The Pro plan is $19/month and removes the post limit. You also get automatic image hosting (images are uploaded to your WordPress media library), AI-generated featured images, priority support, and API access for automation.

If you're publishing more than 5 posts a month, Pro pays for itself in time saved on the first post.

Try It

The best way to evaluate a WordPress publishing workflow is to try it with a real post. Sign up for free at notipo.com, connect your WordPress site, and publish one post. The whole setup takes about 3 minutes.

If you're curious how AI agents can take this even further — drafting content and publishing to WordPress automatically — check out How to Build a WordPress Content Pipeline with AI Agents.

How to Use Claude Code Subagents to Run Parallel Tasks

Kjetil Furås — Thu, 23 Apr 2026 19:42:47 +0000

I’ve been using Claude Code subagents daily for the past few months. They’re the feature that turned Claude Code from a useful assistant into something that actually scales — running multiple tasks at once without losing context or focus.

Here’s how they work, when to reach for them, and the patterns that actually matter in practice.

What Claude Code Subagents Are

A subagent is a separate Claude Code instance that your main session spawns to handle a scoped task. The parent agent keeps its context clean while the child does focused work — exploring files, running searches, reviewing code, or building features in isolation.

The key thing to understand: the subagent starts with zero context from your conversation. It doesn’t know what you’ve been working on, what files you’ve read, or what you’ve tried. You have to brief it like a colleague who just walked into the room. This is by design — it keeps both agents focused and prevents context pollution.

When to Use Subagents vs Doing It Yourself

Not everything needs a subagent. Here’s the decision framework I use:

Use a subagent when:

You need to explore a large codebase and don’t know where things are yet
You have independent research tasks that can run in parallel
The work needs isolation (a separate git worktree, for example)
You want to protect your main context from noisy search results

Just do it yourself when:

You already know the target file and what to change
It’s a simple edit — three lines of code don’t need a subagent
The task depends on something you just learned in this conversation
You need to make a judgment call that requires full context

The threshold is roughly: if you’d context-switch to do it, spawn a subagent. If you’d just do it inline, do it inline.

Practical Example: Parallel Code Review

This is where subagents shine. Say you have a PR with changes across the backend, frontend, and test suite. Instead of reviewing everything sequentially, you spawn three subagents — each reviewing a different dimension of the same PR.

Here’s what that looks like in practice. You tell Claude Code something like:

Review this PR for security issues, performance concerns, and test coverage gaps. Run all three reviews in parallel.

Claude Code spawns three subagents simultaneously:

Security reviewer — checks for injection vulnerabilities, auth bypasses, exposed secrets, unsafe input handling
Performance reviewer — looks for N+1 queries, missing indexes, unnecessary re-renders, large payload sizes
Test coverage reviewer — identifies untested code paths, missing edge cases, brittle test patterns

Each subagent gets a self-contained prompt with the PR diff and a specific focus area. They run concurrently, so a review that would take 15 minutes sequentially finishes in 5.

When all three return, you get three focused reports. No context bleed between them — the security reviewer isn’t distracted by performance opinions, and vice versa.

Practical Example: Research Then Implement

Not all subagent work is parallel. Sometimes you need a sequential pattern: research first, then act on the findings.

Say you need to migrate from a deprecated API across your codebase. You don’t know how many call sites exist or what patterns they use. The approach:

Step 1: Spawn a research subagent to find every usage of the deprecated API. Give it a clear brief:

Find all usages of the legacyAuth.verify() method across the codebase. For each usage, note the file, the surrounding context, and whether it’s in a hot path or a background job. Report back with a summary.

The subagent explores, searches, reads files, and returns a structured report: “Found 12 usages across 8 files. 3 are in request middleware (hot path), 5 are in background workers, 4 are in tests.”

Step 2: Now you have the full picture in your main context. You implement the migration yourself, file by file, using the research to prioritize: fix the hot-path middleware first, then the workers, then update the tests.

This pattern — delegate the exploration, keep the implementation — is how I handle most refactoring tasks.

Running Subagents in the Background

Claude Code gives you two modes for subagents: foreground and background.

Foreground (default): You wait for the result before doing anything else. Use this when the subagent’s output determines your next step — like the research-then-implement pattern above.

Background: The subagent runs independently and you get notified when it’s done. Use this for genuinely parallel work where you don’t need the result immediately.

The distinction matters. If you put everything in the background, you’ll end up with results you can’t act on because they arrived out of order. If you put everything in the foreground, you’re waiting unnecessarily.

My rule of thumb: if I’m going to read the result and then decide what to do, foreground. If I already know what I’m doing and the subagent is handling something separate, background.

Tips From Running Subagents in Production

I run subagents as part of an autonomous agent system — scheduled cron jobs, code review bots, Sentry error fixers. Here’s what I’ve learned:

Write self-contained prompts. The subagent has zero context from your conversation. Don’t say “fix the bug we discussed” — say “fix the null reference error in src/auth/middleware.ts at line 47 where user.email is accessed before the null check.” Include file paths, line numbers, and what specifically needs to change.
Don’t over-delegate. Spawning a subagent has overhead — context initialization, prompt processing, result synthesis. For a three-line fix, just do it. Subagents earn their cost on tasks that would pollute your context or benefit from parallelism.
Use worktree isolation for code changes. When a subagent needs to modify files, give it a git worktree so it works on an isolated copy. This prevents conflicts with your main working tree and makes it safe to run multiple coding subagents in parallel.
Limit parallel spawns. Three to five concurrent subagents is the sweet spot. Beyond that, you’re juggling too many results and the synthesis overhead cancels out the time savings.
Trust the push-based completion model. Don’t poll for subagent status. You get notified when they’re done. Polling wastes cycles and adds noise.

How This Fits Into Larger Agent Architectures

Subagents aren’t just a Claude Code feature — they’re a pattern. In my setup with OpenClaw, the main agent delegates specialized work to coding agents, research agents, and review agents. Each one operates in its own session with its own context, and results flow back automatically.

The Claude Code subagent model is the smallest unit of this pattern: one agent, scoped task, clean handoff. If you’re building autonomous workflows — scheduled jobs, error-fixing pipelines, multi-repo operations — subagents are how you decompose the work without losing coherence.

If you’re building agent workflows like this, I share operator notes and templates in Build & Automate — the community where I break down what’s actually working in production.

How to Publish Markdown to WordPress (Without Copy-Paste)

Kjetil Furås — Mon, 20 Apr 2026 08:23:42 +0000

You write in markdown. Your blog runs on WordPress. And somewhere in between, things go wrong. Gutenberg mangles your formatting. Images need to be uploaded separately. Code blocks lose their syntax highlighting. You end up spending more time fixing the post than writing it.

It doesn't have to be this way. There are tools that take your markdown and publish it to WordPress directly — handling images, metadata, and formatting automatically. Here's how each approach works, what breaks, and what actually solves the problem.

Why Markdown and WordPress Don't Get Along

WordPress switched to Gutenberg (the block editor) in 2018. Since then, pasting markdown into WordPress has been a gamble. Gutenberg converts some markdown syntax into blocks, ignores the rest, and occasionally creates a mess of nested paragraphs and stray HTML.

The core problem: Gutenberg is a visual block editor. Markdown is a plain-text format. They represent content differently, and WordPress doesn't have a reliable built-in bridge between the two.

Specifically, here's what breaks when you paste markdown into WordPress:

Images — markdown image references don't get uploaded to your media library. They either point to external URLs (which can break) or get stripped entirely.
Code blocks — fenced code blocks become plain <pre> tags with no syntax highlighting.
Front matter — YAML front matter (title, category, tags) gets treated as regular text content.
Tables — markdown tables are hit-or-miss. Some convert to HTML tables, some render as plain text.
SEO metadata — there's no way to set meta descriptions, focus keywords, or Open Graph tags from your markdown file.

Option 1: The Jetpack Markdown Module

Jetpack includes a markdown module that lets you write posts in markdown syntax directly inside the WordPress editor. Enable it under Jetpack → Settings → Writing, and you can use a "Markdown" block in Gutenberg.

Pros: Free. Works inside WordPress. Handles basic markdown syntax (headings, bold, italic, links, lists).

Cons: You're still writing inside WordPress, not in your favorite editor. No image handling — you still upload images manually. No code syntax highlighting. No SEO metadata from markdown. And you need the full Jetpack plugin installed, which is heavy.

Best for: Writers who want markdown syntax but don't mind working inside the WordPress admin panel.

Option 2: Convert Markdown to HTML, Then Paste

Tools like pandoc, Marked, or online markdown converters can turn your .md file into HTML. You then paste the HTML into a Custom HTML block in WordPress.

Pros: Works with any markdown file. You keep writing in your preferred editor. Free.

Cons: Manual process every time you publish. Images still need to be uploaded and linked separately. No featured image generation. No SEO metadata. Code blocks are unstyled HTML. If you update the post, you go through the whole process again.

Best for: Occasional publishers who don't mind the manual work.

Option 3: WordPress REST API with a Script

The WordPress REST API lets you create posts programmatically. You could write a script that reads a markdown file, converts it to HTML, and pushes it to WordPress via POST /wp-json/wp/v2/posts.

import markdown
import requests

with open("my-post.md") as f:
    md_content = f.read()

html = markdown.markdown(md_content, extensions=["fenced_code", "tables"])

response = requests.post(
    "https://yourblog.com/wp-json/wp/v2/posts",
    auth=("username", "xxxx xxxx xxxx xxxx xxxx xxxx"),
    json={
        "title": "My Blog Post",
        "content": html,
        "status": "draft",
    }
)

Pros: Full control. Can be automated in CI/CD or run from the command line. Free (if you write the script yourself).

Cons: You're building and maintaining your own publishing tool. Image handling requires separate API calls to upload each image, then rewrite the HTML to use the new URLs. Code highlighting requires adding a client-side library. SEO metadata requires the Yoast or Rank Math REST API. Featured images require another API call. Every edge case (tables, embeds, captions) needs custom code.

Best for: Developers who enjoy building tooling and have simple content (mostly text, few images).

Option 4: Desktop Apps with WordPress Publishing

Apps like Ulysses, iA Writer, and MarsEdit let you write in markdown and publish to WordPress from the app. They connect to your WordPress site via the XML-RPC or REST API.

Pros: Beautiful writing environment. Native app performance. Write and publish from the same place.

Cons: Typically macOS/iOS only. No automatic image optimization or media library management — images are uploaded as-is. No syntax highlighting for code blocks. No SEO metadata. No featured image generation. Subscription pricing ($5–$50/month depending on the app).

Best for: Non-technical writers who value a clean writing experience and don't need code blocks or SEO automation.

Option 5: Notipo — Write Markdown, Publish Everything

Notipo is a markdown editor built specifically for WordPress publishing. You write in the built-in editor (or sync from Notion), and Notipo handles the entire pipeline:

Images — uploaded to your WordPress media library automatically. No broken links, no external hosting.
Code blocks — fenced code blocks are converted to syntax-highlighted HTML. Works with any theme that loads a highlighter.
SEO metadata — set focus keywords, meta descriptions, and SEO titles. Notipo writes these to Rank Math or Yoast via their REST APIs.
Featured images — generated automatically based on your post title and category, or upload your own.
Categories and tags — set from the editor and applied on publish.
One-click publish — your markdown goes to WordPress as a fully formatted post with all metadata in a single action.

The difference from the other options: Notipo doesn't just convert markdown to HTML. It handles everything that usually requires manual work after the conversion — the images, the metadata, the featured image, the code highlighting. You write, click publish, and the post is live.

Pricing: Free for up to 5 posts per month. Pro plan is $19/month for unlimited posts.

Which Option Should You Pick?

It depends on how much of the publishing pipeline you want to automate:

Just want markdown syntax in WordPress? Enable the Jetpack markdown module. It's free and simple.
Publish occasionally and don't mind manual work? Convert to HTML with pandoc and paste it in. Quick and free.
Developer who wants full control? Build a REST API script. You'll spend a weekend on image handling, but you own the whole pipeline.
Writer who wants a beautiful app? iA Writer or Ulysses, if you're on Apple and don't need code blocks.
Want the full pipeline automated? Notipo handles images, code highlighting, SEO, featured images, and publishing in one step. It's the only option that covers everything.

The manual approaches work fine when you're publishing one post a month. But if you're publishing weekly or more, the time spent on image uploads, formatting fixes, and metadata entry adds up fast. That's where automation pays for itself.

Best Markdown Editors for WordPress Publishing in 2026

Kjetil Furås — Sun, 19 Apr 2026 18:14:43 +0000

Compare the best markdown editors that publish to WordPress — Notipo, Ulysses, iA Writer, MarsEdit, and Jetpack. Features, pricing, and which one fits your workflow.

If you write in markdown and publish to WordPress, the Gutenberg editor is not your friend. It's a block editor designed for drag-and-drop page building, not for writing long-form content in plain text. Pasting markdown into Gutenberg is a guaranteed formatting headache.

The good news is there are dedicated tools that let you write in markdown and publish to WordPress without touching Gutenberg. I've used most of them over the past few years. Here's how they compare.

What to Look For

Before the comparison, here are the features that actually matter:

Native WordPress publishing — can it publish directly via the REST API, or do you need to copy-paste?
Image handling — does it upload images to your WordPress media library?
Code block support — does it convert fenced code blocks to syntax-highlighted blocks?
SEO metadata — can you set focus keywords, meta descriptions, and titles?
Featured images — does it handle featured image creation?
Gutenberg output — does it create proper Gutenberg blocks, or raw HTML?

1. Notipo

Notipo is built specifically for the markdown-to-WordPress pipeline. Full disclosure: I built it, so I'm biased. But I built it because nothing else did what I needed.

What it does: Write in the browser-based markdown editor (or sync from Notion, or use the API). Notipo converts to Gutenberg blocks, uploads images to your media library, generates AI featured images, sets Rank Math SEO metadata, and publishes. One click.

Code blocks: Converted to Prismatic plugin blocks with automatic language detection.

Pricing: Free (5 posts/month). Pro at $19/month for unlimited posts, AI featured images, and webhook triggers.

Best for: Developers and technical writers who want the full pipeline automated — especially if your posts include code.

2. Ulysses

What it does: A polished writing app for Mac and iOS with built-in WordPress publishing. Write in a markdown-like syntax, organize with folders and tags, and publish directly.

Code blocks: Basic support. Standard HTML code blocks, not syntax-highlighted.

Image handling: Uploads to WordPress media library. No AI generation.

SEO: No built-in SEO metadata support.

Pricing: $5.99/month or $49.99/year. Apple platforms only.

Best for: Writers who want a beautiful native Mac writing experience.

3. iA Writer

What it does: The gold standard for distraction-free markdown writing with WordPress publishing built in.

Code blocks: Standard HTML code blocks. No syntax highlighting integration.

Image handling: Uploads inline images. Featured images need to be set manually.

SEO: None. Metadata is handled in WordPress.

Pricing: One-time purchase — $49.99 (Mac), $29.99 (iOS/Android/Windows).

Best for: Writers who want a minimal, focused editor and handle SEO in WordPress.

4. MarsEdit

What it does: Desktop blog editor for Mac. Connects to WordPress and lets you write and publish from a native app.

Code blocks: Raw HTML.

Image handling: Uploads to WordPress media library.

SEO: Supports custom fields for SEO plugin integration.

Pricing: $59.95 one-time. Mac only.

Best for: Mac users who want a traditional desktop blogging client.

5. Jetpack

What it does: Adds markdown support directly to the WordPress editor.

Code blocks: Standard WordPress code blocks.

SEO: Separate Jetpack SEO tools available.

Pricing: Free markdown module.

Best for: People who want to stay inside WordPress but write in markdown.

Quick Comparison

Feature	Notipo	Ulysses	iA Writer	MarsEdit	Jetpack
Direct WP publish	Yes	Yes	Yes	Yes	Built-in
Gutenberg blocks	Yes	No	No	No	Partial
Code highlighting	Prismatic	Basic	None	None	None
SEO metadata	Rank Math	No	No	Custom fields	Separate
AI featured images	Yes (Pro)	No	No	No	No
Platform	Web	Apple	All	Mac	WordPress
Free tier	5 posts/mo	No	No	No	Yes

My Recommendation

If you're a developer or technical writer whose posts include code, Notipo is the obvious choice. Nothing else converts fenced code blocks to syntax-highlighted WordPress blocks automatically. And nothing else handles the full pipeline — images, SEO, featured images, and publishing — in one step.

If you're a non-technical writer who wants a beautiful native app and doesn't need code highlighting, iA Writer or Ulysses are both excellent. iA Writer wins on pricing (one-time purchase), Ulysses wins on organization features.

If you want to stay inside WordPress and just need markdown syntax, Jetpack's markdown module is free and works fine.

The real question is: how much of the publishing pipeline do you want automated? If the answer is "all of it," there's only one option.

Kjetil Furås builds automations with AI agents and infrastructure as code. Follow along on X or join the Build & Automate community on Skool.

Write First, Sync Later: How Notipo Works Without Notion

Kjetil Furås — Sun, 19 Apr 2026 18:14:07 +0000

You don't need Notion to use Notipo. Write in the built-in markdown editor, and Notipo handles images, SEO, code highlighting, and WordPress publishing automatically.

People keep asking me if they need Notion to use Notipo. The name doesn't help — "Notipo" sounds like it's all about Notion. Fair assumption, but no. You can use Notipo without ever opening Notion.

Here's how the writing-first flow works, step by step.

Step 1: Connect Your WordPress Site

After signing up, you add your WordPress site using an application password. This takes about two minutes. Notipo verifies the connection and pulls in your existing categories and tags.

That's the only setup. No Notion OAuth, no database template, no workspace configuration.

Step 2: Write in the Markdown Editor

Click "New Post" and you get a clean markdown editor. No distractions, no sidebar, no block palette. Just a title field and a writing area.

The editor supports standard markdown: headings, bold, italic, links, ordered and unordered lists, blockquotes, inline images, and fenced code blocks. If you've written a GitHub README, you already know the syntax.

You can also set the category, tags, and SEO metadata (focus keyword, meta title, meta description) right from the editor. These fields are optional — Notipo will generate sensible defaults if you leave them blank.

Step 3: Hit Publish

When you're ready, click Publish. Here's what Notipo does behind the scenes:

Markdown to Gutenberg — your markdown is converted to proper WordPress Gutenberg blocks, not just raw HTML. This means your posts look native in the WordPress editor if you ever need to edit them there.
Image upload — any images in your post are uploaded to your WordPress media library with permanent URLs. No expiring links, no broken images.
Featured image — if you have AI featured images enabled (Pro), Notipo generates a branded 1200×628 image based on your title and category.
Code highlighting — fenced code blocks are converted to Prismatic plugin blocks with automatic language detection.
SEO metadata — Notipo writes your focus keyword, meta title, and meta description directly to Rank Math via its REST API.

The entire process takes about 10 seconds. You get a link to the live WordPress post when it's done.

What About Drafts?

You don't have to publish immediately. Save as draft and the post sits in your Notipo dashboard. You can preview, edit, and publish when you're ready. You can also publish to WordPress as a draft first — it creates the post with "Draft" status so you can preview it on your actual site before going live.

The API Route

There's a third way to get content into Notipo: the API. Send a POST request with your markdown content, title, and metadata, and Notipo creates and publishes the post. This is how AI agents publish through Notipo — one HTTP request handles everything.

So the full picture is three input methods:

Markdown editor — write directly in the browser
Notion sync — connect your workspace and publish by changing a status
API — send content programmatically

All three feed into the same pipeline. Same image handling, same SEO, same code highlighting, same WordPress publishing. The only difference is where the content starts.

When to Add Notion Later

The "sync later" part of the title is real. Some users start with the editor, get comfortable with the publishing pipeline, and then connect Notion when they want a more structured editorial workflow — databases, properties, status-based publishing, team collaboration.

Notion sync is great if you already use Notion for content planning. But it's not a prerequisite. You can publish hundreds of posts through the editor and never touch Notion.

Try It Now

The free plan gives you 5 posts per month with the markdown editor, code highlighting, and SEO metadata. Sign up here — you can publish your first post in about five minutes.

Kjetil Furås builds automations with AI agents and infrastructure as code. Follow along on X or join the Build & Automate community on Skool.

Why We Built a Markdown Editor for WordPress

Kjetil Furås — Sun, 19 Apr 2026 18:13:35 +0000

60% of Notipo signups never finished onboarding because Notion was required. So I built a markdown editor that publishes to WordPress directly — no Notion needed.

The Data That Changed Everything

When I launched Notipo, the pitch was simple: connect your Notion workspace, change a status, and your post publishes to WordPress automatically. Images, SEO metadata, code highlighting — all handled. I thought the Notion integration was the product.

Turns out, I was wrong.

A few weeks after launch, I opened PostHog and looked at the funnel. People were signing up — that part was working. But 60% of them never finished onboarding. They'd create an account, see the "Connect your Notion workspace" step, and leave.

At first I assumed the OAuth flow was confusing. Maybe the Notion permissions screen was scaring people off. So I simplified the copy, added a video walkthrough, made the button bigger. Nothing changed.

Then I started talking to users who did make it through. The pattern was obvious: the people who loved Notipo were already heavy Notion users. They had databases, templates, editorial calendars. For them, connecting Notion was natural.

But the people who bounced? They wanted to write and publish to WordPress. That's it. They didn't use Notion. They didn't want to learn Notion. They just wanted a clean writing experience that ended with a published WordPress post.

The Wrong Assumption

I'd built Notipo around my own workflow. I write in Notion because I like it — the block editor, the databases, the properties. For me, the Notion-to-WordPress pipeline is the natural way to publish. I assumed everyone else felt the same way.

That assumption filtered into everything: the landing page led with "Notion to WordPress," the onboarding required a Notion connection before you could do anything, and the blog content was entirely about Notion workflows. If you weren't a Notion user, the whole product felt like it wasn't for you.

The real value of Notipo was never the Notion integration. It was everything that happens after you write — the automatic image handling, the SEO metadata, the code syntax highlighting, the one-click WordPress publishing. The Notion connection was just one way to get content in.

Building the Editor

So I built a markdown editor directly into Notipo. The goal was straightforward: give people a clean place to write that feeds into the same publishing pipeline — without requiring any external tools.

You open the editor, write your post in markdown, add a title and category, and hit publish. Notipo converts the markdown to WordPress Gutenberg blocks, uploads any images to your media library, generates a featured image if you have that enabled, sets your Rank Math SEO metadata, and publishes. Same pipeline as the Notion flow, different input.

The editor supports everything you'd expect: headings, lists, bold/italic, links, inline images, and fenced code blocks with language detection. It's not trying to be VS Code or Notion — it's a focused writing tool that gets out of the way.

Notion Didn't Go Away

The Notion integration is still there and it's still great. If you write in Notion, you can still connect your workspace and publish by changing a status. Nothing about that workflow changed.

What changed is the positioning. Notion is now a power-user add-on, not the core experience. The onboarding no longer requires a Notion connection. You can sign up, connect your WordPress site, and publish your first post in under five minutes — all without ever hearing the word "Notion."

What I Learned

The biggest lesson was that your own workflow is a terrible proxy for your users' workflow. I used Notion, so I assumed everyone did. The data said otherwise.

The second lesson was that the core value of a product isn't always where you think it is. I thought the value was "Notion to WordPress." The actual value was "write once, publish to WordPress with everything handled." The input method — Notion, markdown editor, API — was just a detail.

If you're building a product and your onboarding has a step that makes 60% of users leave, don't try to optimize that step. Ask whether it should be required at all.

Try It

The markdown editor is live now for all users, including the free plan. Sign up, connect your WordPress site, and publish your first post. No Notion required.

Kjetil Furås builds automations with AI agents and infrastructure as code. Follow along on X or join the Build & Automate community on Skool.

How to Publish Notion Pages to the Web (With SEO and Your Own Domain)

Kjetil Furås — Sat, 18 Apr 2026 08:50:13 +0000

Notion's "Publish to web" button is the fastest way to share a page publicly. It's also the worst way to publish content you want people to actually find. No custom domain. No meta tags. No sitemap. Images hosted on temporary S3 URLs that expire within an hour. Google can't reliably index it, and readers see a notion.site URL instead of your brand.

If you want to publish Notion pages as real web content — with your own domain, SEO metadata, permanent images, and analytics — you need a publishing layer between Notion and the web. WordPress is the most common choice, and Notipo connects the two automatically.

Why Notion's Built-in Publishing Falls Short

Notion's native publish feature was designed for quick sharing, not for content that needs to rank or convert. Here's what's missing:

No custom domain — every page lives on yourworkspace.notion.site. You can't point your own domain at it without third-party workarounds.
No SEO control — no meta descriptions, no focus keywords, no canonical URLs. Google sees a generic Notion page with no optimization signals.
Temporary images — Notion serves images from AWS S3 with signed URLs that expire after about one hour. Shared links, social previews, and cached pages all break once the URL rotates.
No analytics — no page views, no traffic sources, no conversion tracking. You're publishing blind.
No sitemap or RSS — search engines have no structured way to discover your pages.

For internal docs or team wikis, none of this matters. For blog posts, landing pages, or any content meant to attract organic traffic, it's a dealbreaker.

The Two Approaches to Publishing Notion Pages

1. Notion as a headless CMS with a custom frontend

Frameworks like Next.js or Astro can pull content from the Notion API and render it as static pages. This gives you full control over design and hosting, but you're building and maintaining a custom site. Every Notion block type needs a renderer. Image expiry needs a caching layer. SEO needs manual wiring. It works, but it's a development project, not a publishing workflow.

2. Notion synced to WordPress

WordPress already handles domains, SEO, sitemaps, analytics, and image hosting. The missing piece is getting content from Notion into WordPress without copy-pasting. A sync tool like Notipo bridges this gap — content flows from Notion to WordPress automatically, and WordPress handles everything else.

How Notipo Publishes Notion Pages to WordPress

The pipeline is straightforward:

Write in Notion — use a database with properties for title, slug, category, tags, SEO keyword, and meta description.
Connect Notion and WordPress — Notipo connects to both via OAuth (Notion) and application passwords (WordPress). Setup takes about two minutes.
Publish — change the page status or trigger a sync. Notipo converts Notion blocks to Gutenberg blocks, downloads and re-uploads images to your WordPress media library (permanent URLs), writes SEO metadata to your plugin, and optionally generates a featured image.
Update — edit the Notion page and re-sync. Notipo updates the existing WordPress post in place — same URL, same post ID, no duplicates.

What Gets Synced

Every sync handles the full content stack:

Text and formatting — headings, bold, italic, links, lists, blockquotes, callouts, toggles, dividers. Notion blocks map to Gutenberg blocks.
Images — every image is downloaded from Notion's temporary URL and uploaded to your WordPress media library. The published post uses permanent WordPress URLs, not expiring S3 links.
Code blocks — language detection preserved. Pair with Highlight.js or Prism.js for syntax highlighting.
SEO metadata — focus keyword, SEO title, and meta description written directly to your SEO plugin. Notipo auto-detects Rank Math, Yoast SEO, SEOPress, and All in One SEO.
Featured images — generated automatically from the post title, or use a cover image from Notion.
Categories and tags — mapped from Notion properties to WordPress taxonomies.

Setting Up Your Notion Database

Your Notion database needs a few standard properties:

Title — the page title (built-in Notion property)
Slug — text property for the URL path
Category — select property matching your WordPress categories
Tags — multi-select property for WordPress tags
SEO Keyword — text property for the focus keyword
Meta Description — text property for the meta description
Status — select property (Draft, Review, Publish)

Publishing via the API or CLI

Beyond the web dashboard, Notipo exposes a REST API and CLI for programmatic publishing. A single API call handles the entire pipeline:

curl -X POST https://notipo.com/api/posts \
  -H "X-API-Key: your-api-key" \
  -H "Content-Type: application/json" \
  -d '{
    "title": "My Notion Page",
    "body": "# Content in markdown",
    "category": "Blog",
    "seoKeyword": "publish notion pages",
    "slug": "my-notion-page"
  }'

The API creates a Notion page, syncs it to WordPress, uploads images, writes SEO metadata, and generates a featured image — all in one request.

Notion Publishing vs. Other Approaches

Notion native publish — instant, no setup. But no SEO, no custom domain, broken images after an hour. Only useful for quick internal sharing.
Super.so / Potion.so — wraps Notion pages with a custom domain and some styling. Still depends on Notion's rendering, limited SEO control, and you're locked into their proxy layer.
Custom Next.js / Astro site — maximum flexibility, but you're maintaining a codebase. Every new Notion block type needs a custom renderer.
Notipo + WordPress — Notion stays your writing tool, WordPress handles publishing. Full SEO control, permanent images, 4 SEO plugins supported, featured image generation. No code to maintain.

Limitations to Know

One-way sync — content flows from Notion to WordPress only. Edits in wp-admin don't sync back to Notion. Notion is the source of truth.
WordPress required — Notipo publishes to self-hosted WordPress sites. It doesn't work with WordPress.com free plans or non-WordPress platforms.
Block coverage — most Notion block types are supported. Databases-as-content and some advanced layouts may not map perfectly to Gutenberg blocks.

FAQ

Can I publish Notion pages to the web?

Notion has a built-in "Publish to web" option, but it uses a notion.site subdomain with no SEO control, no custom domain, and temporary image URLs. To publish properly — with your own domain and permanent images — sync to WordPress using Notipo.

Do Notion published pages show up on Google?

Notion's native published pages are not reliably indexed. They lack meta descriptions, canonical URLs, sitemaps, and structured data. Publishing to WordPress through Notipo gives you full SEO control.

Is there a free way to publish Notion pages to WordPress?

Notipo's free tier lets you publish up to 5 pages per month — including image caching, SEO metadata, and featured image generation. No credit card required. Pro is $19/month with a 7-day free trial.

Create a free Notipo account and start publishing Notion pages to WordPress in about two minutes.

Notion CMS: Can You Use Notion as a Content Management System?

Kjetil Furås — Sat, 18 Apr 2026 08:45:32 +0000

Notion has everything you'd expect from a content management system. Databases with custom properties. Rich text editing. Status columns for editorial workflows. Drag-and-drop media. Templates. Collaboration. It looks like a CMS, and many teams already use it as one.

But Notion was built for internal docs and project management — not for publishing content to the web. The moment you need a custom domain, SEO control, permanent image URLs, or analytics, Notion stops being enough. The question isn't whether Notion can be a CMS. It's whether Notion can be your CMS — and what you need to add to make it work.

What Makes Notion Work as a CMS

Notion's database features map surprisingly well to CMS requirements:

Databases as content types — each database is a content collection. Blog posts, landing pages, documentation — one database per type, with custom properties for metadata.
Properties as fields — title, slug, category, tags, author, publish date, SEO keyword, meta description. Every field a traditional CMS offers, you can create as a Notion property.
Status workflows — Draft, In Review, Published. Notion's status property gives you a basic editorial pipeline.
Rich content editing — headings, images, code blocks, callouts, tables, toggles, embeds. Notion's block editor handles most content types.
Real-time collaboration — multiple writers and editors working on the same page simultaneously, with comments and mentions.
Templates — create a blog post template with pre-filled properties and placeholder content. Every new post starts from a consistent structure.

For content creation and editorial management, Notion is genuinely excellent. Most dedicated CMS platforms have worse editing experiences.

Where Notion Falls Short as a CMS

The gap appears when you try to publish. A CMS needs to serve content to readers, and Notion wasn't designed for that:

No custom domains — Notion's "Share to Web" publishes to notion.site subdomains. You can't serve content from your own domain without a third-party wrapper.
No SEO control — no meta descriptions, no focus keywords, no Open Graph tags, no structured data. Google sees your content but can't rank it properly.
Temporary image URLs — Notion stores images on Amazon S3 with signed URLs that expire after about one hour. Any system that embeds Notion image URLs directly will show broken images within hours.
No sitemap — search engines rely on sitemaps to discover content. Notion doesn't generate one.
No analytics — no Google Analytics, no Search Console, no conversion tracking. You can't measure what's working.
No page speed optimization — Notion pages are JavaScript-heavy SPAs. Core Web Vitals scores are poor compared to server-rendered HTML.
No plugins or extensions — WordPress has 60,000+ plugins for forms, e-commerce, membership, caching. Notion has none of this.

These aren't minor gaps. They're the difference between a content editor and a publishing platform.

How to Use Notion as a Headless CMS for WordPress

The term "headless CMS" means separating where you create content from where you display it. Notion becomes the backend (the "body"), and WordPress becomes the frontend (the "head"). A sync tool connects the two.

Here's how the Notion CMS pipeline works with Notipo:

Set up your Notion database — create a database with properties for Title, Slug, Category, Tags, SEO Keyword, Meta Description, and Status.
Connect Notion to Notipo — authorize your Notion workspace via OAuth.
Connect WordPress — add your WordPress site URL and an application password.
Write in Notion — headings, images, code blocks, callouts, and tables all sync to WordPress as Gutenberg blocks.
Publish — change the Status property to Publish. Notipo syncs everything including images to the WordPress media library, SEO metadata to your plugin, and generates a featured image.

The sync is one-way: Notion to WordPress. Notion is always the source of truth.

SEO With a Notion CMS

Notipo auto-detects and writes metadata to four SEO plugins:

Rank Math — focus keyword, SEO title, meta description
Yoast SEO — focus keyword, SEO title, meta description
SEOPress — target keyword, title, description
All in One SEO — focus keyword, title, description

No configuration needed. Install any of these plugins on your WordPress site, add SEO Keyword and Meta Description properties to your Notion database, and Notipo handles the rest.

The Image Problem (and the Fix)

Every Notion CMS setup has to solve the image problem. Notion stores images on Amazon S3 with temporary signed URLs that expire after approximately one hour.

Notipo solves this by downloading each image during sync and uploading it to your WordPress media library. The WordPress URL is permanent. On subsequent syncs, it checks which images are already cached and only uploads new or changed ones.

Pricing

Notion — free plan covers unlimited pages and databases
WordPress hosting — starts around $3/month
Notipo Free — 5 posts per month, full image caching, SEO metadata sync
Notipo Pro — $19/month for unlimited posts, AI-generated featured images, and priority sync. 7-day free trial, no credit card required.

FAQ

Can Notion be used as a CMS?

Notion works well as a content management backend — databases, properties, status workflows, and rich editing. But it lacks publishing features like custom domains, SEO metadata, sitemaps, and permanent image URLs. To use Notion as a full CMS, pair it with WordPress and a sync tool like Notipo.

Is Notion better than WordPress as a CMS?

Notion is a better writing and content organization tool. WordPress is a better publishing platform. The ideal setup uses both: Notion for drafting, WordPress for SEO and serving content. Notipo connects the two automatically.

Does Notion have an API for CMS use?

Yes. The Notion API lets you read pages and database entries programmatically. Sync tools like Notipo use the API to pull content and publish it to WordPress — including images, formatting, and metadata.

What are the limitations of using Notion as a CMS?

Notion images use temporary S3 URLs that expire after about one hour. There's no built-in SEO control, no custom domains for published pages, no sitemap generation, and no analytics.

Notion WordPress Integration: Connect Notion to WordPress in 2026

Kjetil Furås — Sat, 18 Apr 2026 08:28:56 +0000

Notion is where you write. WordPress is where you publish. The problem: there's no official Notion WordPress integration. Connecting them requires a third-party tool, and the tool you pick determines whether images break, SEO metadata transfers, and formatting survives the move.

This guide covers every way to integrate Notion with WordPress — what each approach handles, what it doesn't, and how to set up a sync that actually works.

Why Notion and WordPress Need an Integration

Notion is a better writing environment than the WordPress editor. Drag-and-drop blocks, inline databases, slash commands, nested pages — writers are faster in Notion. But Notion has no SEO, no custom domain, no analytics, and Google rarely indexes Notion pages.

WordPress handles all of that. What it lacks is a good writing experience. The ideal setup: write in Notion, publish to WordPress, and never copy-paste between them.

A Notion WordPress integration bridges this gap. It reads your Notion content, converts it to WordPress-compatible format (Gutenberg blocks), handles images, maps SEO metadata, and publishes.

What a Good Integration Must Handle

Not all Notion-to-WordPress integrations are equal. The critical features:

Image handling — Notion stores images on S3 with temporary URLs that expire in about an hour. The integration must download images and upload them to your WordPress media library.
SEO metadata — focus keyword, meta description, and SEO title should transfer to your SEO plugin (Rank Math, Yoast, SEOPress, or All in One SEO)
Featured images — either mapped from a Notion property or auto-generated
Code blocks — language metadata must survive so syntax highlighting works
Gutenberg blocks — content should convert to proper WordPress blocks, not raw HTML
Categories and tags — mapped from Notion database properties
Re-sync — updating a post in Notion should update the same WordPress post, not create a duplicate

Option 1: Notipo (API-Based Sync)

Notipo is a dedicated Notion-to-WordPress sync service. It connects to both platforms via their APIs and handles the full content pipeline.

How It Works

Connect your Notion workspace via OAuth
Connect WordPress with your site URL and an application password
Duplicate the Notipo template database into your workspace
Write a post in Notion, fill in properties (category, tags, SEO keyword, meta description)
Set the status to "Publish" — Notipo syncs automatically

What Notipo Handles

Images downloaded and uploaded to WordPress media library (permanent URLs)
SEO metadata written to Rank Math, Yoast, SEOPress, or All in One SEO
Featured images auto-generated (standard or AI-powered on Pro)
Code blocks with language metadata preserved
Gutenberg block conversion for headings, lists, quotes, callouts, toggles
Categories and tags mapped from Notion database properties
Re-syncs update the existing WordPress post — no duplicates

API and CLI Access

Notipo Pro includes a REST API and CLI for programmatic publishing:

# Publish a post via the Notipo CLI
npx notipo publish \
  --title "My Blog Post" \
  --body "Markdown content here..." \
  --category "Guides" \
  --seo-keyword "target keyword" \
  --slug "my-blog-post"

Pricing

Free — 5 posts/month, full image handling, SEO metadata, code highlighting, standard featured images
Pro ($19/month) — unlimited posts, AI featured images, instant sync, REST API and CLI access. 7-day free trial, no credit card required.

Option 2: WP Sync for Notion (WordPress Plugin)

WP Sync for Notion is a WordPress plugin that pulls content from Notion. You install it on your WordPress site, connect your Notion API key, and link individual pages or databases.

Free — sync individual Notion pages, basic content conversion, image downloading, manual sync trigger
Pro (~$9/month) — full database sync, scheduled/webhook sync, SEO plugin integration, property mapping

Option 3: Zapier or Make (Automation Platforms)

Zapier and Make can create a basic Notion WordPress integration. The trigger watches a Notion database, and the action creates a WordPress post via the REST API.

What breaks: Images (Notion S3 URLs expire within an hour), formatting (raw block data needs Gutenberg conversion), SEO metadata (not handled natively), featured images (not handled), re-syncs (need extra logic).

Option 4: Custom Integration via Notion API

Build a custom integration using the Notion API and the WordPress REST API:

// Pseudocode: custom Notion → WordPress sync
const notionPage = await notion.pages.retrieve({ page_id });
const blocks = await notion.blocks.children.list({ block_id: page_id });

// Convert Notion blocks to Gutenberg HTML
const gutenbergHtml = convertBlocks(blocks.results);

// Download images from Notion S3 URLs before they expire
const processedHtml = await downloadAndReplaceImages(gutenbergHtml, wpClient);

// Create or update WordPress post
await wp.posts.create({
  title: notionPage.properties.Title.title[0].plain_text,
  content: processedHtml,
  status: "publish",
});

Building this from scratch means handling every edge case yourself: nested blocks, image expiry, Gutenberg block syntax, SEO plugin meta keys, featured image generation, and update-vs-create logic.

Important: All Integrations Are One-Way

Every Notion WordPress integration available today syncs in one direction: Notion to WordPress. You write and edit in Notion, and changes flow to WordPress. Notion is the single source of truth.

FAQ

Does Notion have a built-in WordPress integration?

No. You need a third-party tool — Notipo, WP Sync for Notion, or an automation platform.

What is the best Notion to WordPress integration?

Notipo is the most complete option — images, SEO for 4 plugins, featured images, code highlighting, and Gutenberg blocks. WP Sync is simpler but needs Pro for SEO and database sync.

Can I sync Notion to WordPress automatically?

Yes. Notipo watches a Notion database and syncs on status change. WP Sync Pro supports scheduled sync.

Originally published at notipo.com/blog/notion-wordpress-integration