Automate WordPress Blog Publishing with Airtable and n8n

I wanted to automate WordPress blog publishing because the manual process was killing my productivity. Between writing content, make featured images, uploading to WordPress, configuring SEO settings, and double-checking everything looks right—publishing a single post used to take me 15-20 minutes of clicking through different interfaces.

Now I do it in 30 seconds with 5 manual actions.

Here’s how I built this system using Airtable as my CMS, n8n as the automation engine, and WordPress as the final destination.

The Problem with Traditional Publishing

Before automation, my workflow looked like this:

1. Write content in my editor of choice (usually Markdown)
2. Open Canva or similar tool to design a featured image
3. Download and manually optimize the image
4. Log into WordPress
5. Create new post, paste content, manually change all WordPress built-in code blocks over to Prismatic and select the correct code language
6. Upload featured image, set it as featured
7. Configure Rank Math SEO settings (title, description, focus keyword)
8. Preview, adjust formatting
9. Hit publish

That’s 9 separate steps across multiple tools. Context switching kills productivity, and I found myself procrastinating on publishing because the overhead just wasn’t worth it.

The Solution: A Three-Step Publishing System

Now my workflow is:

Step 1: Write in Notion (4 actions)

→ Automation syncs to Airtable
→ Airtable automation generates featured image

1. Add blog title
2. Select category, Featured Image Title, SEO Keyword
3. Write content in markdown
4. Change status to “Ready to Publish”

Step 2: Create Draft (1 action)

→ Automation creates WordPress draft with featured image and SEO configured (~15-20 seconds)

1. In Airtable, change Status to “Post to WordPress”

Step 3: Review & Publish (1 action)

→ Automation publishes the post live

1. Review draft in WordPress admin, then change Airtable Status to “Publish”

Total: 6 manual actions, ~30 seconds of automation time.

Everything else—image generation, WordPress draft creation, featured image upload, SEO configuration—happens automatically. I still review the draft in WordPress before publishing, then change the status in Airtable to trigger the final publish.

It handles multiple inline images too. Drop images in your Notion, and they all get uploaded to WordPress and properly embedded. No manual intervention needed.

System Architecture

Here’s how the pieces fit together:

Data Layer: Airtable Base

The foundation is an Airtable base with 5 interconnected tables:

• Variables Table holds all configuration (webhook URLs, API endpoints, production toggle)
• Featured Image Table triggers image generation via n8n webhook
• Posts Table triggers WordPress publishing via n8n webhook
• Category Table stores WordPress IDs, tags, and background images
• Image Mappings Table caches Notion→WordPress image URLs (this is the secret sauce for fast re-syncs)

Automation Layer: n8n Workflows

Two separate workflows handle different tasks:

• Notion to Airtable Sync (51 nodes): Triggers on Notion changes → converts to Markdown → routes to F1 (no images) or F2 (with images) → caches image mappings → syncs to Airtable
• Publish to WordPress (23 nodes): Featured image generation + WordPress publishing with 3-path routing (publish, edit, create)

Publishing Layer: WordPress

The final destination receives:

• Published posts with Gutenberg blocks
• Featured images properly attached
• All inline images uploaded and embedded
• Rank Math SEO metadata configured

Breaking Down the Components

1. Airtable as My CMS

I use Airtable as my content management system because it’s flexible, visual, and has powerful automation capabilities. My base has 5 tables:

Featured Image Table

• Title (Single line text)
• Category (Link to Category table)
• Processed Image (Attachment field – populated by automation)

Category Table

• Name, WordPress ID, Tags
• Background Image URLs (for featured image generation)

Posts Table

• Title (Single line text)
• Content (Long text – Markdown format from Notion)
• Featured Image (Link to Featured Image table)
• Category (Link to Category table)
• Status (Single select – “Draft”, “Synced to Airtable”, “Post to WordPress”, “Update Pending”, “Posted to WordPress”)
• WordPress ID (auto-populated)

Variables Table

• Name, Value pairs for all configuration
• Examples: “Generate Featured Image”, “Post to WordPress”, “NCA Endpoint”, “WordPress Media Url”, “WordPress Posts Url”
• Production mode toggle (strips “-test” from all URLs)

Image Mappings Table

• Notion Image URL → WordPress Image URL mapping
• WordPress Media ID (for tracking)
• Linked to Posts table
• This table is the performance secret—subsequent syncs reuse cached WordPress URLs instead of re-uploading images

The Variables table is brilliant because I can switch between test and production environments by changing a single checkbox. All webhook URLs and automatically adjust.

2. Airtable Automations (5 Total)

Airtable automations connect the UI to n8n. I have 5 automations split into two categories:

n8n Automations (3) – Scripts that trigger n8n webhooks:

• Process Image: Record enters “Ready for Processing” view → calls n8n to generate featured image
• Send to WordPress: Record enters “Send to WordPress” view → calls n8n to create new post
• Publish Post: Record enters view → calls n8n to publish existing draft

Airtable Automations (2) – Native Airtable actions:

• Import Processed Image: Receives n8n webhook callback → updates Featured Image with generated URL
• Create New Post: Record enters “Create New Post” view → creates linked Post record

Here’s a simplified version of the automation script:

// 1. Fetch configuration from Variables table
let table = base.getTable('Variables');
let query = await table.selectRecordsAsync();
let variables = {};

for (let rec of query.records) {
  let name = rec.getCellValue('Name');
  let value = rec.getCellValue('Value');
  if (name && value) {
    variables[name] = value;
  }
}

// 2. Get webhook URL based on trigger type
let params = input.config();
let webhookName = params.webhook || 'Generate Featured Image';
let webhookUrl = variables[webhookName];

// 3. Send data to n8n
await fetch(webhookUrl, {
  method: "POST",
  headers: { "Content-Type": "application/json" },
  body: JSON.stringify({
    recordId: params.recordId,
    ...variables
  })
});

This script does three things:

• Fetches configuration from the Variables table
• Selects the correct webhook based on what triggered the automation
• Sends everything to n8n for processing

The production version I actually use is more sophisticated—it normalizes variable names to camelCase, handles environment switching between test and production with a single toggle, groups related config by prefix, and does dynamic payload building. But this simplified version shows the core concept.

Want the complete implementation? I’m sharing the production-ready automation scripts, complete n8n workflow JSON, Airtable base template, and setup guides in my Build-Automate community. The community is free to join, and you can access this project and others like it for $47/month in the premium tier.

3. n8n Workflows:

I have two separate n8n workflows that handle different parts of the system.

Workflow 1: Notion to Airtable Sync (51 nodes)

This is the big one. When you change a Notion page status to “Ready to Publish”:

The Smart Part: F1/F2 Flow Routing

The workflow detects whether your post has inline images and routes accordingly:

• F1 (No Images): Streamlined sync—just converts markdown and creates/updates the Airtable record

• F2 (With Images): Full image processing pipeline with caching

Why does this matter? Text-only posts sync in seconds. Posts with 10 images don’t slow down posts with zero images.

Image Mapping Cache (The Performance Secret)

Here’s what made this system actually usable for updates:

1. First sync: Upload image to WordPress, store Notion URL → WordPress URL mapping in Airtable
2. Second sync: Check cache first. Image already uploaded? Reuse the WordPress URL. Skip the upload entirely.
3. Remove an image from your post? Orphan cleanup automatically deletes the unused mapping.

Before I built the cache, updating a post with 5 images meant re-uploading all 5 images every time. Now it takes seconds because it just swaps in the cached URLs.

Workflow 2: Publish to WordPress (23 nodes)

This workflow handles two pipelines:

Pipeline 1: Featured Image Generation

1. Airtable automation triggers n8n webhook with record ID
2. n8n fetches category background image from Airtable
3. NCA API (Python/PIL) generates 1200×628 image with title overlay
4. Image uploads to S3
5. Callback updates Airtable with the image URL

Total time: ~10 seconds

Pipeline 2: WordPress Publishing (3-Path Routing)

This is the magic. The workflow uses a Switch node to route to three different paths:

1. n8n fetches the complete record (content, featured image, category, tags)
2. Markdown converter transforms content into Gutenberg blocks & Prismatic blocks for code (Prism.js)
3. Switch routes based on what action is needed:

The Create path does the heavy lifting:

• Creates WordPress draft
• Downloads and uploads featured image
• Sets alt text, title, caption on media
• Attaches featured image to post
• Auto-configures Rank Math SEO (focus keyword, description, title)
• All via WordPress REST API—no manual SEO screen clicking

The 3-path routing was a game-changer. Before, I had one path trying to handle everything. Now each action has its own clean flow. Publishing a draft? Path 1. Updating existing content? Path 2. Brand new post? Path 3.

The Rank Math automation is underrated. Every post gets a 66/100 SEO score out of the box without touching the SEO panel. Not perfect, but way better than forgetting to set it entirely.

Total time: ~15-20 seconds

4. WordPress Configuration

For this to work, WordPress needs a few things configured:

Required Plugins:

• Rank Math SEO (for SEO meta fields)
• Prismatic (for syntax highlighting in code blocks)

Application Password:
WordPress → Users → Your Profile → Application Passwords
Create a new password for n8n API access.

Rank Math REST API Registration (functions.php):

/**
 * Register Rank Math SEO meta fields for WordPress REST API
 */
add_action('init', function () {
  $keys = [
    'rank_math_title',
    'rank_math_description',
    'rank_math_focus_keyword',
  ];

  foreach ($keys as $key) {
    register_post_meta('post', $key, [
      'type'          => 'string',
      'single'        => true,
      'show_in_rest'  => true,
      'auth_callback' => function () {
        return current_user_can('edit_posts');
      },
    ]);
  }
});

This makes Rank Math fields accessible via REST API, allowing n8n to set SEO metadata programmatically.

The Publishing Experience

Now when I want to publish a blog post:

1. Write in Notion:
2. Create Draft:
3. Review & Publish:

Updating a post? Even easier:

• Edit in Notion, change status to “Ready to Publish” again
• Sync detects existing post, updates Airtable (status becomes “Update Pending”)
• Change to “Post to WordPress”—it updates the existing WordPress post instead of creating a duplicate

No context switching. No manual uploads. No image creation. No SEO configuration screens.

Why This Works Better Than Other Solutions

vs. WordPress Native:

• Markdown is faster than Gutenberg editor
• Built-in markdown preview links (copy content → paste in markdownlivepreview.com)
• Posts created as drafts – review in WordPress admin before publishing

vs. Static Site Generators:

• No git commits or deployment pipelines
• Non-technical users can publish (if needed)
• WordPress ecosystem and plugins still available

vs. Zapier/Make:

• n8n is self-hosted (no monthly limits)
• More control over data and logic
• Free for unlimited workflows

vs. Manual Image Creation:

• Consistent branding across all images
• 10 seconds vs. 5-10 minutes per image
• No design skills required

vs. Re-uploading Images Every Time:

• Image mapping cache means updates are fast
• Edit a post with 10 images? Cache hits, no re-uploads
• Remove an image? Orphan cleanup keeps things tidy

Environment Management with Variables Table

The Variables table approach deserves special attention because it solves a common problem: testing workflow changes without affecting production.

The same workflow handles both test and production through different webhook URLs:

• Test: https://n8n.example.com/webhook-test/9ffcd535-379e-4860-941f-5e4f4980a538
• Production: https://n8n.example.com/webhook/9ffcd535-379e-4860-941f-5e4f4980a538 (strips test)

In my Variables table, I store the test URLs by default:

• Generate Featured Image: https://n8n.example.com/webhook-test/d9c38552-a348-4e64-9853-fc25627e5881
• Post To WordPress: https://n8n.example.com/webhook-test/9ffcd535-379e-4860-941f-5e4f4980a538
• WordPress Media Url: https://example.com/wp-json/wp/v2/media
• WordPress Posts Url: https://example.com/wp-json/wp/v2/posts
• Production: true

When Production is true, the Airtable automation script automatically strips -test from all webhook URLs. Every automation instantly switches to production endpoints.

This means:

• One automation script handles both environments
• Zero risk of accidentally publishing to production during testing

Performance & Reliability

The system handles posts reliably with consistent timing:

• Featured image generation: 8-12 seconds (depends on Python API)
• WordPress publishing: 15-20 seconds (network + API calls)
• Airtable updates: <1 second

Total automation time: ~30 seconds from changing the status to WordPress draft ready.

Getting Started with This System

If you want to build something similar:

1. Start with Airtable
2. Set up n8n
3. Configure WordPress
4. Connect the pieces

Final Thoughts

I test every code snippet and workflow step before publishing. Writing about automation means the tutorials have to actually work.

Building this from scratch took me about a week, working on it alongside my main job. If you use my templates and workflows (available in the Build-Automate community), you can get up and running in under a day.

If you publish regularly and hate the manual overhead, this might work for you too.

---

Get the Complete Implementation

I’m sharing everything I built in my Build-Automate community premium tier ($47/month):

✔️ Complete n8n workflow JSON (2 workflows: Notion Sync + Publish to WordPress)
✔️ Airtable base template (5 tables + 5 automations with environment switching)
✔️ WordPress setup guide (Rank Math API registration code)
✔️ Complete system documentation (architecture, workflows, troubleshooting)
✔️ Private GitHub org access (complete Docker stack + Infrastructure as Code)

Premium members also get access to my private GitHub organization with the exact Docker stack and infrastructure automation (Terraform/Ansible) I use to run this system in production.

The community is free to join—come check it out and see if the premium tier is right for you.

Questions? Join the Build-Automate community and let’s talk about your automation projects.