How to Automate Blog Content Generation with n8n and AI

The internet has enough auto-published AI slop. The workflows behind most of it look identical: a topic goes into OpenAI, the raw response goes straight into a WordPress node, and whatever the model returned is now live with nobody having read it. n8n blog content generation done well does the opposite. It treats the AI draft as a draft, parses it into real fields, and makes a human click "approve" before anything publishes.

Two things break the naive version. The model returns one blob of text while the publish node expects structured fields, so the post lands malformed or empty. And with no approval gate, a hallucinated claim or an off-brand paragraph goes public before anyone sees it.

This is the build that fixes both: AI draft, parse step, email approval, then publish.

What you can automate in a content pipeline

A content workflow is more than "write a post." Once n8n holds the topic and the draft, you can wire in the steps a real editorial process needs:

• Pull queued topics from a Google Sheet, one draft per run
• Seed the model with brand-voice examples so output matches your tone
• Parse the AI response into title, body, excerpt, and slug fields
• Generate a meta description and tags in the same call
• Route the draft to an editor's inbox with approve and reject links
• Publish approved drafts to WordPress as draft status, not live, for a final human pass
• Log every generated post, its status, and its approver to a sheet

The list is tempting to automate end-to-end with no human in it. Resist that. The approval gate is the feature, not the friction.

The content-generation pipeline

Topic Trigger → OpenAI draft → Code parse → Email approval
       → WordPress publish (draft) → Log to Sheet

Topic in. Draft from the model. Parse the blob into fields. Wait for a human. Publish only on approval.

1. Collect the topic

A Google Sheets row or a form submission is the cleanest trigger. One row holds the topic, the target keyword, and an optional angle. Read it, and the rest of the pipeline has structured input instead of a vague prompt.

2. Draft with brand voice

Send the topic to an OpenAI node. The honest way to get brand voice isn't a magic instruction; it's example seeding. Paste two or three short excerpts of your actual published writing into the system prompt and ask the model to match their rhythm and vocabulary. That works far better than "write in a professional yet friendly tone," which produces the same beige prose for everyone.

Ask the model to return structured output: a JSON object with title, body, excerpt, and tags. You'll need those fields separated anyway, so ask for them separated.

3. Parse the output (the step everyone skips)

This is where most pipelines silently break. The OpenAI node hands you text. The WordPress node wants discrete fields. Between them goes a Code node that parses the model's JSON into $json.title, $json.body, and so on.

Add this node every single time, even when it feels redundant. The failure mode is sneaky: a missing parse step doesn't throw a loud error, it posts an empty or mangled article. The execution log makes a broken parse obvious after the fact; the live post makes it embarrassing.

4. The approval gate

Insert an approval step. n8n's email-based wait node sends the parsed draft to an editor with approve and reject links and pauses the execution until someone clicks. Approved drafts continue. Rejected ones route to a "needs work" sheet with the editor's note.

This single node is what separates a content workflow you'd run on your own site from a content farm you'd be ashamed of.

5. Publish and log

On approval, the WordPress node creates the post. Set its status to draft rather than publish for one more human pass in the CMS itself. Then append a row to your tracking sheet: topic, title, approver, timestamp, and the post URL.

Implementation patterns worth copying

Pattern: JSON-mode parse with a fallback

Ask the model for JSON and use the response-format option where the node supports it. But models occasionally ignore it and return prose. Wrap the Code node parse in a try/catch: valid JSON publishes, invalid JSON pings Slack so a person fixes the prompt instead of the workflow shipping garbage.

Pattern: brand-voice example library

Keep your voice examples in a Google Sheet, not hardcoded in the node. When your tone shifts, you edit a sheet instead of every workflow. The Content Scheduler & Distributor reads its inputs from a Sheet for exactly this reason, so the writing changes without touching node config.

Pattern: multi-output from one draft

One topic can produce the blog post plus its social captions in a single run. Reuse the parsed body, send it to a second OpenAI call for short-form variants, and route those to your posting workflow. That's the repurposing pattern, and the Social Media Scheduler & Designer handles the caption-plus-graphic side of it.

n8n nodes you'll use most

Getting started

1. Set up a Google Sheet with topic, keyword, and status columns.
2. Add an OpenAI node and seed it with two or three real excerpts of your writing.
3. Tell the model to return JSON with title, body, excerpt, and tags.
4. Insert a Code node that parses that JSON into fields, wrapped in a try/catch.
5. Add the email approval wait node pointed at your editor's inbox.
6. Connect the WordPress node, set status to draft, and run one topic end-to-end.
7. Add the Sheets log so every post records its approver and URL.

For the broader picture, automate content creation with n8n covers the end-to-end editorial workflow, and n8n OpenAI workflows digs into the output-path and JSON-mode details that make the parse step reliable. Once your drafts are publishing cleanly, the Social Media Scheduler & Designer turns each one into ready-to-post social content.