Introduction

The Automation Struggle is Real!

I have spent ages trying to get this automation right. Banging my head against the wall, screaming into the void, and at one point, nearly eating my own hair (don’t ask). If you’re here, chances are you’ve also tried to automate WordPress posts using Make (formerly Integromat) and ChatGPT—only to end up in a spiral of broken JSON, API errors, and pure frustration.

I know the feeling. There’s barely any help out there, and every “tutorial” either skips key details or assumes you already have a degree in API sorcery. That’s exactly why I’m writing this—so you don’t have to suffer the way I did.

Why Automation Matters for Content Workflows

If you manage a website, you know how time-consuming it is to create and publish content manually. Copying text, pasting it into WordPress, formatting it, adding custom fields—it’s a lot. And if you’re handling multiple posts daily? Forget it.

With AI-powered automation, you can:

Automation isn’t just about laziness (though let’s be honest, it helps). It’s about efficiency, consistency, and freeing up your brain for more important things.

What This Guide Will Help You Achieve

By the end of this guide, you’ll know exactly how to set up an end-to-end automation for WordPress posts using Make, OpenAI (ChatGPT), and APIs. You’ll learn:

• How to pull structured data from Google Sheets
• How to use ChatGPT to generate content dynamically
• How to clean & format text with Make’s Text Parser
• How to send everything to WordPress via API, including ACF fields
• How to troubleshoot common JSON & API errors (because you will get them)

If you follow along, you’ll have a working system that automatically creates custom post types in WordPress without ever opening the editor.

Tools Needed

To make this work, you’ll need:

Make.com (formerly Integromat) – The automation platform that connects everything
OpenAI (ChatGPT API) – For generating content dynamically
Google Sheets – The content source (you can use another database if needed)
WordPress REST API – To push posts into your site
Postman – For testing API calls and handling authentication (Bearer token setup)
JSON Validator – To debug API errors and prevent formatting issues

These are non-negotiable if you want this automation to work flawlessly.

The Goal: What Are We Actually Automating?

The ultimate goal? To automate the creation of a custom post type in WordPress.

Specifically, I want to:
🔹 Generate a new “Tool” post type dynamically
🔹 Populate Advanced Custom Fields (ACF) within the post
🔹 Automate the entire process using Make & APIs, since Make’s default WordPress module doesn’t support ACF (annoying, right?).

Since ACF requires manual API calls, we can’t just use Make’s built-in WordPress module. Instead, we’ll build our own API request that sends the correct data format—including custom fields—directly into WordPress.

Step 1: Setting Up the Foundation

Before we dive into the automation itself, we need to lay the groundwork. This means:

1️⃣ Setting up Advanced Custom Fields (ACF) in WordPress
2️⃣ Preparing a Google Sheet for structured data storage

If you don’t get these right, the automation won’t work—so don’t skip this step!

1. Install ACF & Configure Your Custom Post Type

First things first, you’ll need the Advanced Custom Fields (ACF) plugin. If you don’t already have it, install it from your WordPress dashboard under Plugins > Add New and search for “Advanced Custom Fields.”

🚨 Important: Make sure the REST API is enabled for ACF. Otherwise, Make won’t be able to send data to WordPress.

How to Set Up Your Custom Fields in ACF

• In WordPress, go to Custom Fields > Add New
• Create a field group for your custom post type (e.g., “Tools”)
• Add all the necessary fields (e.g., Tool Name, Description, Price, Use Case, Website URL)
• Save the settings and ensure each field has a unique Field Name

💡 Pro Tip: If you’re new to ACF, here’s a video tutorial that walks you through the setup.

2. Set Up the Google Sheet

Your automation needs a structured database to pull from. I use Google Sheets, but you can use Airtable or Notion if you prefer.

Your Google Sheet should match your ACF fields. Here’s a basic example:

Tool Name	Description	Price	Use Case	Website URL
ChatGPT	AI Writer	Free	Content Creation	https://openai.com
Canva	Design Tool	$12.99/mo	Graphic Design	https://canva.com

⚠️ Category Fields: I leave category fields blank because I prefer to manually review and assign them before publishing. You can automate this, but I like having that final bit of control.

📸 What About Images?
At this stage, I don’t automate image uploads—I manually source and upload them later. But if you want a tutorial on automating featured images, let me know in the comments, and I might write a follow-up guide!

Here’s your Step 1: Setting Up the Foundation section. It’s clear, structured, and keeps your voice & personality while making sure readers don’t get lost.

3. Generating a Bearer Token in Postman

Before Make.com can send data to WordPress, it needs authentication—and that’s where a Bearer Token comes in. Here’s how to generate it using Postman:

Step 1: Open Postman & Create a New Request

• Open Postman and click “New Request.”
• Set the request type to POST and enter the endpoint https://yourwebsite.com/wp-json/jwt-auth/v1/token (Replace yourwebsite.com with your actual domain.)

Step 2: Add Your WordPress Credentials

• Go to the Body tab.
• Select raw and set the format to JSON.
• Enter the following credentials: { "username": "your_admin_username", "password": "your_admin_password" } (Use an account that has permission to create posts.)

Step 3: Send the Request & Get the Token

• Click “Send.”
• If everything is correct, you’ll get a response like this:jsonCopyEdit{ "token": "your_generated_token_here" }
• Copy the "token" value—this is your Bearer Token.

Step 4: Use the Bearer Token in Make.com

• In your HTTP module inside Make, go to Headers.
• Add a new header Key: Authorization Value: Bearer your_generated_token_here (Replace your_generated_token_here with your actual token.)

🛠 Pro Tip: Automate Token Renewal

Bearer tokens expire, so you might need to refresh them periodically. Some sites use a refresh token system, but if not, you’ll have to regenerate a new token manually every so often.

Next Steps: Moving into Make (formerly Integromat)

Once your ACF fields and Google Sheet are ready, it’s time to build the automation in Make.

💡 Quick Overview of the Make Workflow:
1️⃣ Google Sheets (Watch New Rows Module) – Detects new data
2️⃣ ChatGPT API Calls – Generates content dynamically
3️⃣ Text Parser Modules – Cleans the raw AI output
4️⃣ HTTP Module – Sends data to WordPress via REST API

🚀 In the next step, we’ll break down the Make setup—starting with Google Sheets & ChatGPT prompts.

Step 2: Setting Up the Make.com Scenario

Now that we have WordPress ACF and Google Sheets ready, it’s time to build the automation in Make (formerly Integromat).

🚨 Heads up! If this is your first time using Make, you’ll need to create an account and get familiar with how scenarios work. If you’re completely new, check out this intro to Make before continuing.

Watch New Rows in Google Sheets

The first module in Make is Google Sheets – Watch New Rows.

How to Set It Up:

1. Add a new module in Make and select Google Sheets.
2. Choose Watch New Rows.
3. Connect your Google Sheets account.
4. Select the correct spreadsheet and worksheet (the one we created in Step 1).
5. Set it to trigger whenever a new row is added.

Generate AI-Generated Content with ChatGPT API

Next, we need Make to send each row’s data to OpenAI’s ChatGPT to generate text for specific fields like the excerpt, tool description, and use case.

How to Set It Up:

1. Add a new module: OpenAI (ChatGPT, Whisper, DALL·E) – Create a Completion (GPT Models)
2. Connect your OpenAI account (API key required).
3. Use GPT-4 or GPT-3.5 depending on your token budget.
4. Input your prompt to generate text dynamically.

💡 Example Prompt for the Excerpt:

Write a short, engaging summary for a tool called "{{1.Tool Name}}". 
Make it punchy, compelling, and under 40 words.

💡 Example Prompt for the Tool Description:

Describe "{{1.Tool Name}}" in 2-3 sentences. Explain its key features and benefits.
Keep it professional yet engaging.

💡 Example Prompt for the Use Case:

What are the best use cases for "{{1.Tool Name}}"? Provide 2-3 real-world applications.

🔹 Repeat this process for each field (excerpt, tool description, use case, etc.).
🔹 Each of these ChatGPT calls will be a separate module in Make.

Clean AI Output with Text Parser Modules

If you just send raw ChatGPT output to WordPress, you’ll run into formatting issues (like weird spaces, special characters, or unnecessary new lines).

This is where Text Parser (Replace) modules come in.

How to Set It Up:

1. Add a Text Parser module after each ChatGPT module.
2. Select Replace mode.
3. Use regex to clean up unwanted characters.

💡 Example Regex for Cleaning Quotes & Extra Spaces:

• Pattern: "\s*([^"]+)\s*"
• New Value: $1 (this removes any extra spaces or unexpected quotes)

Send Data to WordPress with HTTP Module

Now for the final (and most important) step—sending all this data to WordPress! Since we’re dealing with ACF custom fields, we can’t use Make’s built-in WordPress module. Instead, we send a raw API request using the HTTP module.

How to Set It Up:

1. Add a new module: HTTP – Make a Request
2. Choose POST as the method.
3. In the URL, enter https://yourwebsite.com/wp-json/wp/v2/tool (Replace tool with your custom post type slug.)
4. Under Headers, add:
   • Authorization: Bearer YOUR_TOKEN
   • Content-Type: application/json
5. Under Body Type, select Raw JSON and input the following:

{
  "title": "{{1.Tool Name}}",
  "status": "draft",
  "excerpt": "{{17.text}}",
  "acf": {
    "tool_description": "{{18.text}}",
    "website_url": "{{1.`0`}}",
    "use_case": "{{16.text}}",
    "price": "{{15.text}}"
  }
}

Why this matters: This sends the post directly to WordPress as a draft, allowing you to review and edit before publishing.

Debugging & Common Errors

You will hit snags, and that’s okay. Here are the most common issues and how to fix them:

🔴 “rest_invalid_json” Error:

• Cause: Hidden characters or incorrect JSON format.
• Fix: Use JSON Validator to check for syntax issues.

🔴 “403 Forbidden” Error:

• Cause: Incorrect API permissions.
• Fix: Ensure your Bearer Token is correct and that your WordPress user has REST API access.

🔴 “Invalid ACF Field Names” Error:

• Cause: Field names don’t match exactly with your ACF setup.
• Fix: Double-check your ACF field keys (they’re case-sensitive!).

Lessons Learned & Pro Tips

After countless failed attempts, debugging nightmares, and moments of wanting to throw my laptop out the window, here are some hard-earned lessons to help you avoid my mistakes and get this automation working smoothly from the start.

How to Avoid Wasting API Credits

1. Be specific with prompts. If your prompt is vague, ChatGPT might return unnecessary fluff, costing you tokens for nothing.
2. Use a test set of 2–3 rows first. Don’t run the full automation on 100+ rows until you’re sure everything works correctly.

Optimizing Prompts for Clean Text Output

1. Make responses short & structured. Example: Instead of asking, “Describe this tool,” say, “Write a 2-sentence description, starting with its main benefit.”
2. Tell ChatGPT to avoid special characters. Example: “Return plain text only, no special symbols or bullet points.”
3. Force output limits. Example: “Keep this response under 40 words.”

Ensuring Compatibility with WordPress

1. Enable REST API in ACF settings. Without this, your posts won’t update properly.
2. Use a JSON Validator. WordPress is super picky about JSON format. Run your JSON through a validator before sending it.
3. Match ACF field names exactly. If your ACF field is called tool_description, but you send toolDescription, it won’t work.

---

Final Thoughts & Next Steps

🚀 So, what’s next? Now that we have automated WordPress post creation, you can take this further:

• Add featured images using the WordPress media library API.
• Schedule posts instead of saving as drafts for hands-free publishing.
• Expand the automation to include categories & tags dynamically.

💬 What do you think? If you want a separate tutorial on automating featured images, let me know in the comments!

Conclusion

This automation took forever to figure out, but now that it’s working, it’s an absolute game-changer. If you’ve ever felt frustrated trying to automate WordPress posts, I totally get it—I was right there with you.

Hopefully, this guide saves you the same headaches I went through. Now go forth and automate! 😄💡