DEV Community: Kjetil Furås

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

Build a Custom MCP Server in Python in 2026

Kjetil Furås — Fri, 17 Apr 2026 09:14:59 +0000

Building tools that Claude Code can call directly from your terminal changes how you work with AI. Instead of copy-pasting data into prompts, you give Claude direct access to your systems through MCP servers.

I've built several MCP servers in Python — for WordPress publishing, Skool community management, and YouTube analytics. Every one follows the same pattern. Here's exactly how to build a custom MCP server in Python from scratch using the official SDK.

What Is an MCP Server?

MCP (Model Context Protocol) is an open standard from Anthropic that lets AI assistants call external tools. You define tools with typed inputs and outputs. Claude Code calls them mid-conversation like native functions.

The protocol runs over JSON-RPC through stdio. Your server starts as a subprocess that Claude Code spawns and talks to via stdin/stdout. No HTTP. No webhooks. Just a Python process that reads and writes JSON.

If you've built a CLI tool before, building an MCP server is simpler.

Set Up the Project

Start with a clean directory and install the MCP Python SDK:

mkdir my-mcp-server && cd my-mcp-server
python3 -m venv .venv && source .venv/bin/activate
pip install mcp[cli]

The mcp[cli] package includes the server framework and a dev inspector for testing. That's the only dependency you need.

Build Your First Tool

Create server.py. Every MCP server follows the same structure: create a server instance, define tools with decorators, and run the stdio transport.

from mcp.server.fastmcp import FastMCP

mcp = FastMCP("my-tools")


@mcp.tool()
def get_system_info() -> str:
    """Return basic system information."""
    import platform

    return (
        f"OS: {platform.system()} {platform.release()}\n"
        f"Python: {platform.python_version()}\n"
        f"Machine: {platform.machine()}"
    )


@mcp.tool()
def count_files(directory: str, extension: str = "") -> str:
    """Count files in a directory, optionally filtered by extension.

    Args:
        directory: Path to the directory to scan
        extension: File extension to filter by (e.g. '.py', '.json')
    """
    from pathlib import Path

    path = Path(directory).expanduser()
    if not path.is_dir():
        return f"Error: {directory} is not a valid directory"

    if extension:
        files = list(path.rglob(f"*{extension}"))
    else:
        files = [f for f in path.rglob("*") if f.is_file()]

    return f"Found {len(files)} files in {directory}" + (
        f" matching {extension}" if extension else ""
    )


if __name__ == "__main__":
    mcp.run(transport="stdio")

Three things to notice:

The @mcp.tool() decorator registers a function as a callable tool. The function name becomes the tool name.
Type hints on parameters are required. MCP uses them to generate the JSON schema that Claude reads.
The docstring becomes the tool description. Claude uses this to decide when to call it. Write it like you're explaining to a colleague.

Add a Tool With External API Access

Most useful MCP servers talk to external services. Here's a tool that checks the status of a website:

import httpx


@mcp.tool()
async def check_website(url: str) -> str:
    """Check if a website is reachable and return its status code and response time.

    Args:
        url: Full URL to check (e.g. https://example.com)
    """
    async with httpx.AsyncClient(timeout=10) as client:
        try:
            response = await client.get(url)
            return (
                f"Status: {response.status_code}\n"
                f"Response time: {response.elapsed.total_seconds():.2f}s\n"
                f"Content-Type: {response.headers.get('content-type', 'unknown')}"
            )
        except httpx.RequestError as e:
            return f"Error reaching {url}: {str(e)}"

Async tools work out of the box. The MCP SDK handles the event loop. Use httpx for HTTP calls — it's async-native and comes with timeout handling.

Install it alongside the SDK:

pip install httpx

Test Before Connecting to Claude

The MCP CLI includes a dev inspector that lets you test tools without Claude:

mcp dev server.py

This opens a web UI where you can call each tool, inspect the JSON schema, and verify outputs. Fix issues here before connecting to Claude Code — debugging inside a conversation is slower.

Connect to Claude Code

Add your server to Claude Code's MCP configuration. Open .claude/settings.json in your project root:

{
  "mcpServers": {
    "my-tools": {
      "command": "/path/to/my-mcp-server/.venv/bin/python",
      "args": ["server.py"],
      "cwd": "/path/to/my-mcp-server"
    }
  }
}

Use the full path to the Python binary inside your venv. Claude Code spawns this as a subprocess. If you use a relative path or the system Python, it won't find your installed packages.

Restart Claude Code. Your tools appear as mcp__my-tools__get_system_info, mcp__my-tools__count_files, and mcp__my-tools__check_website.

Add Resources for Context

Tools handle actions. Resources handle data that Claude reads as context. Use them for configuration, reference data, or live state:

@mcp.resource("config://settings")
def get_settings() -> str:
    """Current server configuration."""
    import json

    settings = {
        "version": "1.0.0",
        "tools_registered": 3,
        "max_timeout": 10,
    }
    return json.dumps(settings, indent=2)

Claude can read this resource to understand your server's capabilities before calling tools.

Error Handling That Works

MCP tools should never raise unhandled exceptions. A crash kills the server process and disconnects all tools mid-conversation. Wrap external calls and return error strings:

@mcp.tool()
def read_config(path: str) -> str:
    """Read a configuration file and return its contents.

    Args:
        path: Path to the config file
    """
    from pathlib import Path

    try:
        config_path = Path(path).expanduser()
        if not config_path.exists():
            return f"Error: {path} does not exist"
        if config_path.stat().st_size > 100_000:
            return f"Error: {path} is too large (>100KB)"
        return config_path.read_text()
    except PermissionError:
        return f"Error: no permission to read {path}"
    except Exception as e:
        return f"Error reading {path}: {str(e)}"

Return errors as strings, not exceptions. Claude reads the error message and adjusts — retries with a different path, asks the user for help, or moves on. An unhandled exception just kills the connection.

Project Structure for Production

Once your server grows past 3-4 tools, split into modules:

my-mcp-server/
  server.py          # Entry point — imports and registers tools
  tools/
    system.py        # System info tools
    web.py           # HTTP/API tools
    files.py         # File operation tools
  requirements.txt

Keep server.py minimal. Import tools from modules so each file stays focused:

from mcp.server.fastmcp import FastMCP

mcp = FastMCP("my-tools")

# Import tool modules — decorators register on import
import tools.system  # noqa: F401
import tools.web     # noqa: F401
import tools.files   # noqa: F401

if __name__ == "__main__":
    mcp.run(transport="stdio")

Each tool module imports the shared mcp instance and uses @mcp.tool() as usual. This pattern scales to 20+ tools without the main file becoming unreadable.

Common Mistakes

Printing to stdout. MCP uses stdout for JSON-RPC. Any print() statement corrupts the protocol and crashes the connection. Use logging to stderr instead:

import logging
import sys

logging.basicConfig(stream=sys.stderr, level=logging.INFO)
logger = logging.getLogger(__name__)

Missing type hints. Every parameter needs a type annotation. Without one, the MCP SDK can't generate the JSON schema, and Claude won't know what arguments to pass.

Blocking the event loop. If you have a CPU-heavy tool, run it in an executor. The MCP server is single-threaded — a blocking call freezes all tools:

import asyncio


@mcp.tool()
async def heavy_computation(data: str) -> str:
    """Run a CPU-intensive task without blocking other tools."""
    loop = asyncio.get_event_loop()
    result = await loop.run_in_executor(None, process_data, data)
    return result

FAQ

Do I need to restart Claude Code after changing my MCP server?

Yes. Claude Code loads the MCP configuration at startup and spawns servers as subprocesses. After editing server.py, restart Claude Code to pick up changes. The mcp dev inspector is faster for iterating.

Can one MCP server connect to multiple AI clients?

Yes. The MCP protocol is client-agnostic. The same server works with Claude Code, Claude Desktop, and any other MCP-compatible client. No code changes needed — just point each client to your server's entry point.

What's the difference between tools and resources?

Tools perform actions — they take inputs, do something, and return results. Resources provide read-only context — configuration, reference data, live state. Claude reads resources for background knowledge and calls tools to take action.

Is there a limit on how many tools one server can expose?

No hard limit in the protocol. I run servers with 10-15 tools without issues. If you go past 20, consider splitting into multiple servers by domain (one for database ops, one for API calls, etc.) to keep tool descriptions focused.

I'm documenting the full build process — MCP servers, Claude Code agent patterns, and autonomous workflows — in my Build & Automate community. If you want step-by-step modules with real production code, that's where it's happening.

This post was published using Notipo — my Notion-to-WordPress sync tool. Write in Notion, publish to WordPress automatically.

Sync Notion to WordPress: Keep Your Content in Sync Automatically

Kjetil Furås — Thu, 16 Apr 2026 12:38:25 +0000

You write in Notion. Your blog runs on WordPress. The gap between them is where you lose 15-30 minutes per post — copy-pasting content, re-uploading images, setting SEO fields, fixing formatting that breaks in Gutenberg.

There are several ways to publish from Notion to WordPress automatically. This guide covers the main options, when each one makes sense, and how to set up the fastest workflow.

Why publish from Notion to WordPress?

Notion is a better writing environment than the WordPress editor. Markdown-style formatting, nested pages, databases with properties, inline images — it's where most writers already work.

WordPress is a better publishing platform. Custom domains, SEO plugins, themes, full control over your site. Over 40% of the web runs on WordPress.

The problem: getting content from one to the other is tedious. Manual copy-paste breaks formatting. Images need re-uploading. Categories, tags, featured images, and meta descriptions need setting manually. A 1,000-word post takes 5 minutes to write and 15 minutes to publish.

The solution: automate the sync. Write in Notion, publish to WordPress with one action.

Option 1: Notipo — API-first Notion to WordPress sync

Notipo connects your Notion database to your WordPress site. When you change the status of a page in Notion to "Publish," it syncs the content to WordPress automatically — including images, SEO metadata, categories, tags, and featured images.

How it works

Sign up at notipo.com (free plan available)
Connect your Notion workspace (one-click OAuth)
Connect your WordPress site (enter URL, click approve in WP admin)
Write a post in Notion, set the status to "Publish"
Notipo converts the Notion content to WordPress blocks and publishes it

What syncs automatically

Content — headings, paragraphs, lists, code blocks, quotes, callouts, toggle blocks
Images — uploaded to your WordPress media library automatically
SEO metadata — focus keyword and meta description from Notion properties
Categories and tags — mapped from your Notion database
Featured images — AI-generated from Unsplash or Google Gemini on the Pro plan
Code highlighting — syntax highlighting preserved with language detection

API and CLI access

Notipo also has a REST API and CLI tool for automation:

notipo posts create \
  --title "My Post Title" \
  --body "$(cat post.md)" \
  --category "Tutorial" \
  --seo-keyword "target keyword" \
  --publish --wait

This is how AI coding agents like Claude Code publish blog posts — one command, full SEO, no manual work.

Pricing

Free — 5 posts/month, one-click WordPress setup, SEO metadata, code highlighting
Pro ($19/month) — Unlimited posts, AI featured images, instant sync, priority support, 7-day free trial

Option 2: WP Sync for Notion (WordPress plugin)

WP Sync for Notion is a WordPress plugin by WPConnect. Install it, connect your Notion database, and it pulls content into WordPress posts.

Limitations

Requires a WordPress plugin installation
Free version only syncs individual pages, not databases
Pro version needed for database sync, custom post types, and SEO plugin integration
Image handling can be inconsistent (Notion image URLs expire)

Option 3: Zapier or Make

Connect Notion and WordPress through Zapier or Make. When a Notion database item changes status, a Zap or scenario creates a WordPress post via the REST API.

Cons

Requires paid plan for multi-step workflows
Content formatting is basic — you lose rich blocks like callouts, toggles, and code highlighting
Images require extra steps to transfer (Notion image URLs expire after 1 hour)
Ongoing maintenance when APIs change

Option 4: Cloudpress

Cloudpress exports content from Notion to WordPress, Webflow, and other CMS platforms.

Limitations

Export-based, not sync-based — changes in Notion require a new export
Priced per export ($0.50-$1 per article on lower plans)
No automatic publishing on status change

Which option should you pick?

Choose Notipo if you want automatic one-way sync (Notion to WordPress) triggered by a Notion status change. Best for bloggers and content teams who publish regularly and want zero manual steps.

Choose WP Sync for Notion if you prefer a WordPress plugin approach and want everything managed from your WordPress dashboard.

Choose Zapier/Make if you need a custom multi-step workflow that goes beyond Notion-to-WordPress.

Choose Cloudpress if you export occasionally rather than publishing regularly.

Common issues when syncing Notion to WordPress

Images break after sync. Notion serves images through temporary signed URLs that expire after 1 hour. Any sync tool must download and re-upload images to your WordPress media library.

Formatting doesn't match. Notion blocks don't map 1:1 to WordPress Gutenberg blocks. Callouts, toggle lists, and synced blocks need special handling.

SEO metadata gets lost. Unless your tool explicitly maps Notion properties to your SEO plugin, you'll need to set meta descriptions and focus keywords manually.

FAQ

Can I use Notion as a full CMS for WordPress?

Yes. With the right sync tool, Notion becomes your content editor and WordPress becomes your publishing platform. You never need to open the WordPress editor.

Do I need a self-hosted WordPress site?

For most sync tools, yes. Self-hosted WordPress (wordpress.org) supports the REST API and application passwords needed for automated publishing.

Will my existing WordPress theme work?

Yes. Notion-to-WordPress sync tools create standard WordPress posts with Gutenberg blocks. Your theme displays them like any other post.

What happens if I edit the post in Notion after publishing?

With sync-based tools like Notipo, changes in Notion automatically update the WordPress post. With export-based tools like Cloudpress, you need to re-export manually.

Build a Sales Follow-Up Agent With the Claude Agent SDK

Kjetil Furås — Tue, 14 Apr 2026 09:42:54 +0000

A Norwegian sales manager just told VG his team closed 1,000+ deals in three months using AI agents. He called it "going from cycling to flying a jet." He didn't say which tools. So I'll show you how to build one yourself with the Claude Agent SDK — the same SDK I use to run Koda, my autonomous marketing agent.

This is a working claude agent sdk tutorial you can fork today. No theory. No "imagine if." Real code, real tools, real scheduling.

What the agent actually does

A sales follow-up agent earns its keep by doing three boring things reliably:

Reads new leads from a CRM or spreadsheet
Decides which ones need a follow-up today based on rules you define
Drafts a personalized message and either sends it or queues it for approval

That's it. No magic. The boring version is what actually moves revenue.

Here's the shape of the agent loop:

from claude_agent_sdk import query, ClaudeAgentOptions

options = ClaudeAgentOptions(
    system_prompt=open("system.md").read(),
    allowed_tools=["Read", "Write", "Bash"],
    mcp_servers={
        "airtable": {
            "command": "npx",
            "args": ["-y", "airtable-mcp-server"],
            "env": {"AIRTABLE_API_KEY": os.environ["AIRTABLE_API_KEY"]},
        },
        "gmail": {
            "command": "python3",
            "args": ["-m", "gmail_mcp"],
        },
    },
)

async for message in query(
    prompt="Run the daily sales follow-up cycle. Read the skill file first.",
    options=options,
):
    print(message)

That's the whole runtime. The intelligence lives in two places: the system prompt and a skill file. The SDK handles tool calls, retries, and the model loop.

The system prompt is where the personality lives

Your agent needs to know who it is, what it's allowed to do, and what counts as done. I keep this short and specific.

You are a sales follow-up agent for Acme Co.

Your job: read leads from Airtable, identify who needs a follow-up today,
draft a message in my voice, and queue it as a Gmail draft for my review.

Rules:
- Never send emails directly. Always create drafts.
- Never follow up a lead more than once in 7 days.
- If a lead replied, mark them as active and stop the sequence.
- Log every action to ~/agent/logs/YYYY-MM-DD.md

Voice: direct, concise, first person. No "I hope this finds you well."
No hype words. One specific reason for the outreach. One clear ask.

Notice what's missing: no chain-of-thought prompts, no "think step by step," no roleplay. The SDK model is already good at reasoning. What it needs is boundaries and memory.

The skill file is the recipe

The system prompt says what the agent is. The skill file says how to do today's task. I keep mine in ~/agent/skills/daily-followup.md and reference it from the prompt.

# Daily Follow-Up Skill

## Steps

1. Fetch all Airtable records where `status = "lead"` and `last_contact < 7 days ago = false`.
2. For each lead, check Gmail for any reply from that email address.
3. If replied, update Airtable status to "active" and skip.
4. If not replied, draft a follow-up using the lead's company context.
5. Create a Gmail draft — do NOT send.
6. Log the action.

## Draft template

Subject: Re: {{previous_subject}}

Hi {{first_name}},

Following up on {{specific_thing_from_last_message}}.
{{one_sentence_with_new_angle_or_value}}.

Worth a quick call this week?

— {{sender_name}}

Skills are just markdown. No YAML, no DSL. The agent reads them as context and follows them. I keep a dozen of these for Koda — each covers a single recurring task.

Wire in real tools with MCP

The agent is useless without data. The Claude Agent SDK speaks MCP (Model Context Protocol), which means any MCP server becomes a tool the agent can call. For sales follow-up, I wire in three:

{
  "mcpServers": {
    "airtable": {
      "command": "npx",
      "args": ["-y", "airtable-mcp-server"]
    },
    "gmail": {
      "command": "python3",
      "args": ["-m", "gmail_mcp"]
    },
    "slack": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-slack"]
    }
  }
}

No custom glue code. No webhooks. The agent reads Airtable, reads Gmail, and posts to Slack when it needs approval — all through MCP. This is the piece most tutorials skip, and it's the piece that makes the agent useful in production.

Schedule it so it runs without you

An agent that only runs when you type a prompt is a chatbot. An agent that runs on a schedule is an employee. I use a simple JSON task file and a daemon that wakes the SDK at the scheduled time:

{
  "sales_followup": {
    "prompt": "Run the daily sales follow-up cycle. Read ~/agent/skills/daily-followup.md first.",
    "cron": "0 9 * * 1-5",
    "type": "approval"
  }
}

type: "approval" means the agent drafts and waits — it posts the drafts to my Slack and I either approve or reject each one. type: "silent" would ship them automatically. For sales outreach I always use approval until I trust the quality for a specific customer segment.

Cost and throughput

One daily run on 50 leads uses roughly 30-80k tokens with Sonnet. That's under $1 per day per agent. Flaaten's 1,000 conversions in three months suggests the team runs at least one outreach agent plus a qualification agent and a scheduler. Total SDK cost for that operation: maybe $100/month. The bottleneck is never the model. It's the quality of your lead list.

What breaks

Three things break in production:

Stale skill files. The agent follows the skill exactly. If the skill says "check Airtable" but you moved to HubSpot, it will quietly do nothing. Update the skill, not the prompt.
Tool permission drift. The SDK's allowed_tools list is a hard boundary. If you add a new MCP server and forget to allow it, the agent reports "I don't have a tool for that" and gives up. Allow explicitly.
Approval queue neglect. An approval-mode agent drafts faster than you review. If you don't review daily, the queue becomes noise and you lose the one message that actually mattered. Either review daily or switch segments to silent.

Why this pattern beats a workflow tool

No canvas. No boxes and arrows. No "here's how we connect step 3 to step 7." The Claude Agent SDK is a function call with a system prompt and a toolbox. The intelligence is in the model, the rules are in a markdown file, and the data comes from MCP servers. That's the whole stack.

I run five of these agents daily for my own work. One for sales outreach, one for content drafting, one for analytics, one for social scheduling, one for community engagement. Total code across all of them: under 500 lines.

I'm documenting the full build process — skills, scheduling, approval queues, and the production patterns that keep them stable — in my Build & Automate community. If you want step-by-step modules with real production code, that's where it's happening.

FAQ

Do I need a Claude Max subscription to use the Agent SDK?

No. The SDK works with an API key. You pay per token. For most agents running a few times a day, expect $10-50/month at Sonnet prices. Max is cheaper only if you're also using Claude Code interactively for hours a day.

Can I use this with a non-Claude model?

The Claude Agent SDK is Claude-specific, but the pattern — system prompt, skill files, MCP tools, scheduled runs — works with any agent framework. I prefer the Claude SDK because the tool-use is more reliable and MCP is natively supported.

How is this different from n8n or Make?

Workflow tools are explicit: every step, every branch, every condition is a box you draw. Agents are declarative: you describe the goal and constraints, and the model decides the path. For rigid processes, workflows win. For anything that requires judgment — "is this lead worth following up today?" — agents win.

Is it safe to let an agent send emails?

Not without approval, not at first. I run every outbound agent in approval mode for at least two weeks per customer segment. Only after the draft quality is boring and consistent do I flip to silent. Shortcuts here cost you the sender reputation.

This post was published using Notipo — my Notion-to-WordPress sync tool. Write in Notion, publish to WordPress automatically.

Using Notion as a WordPress CMS: The Complete Guide

Kjetil Furås — Mon, 13 Apr 2026 12:08:24 +0000

WordPress has a powerful editor, but many content teams prefer writing in Notion. The collaboration features, database views, and familiar interface make it a natural fit for managing blog content. The challenge is bridging the gap between where you write and where you publish.

This guide shows you how to use Notion as a full content management system for WordPress — from setting up your editorial database to automating the publish pipeline with Notipo.

Why Use Notion Instead of the WordPress Editor?

Real-time collaboration — Multiple people can edit the same page simultaneously. WordPress doesn't support this natively.
Database views — See all posts in a board (Kanban), table, calendar, or gallery view. Filter by status, category, author, or any custom property.
Templates — Create reusable page templates so every post starts with the same structure.
Comments and mentions — Leave inline comments, mention team members, discuss edits without leaving the document.
Offline editing — Notion works offline and syncs when you reconnect.

Setting Up Your Editorial Database

The foundation of your Notion CMS is a database where each row represents a blog post. Duplicate the Notipo blog template which has everything pre-configured.

Required Properties

Name (Title) — The post title
Status (Select) — Controls the pipeline: "Post to Wordpress," "Publish," "Update Wordpress," "Ready to Review," and "Published"
Category (Select) — Auto-populated from your WordPress categories
Tags (Multi-select) — Auto-populated from your WordPress tags
Slug (Text) — The URL slug for WordPress
Featured Image Title (Text) — Text rendered on the auto-generated featured image
SEO Keyword (Text) — The focus keyword for your SEO plugin
WordPress Link (URL) — Auto-filled after syncing

Organizing Content with Database Views

Board view — Columns for each status. Drag cards between columns to trigger actions.
Table view — See all posts with every property visible. Great for bulk editing.
Calendar view — Visualize your publishing schedule by date.
Gallery view — Preview posts with their featured image titles.

The Content Pipeline

The Status property drives your entire publishing workflow:

Draft — You're writing. No action taken.
Post to Wordpress — Notipo syncs content, images, and metadata to WordPress as a draft. Status auto-changes to "Ready to Review."
Ready to Review — WordPress draft is ready. Review and preview.
Publish — Notipo publishes the draft live. Status changes to "Published" and the WordPress Link updates.

Need to update a published post? Change the status to "Update Wordpress" and Notipo re-syncs while keeping the post live.

What Notion Blocks Convert to WordPress

Notipo converts these Notion blocks to native WordPress Gutenberg blocks:

Paragraphs, headings (H1-H3), and inline formatting
Bulleted lists, numbered lists, and to-do lists
Images (uploaded to your WordPress media library)
Code blocks (with language identifier for syntax highlighting)
Quotes, dividers, and table of contents
Bookmarks and embedded links

SEO Optimization from Notion

Fill in the SEO Keyword property and Notipo automatically configures your WordPress SEO plugin — focus keyword, SEO title, and meta description. Supports Rank Math, Yoast SEO, SEOPress, and All in One SEO. Your posts are SEO-ready the moment they sync.

Getting Started

Using Notion as your WordPress CMS takes less than 5 minutes to set up. Create a free Notipo account, connect Notion and WordPress, and start publishing.

Originally published at notipo.com/blog/notion-as-wordpress-cms

From Python Script to App: How an n8n Workflow Became Notipo

Kjetil Furås — Mon, 13 Apr 2026 12:07:53 +0000

Notipo didn't start as a product. It started as a Python script that saved me 10 minutes every time I published a blog post. Over the course of a year, that script grew into an n8n workflow, then a sprawling multi-workflow automation, and finally into the app you see today. This is the story of that evolution.

Phase 1: A Python Script for Featured Images

It started with a simple annoyance. Every blog post needed a featured image, and I was creating them manually in Canva. Same layout every time — background image, title text, category label. Twenty minutes of dragging text boxes around for something that should be automatic.

So I wrote a Python script using Pillow. It read titles and categories from a CSV file and generated 1200×628 PNG images. Run the script, get your images. Done.

Phase 2: Discovering n8n

I discovered n8n, the open-source workflow automation tool. I connected Airtable to n8n and turned my Python script into an API endpoint. Now the flow was: fill out an Airtable form, n8n picks it up, calls the Python API, and stores the generated image in MinIO.

This felt like magic. But it only solved the featured image problem.

Phase 3: The Full Notion-to-WordPress Workflow

The manual publishing process: write in Notion, copy content, paste into WordPress editor, fix code blocks, fix formatting, upload images one by one, create featured image, set SEO metadata, hit publish. Fifteen to twenty minutes of tedious work after the writing was done.

I decided to automate the entire thing in n8n. The workflow grew to handle:

Markdown conversion — pulling from Notion's API, converting blocks to Gutenberg
Code block transformation — wrapping in Prismatic blocks with language detection
Image caching — Notion's image URLs expire after an hour, so every image needed downloading and re-uploading to WordPress
Orphan cleanup — removing old images when removed from Notion
Featured image generation — calling the Python API
SEO metadata — setting Rank Math fields via REST API
Status management — updating Notion after each operation

I ended up with 50+ nodes across multiple paths. Airtable sat at the center with five interconnected tables.

Where It Broke Down

The automation worked. But living with it revealed problems:

The execution log was useless — Polling every few minutes created pages of empty "success" runs. Finding the actual sync in the noise was painful.

Airtable was an expensive dependency — $24/month for a spreadsheet acting as a database. Every API call added latency.

The complexity was unmanageable — 50+ nodes, multiple paths, debugging meant clicking through node after node. Adding a feature meant touching nodes in multiple places.

n8n is an incredible tool for connecting APIs and building automations. But there's a complexity threshold where a visual workflow becomes harder to reason about than code. I had crossed it.

Rebuilding as an App

The new stack: Fastify backend with PostgreSQL (replacing Airtable), pg-boss job queue (replacing n8n's execution engine), and Next.js frontend. The Gutenberg block converter became a proper TypeScript module with tests. The image caching pipeline became a service with clear inputs and outputs.

Every pain point had a direct solution:

Noisy logs → job queue only creates entries for actual work
Airtable costs → PostgreSQL with Prisma, zero monthly cost
Debugging → proper error handling, structured logging, stack traces
Feature development → changing one switch statement, not rewiring workflow paths

What n8n Taught Me

I don't regret the n8n phase. Building the workflow forced me to understand every edge case of the Notion and WordPress APIs before writing application code. The workflow was a prototype that ran in production. By the time I wrote the app, I had a complete specification from months of real usage.

Lessons for Anyone Automating with n8n

n8n is perfect for prototyping — validate an idea in hours instead of days
Watch for the complexity cliff — if you dread opening the workflow editor, you've passed it
Paid dependencies add up — evaluate whether a simple database would work
Polling is a poor man's webhook — look for webhook-based triggers whenever possible
The workflow is the spec — if you outgrow n8n, your workflow is the most detailed specification you could ask for

Try It Yourself

If you're writing in Notion and copy-pasting into WordPress — give Notipo a try. The free plan covers 5 posts per month. It took me a year of incremental automation to get here. You can set it up in 5 minutes.

Originally published at notipo.com/blog/from-n8n-to-app

How to Publish WordPress Posts with OpenClaw (AI Agent Automation)

Kjetil Furås — Mon, 13 Apr 2026 12:07:13 +0000

AI agents are getting good at writing. The missing piece is publishing — getting the generated content from the agent into WordPress with proper formatting, images, and SEO metadata. Most solutions require you to string together Notion APIs, WordPress APIs, image uploads, and SEO plugins yourself. Notipo handles the entire pipeline with a single API call.

This guide shows how to use OpenClaw, the open-source AI agent framework, to publish WordPress blog posts through Notipo. The same approach works with any AI agent or HTTP client — Claude Code, n8n, Make, custom scripts, or anything that can send a POST request.

Why Use Notipo as Your Publishing Engine

Without Notipo, an AI agent that wants to publish to WordPress needs to handle: Notion API authentication and page creation, markdown-to-Gutenberg block conversion, downloading and re-uploading images, generating a featured image, setting SEO metadata across different plugins, and managing post statuses. That's dozens of API calls and edge cases.

With Notipo, the agent sends one POST request with a title and body. Notipo creates the Notion page, converts the markdown, uploads images, generates a featured image, sets SEO metadata, and publishes to WordPress. The agent doesn't need Notion or WordPress credentials — just a Notipo API key.

The API Endpoint

Everything goes through POST /api/posts/create:

curl -X POST https://notipo.com/api/posts/create \
  -H "X-API-Key: your-api-key" \
  -H "Content-Type: application/json" \
  -d '{
    "title": "10 Productivity Hacks for Remote Developers",
    "body": "## Introduction\n\nRemote work is here to stay.",
    "category": "Productivity",
    "tags": ["remote-work", "productivity"],
    "seoKeyword": "productivity hacks remote developers",
    "slug": "productivity-hacks-remote-developers",
    "publish": true
  }'

What Notipo Does With That Request

Creates a Notion page with the title and markdown body converted to Notion blocks
Inserts inline Unsplash images after specified headings (Pro plan)
Triggers the sync pipeline — Gutenberg block conversion, image downloads, WordPress media uploads
Generates a 1200×628 featured image with the category background and title overlay
Applies SEO metadata — focus keyword, title, description — to Rank Math, Yoast, SEOPress, or AIOSEO
Creates a WordPress draft or publishes live, depending on the publish flag

The agent gets back a jobId immediately. Processing happens in the background.

Using Claude Code

Claude Code can publish to WordPress through Notipo using a simple curl command. Since Claude Code has shell access, it can call the Notipo API directly. Set your API key as an environment variable and Claude Code can publish posts as part of any workflow.

Using n8n with AI Agents

n8n's AI Agent node can generate content using OpenAI, Claude, or any LLM, then send it to Notipo in one HTTP request. The workflow is four nodes:

Trigger — schedule, webhook, or manual
HTTP Request — fetch categories and tags from Notipo
AI Agent — generate title, body, SEO keyword, category, tags
HTTP Request — POST /api/posts/create

Checking Job Status

curl https://notipo.com/api/jobs?limit=1 \
  -H "X-API-Key: your-api-key"

# Response includes:
# - status: COMPLETED or FAILED
# - result.wpUrl: the live WordPress URL

For most use cases, fire-and-forget is fine — Notipo sends failure notifications to your configured webhook.

Getting Started

Sign up for Notipo (free, 7-day Pro trial), connect your Notion database and WordPress site, then grab your API key from Settings → Account. Point your AI agent at POST /api/posts/create and you're publishing.

Originally published at notipo.com/blog/openclaw-wordpress-publishing