Auto-Categorize WordPress Posts with OpenAI

This workflow automates the process of categorizing WordPress blog posts using OpenAI's language model. It fetches all existing posts, analyzes each title to determine the most relevant category from a predefined list, and updates the post with the assigned category ID. This saves hours of manual effort and ensures consistent taxonomy across your content library.

Step-by-Step Workflow

  1. When clicking ‘Test workflow’ (Manual Trigger) — No auth required. Starts the workflow on demand. Replace with a Schedule Trigger for automated runs.
  2. Get All Wordpress Posts (WordPress API) — Uses WordPress credentials (Basic Auth or Application Password). Retrieves all posts from your WordPress site with returnAll: true.
  3. OpenAI Chat Model (OpenAI API Key) — Configures the OpenAI language model. Requires a valid OpenAI API key stored in your n8n credentials.
  4. AI Agent (No auth) — Processes each post's title using a custom prompt. The prompt defines a fixed category map (e.g., 13 = Content Creation) and instructs the AI to output only the single most relevant category ID. It references $json.title.rendered from the previous node.
  5. Wordpress (WordPress API) — Updates the post (operation: update) using the post ID from the 'Get All Wordpress Posts' node and sets the categories field to the output of the AI Agent ($json.output).

Setup Instructions

  • WordPress: You need a WordPress site with the REST API enabled. Create an application password or use your username/password for Basic Auth. Store these as a WordPress credential in n8n.
  • OpenAI: Sign up for OpenAI and obtain an API key from platform.openai.com/api-keys. Save it as an OpenAI credential in n8n.
  • Categories: First ensure the category IDs in the AI prompt match the actual category IDs in your WordPress installation. The workflow uses hardcoded IDs (e.g., 13, 14, 15...). Adjust these as needed.

Use Cases & Customization

  • Scheduled categorization: Replace the manual trigger with a Cron or Schedule trigger to run daily/weekly.
  • Adapt categories: Modify the prompt to use different category names/IDs, or add more categories.
  • Extend analysis: Include post content or excerpt in the prompt for more accurate categorization.
  • Export results: Add a node (e.g., Google Sheets) to log which categories were assigned for auditing.
  • Bulk re-categorization: Run once to categorize hundreds of existing posts in minutes.
9 nodesmanual triggerAI
WordpressSticky NoteLm Chat Open AIAgent

Workflow JSON

{
  "id": "caaf1WFANPKAikiH",
  "meta": {
    "instanceId": "558d88703fb65b2d0e44613bc35916258b0f0bf983c5d4730c00c424b77ca36a",
    "templateCredsSetupCompleted": true
  },
  "name": "Auto categorize wordpress template",
  "tags": [],
  "nodes": [
    {
      "id": "2017403c-7496-48f8-a487-8a017c7adfe3",
      "name": "When clicking ‘Test workflow’",
      "type": "n8n-nodes-base.manualTrigger",
      "position": [
        680,
        320
      ],
      "parameters": {},
      "typeVersion": 1
    },
    {
      "id": "82ff288f-4234-4192-9046-33e5ffee5264",
      "name": "Wordpress",
      "type": "n8n-nodes-base.wordpress",
      "position": [
        1500,
        320
      ],
      "parameters": {
        "postId": "={{ $('Get All Wordpress Posts').item.json.id }}",
        "operation": "update",
        "updateFields": {
          "categories": "={{ $json.output }}"
        }
      },
      "credentials": {
        "wordpressApi": {
          "id": "lGWPwxTdfPDDbFjj",
          "name": "Rumjahn.com wordpress"
        }
      },
      "typeVersion": 1
    },
    {
      "id": "521deb22-62dd-4b5f-8b9a-aab9777821da",
      "name": "Sticky Note1",
      "type": "n8n-nodes-base.stickyNote",
      "position": [
        620,
        -100
// ... truncated (copy to see full JSON)

How to Import This Workflow

  1. 1Copy the workflow JSON above using the Copy Workflow JSON button.
  2. 2Open your n8n instance and go to Workflows.
  3. 3Click Import from JSON and paste the copied workflow.

Don't have an n8n instance? Start your free trial at n8nautomation.cloud

Related Templates

Automated Blog Post Creation from News with AI and Blogger

This workflow automates the entire process of creating a fully SEO-optimized blog post from a news article. It fetches a trending technology news headline from Mediastack, generates relevant images from Pexels, uses two AI agents (via OpenRouter) to produce a title, slug, meta description, and a complete WordPress-compatible HTML blog post, then posts it directly to Blogger and sends you a Telegram notification. It's perfect for content marketers, bloggers, or anyone who wants to consistently publish fresh, data-driven content without manual effort. Node Breakdown Schedule Trigger (No auth) — Runs the workflow at a set interval (configured every minute by default, but you should change it to daily or hourly). Mediastack News (API Key auth via query parameter) — Fetches the latest technology news article in English from the Mediastack API. Parameters: set to . Genarate image (API Key auth via header, ) — Searches Pexels for up to 2 images related to the news title. Parameters: = , = 2. Send a text message1 (Telegram bot token auth) — Sends a Telegram message with the generated image URLs to the chat ID stored in . AI Agent (Uses OpenRouter Chat Model — API Key auth) — This agent takes the news title and returns a JSON object with three fields: , , and (meta description). The prompt includes strict guidelines for SEO-friendly output. OpenRouter Chat Model (API Key auth) — The language model for the first AI agent, using . Parsing (No auth) — A Code node that cleans the raw AI output (removes markdown code fences) and parses the JSON into usable fields. Copywriter AI Agent (Uses OpenRouter Chat Model2 — API Key auth) — This agent writes a complete 1,000-word SEO blog post in HTML format. It uses the title, meta, and the two images from Pexels. The prompt is very detailed, specifying structure, keyword placement, and styling. OpenRouter Chat Model2 (API Key auth) — Same model as the first, but used for the second agent. Cleanup HTML (No auth) — A Set node that removes any leftover htmlurlhttps://www.googleapis.com/blogger/v3/blogs/$vars.bloggerid/postsPOSThttpQueryAuthAuthorization$vars.telegramchatid$vars.bloggeridbusinesssports`) to match your niche. Multi-language Support — Modify the Mediastack query to fetch news in other languages, and adjust the AI prompts to write in that language. Custom Image Sources — Replace the Pexels node with another image API (e.g., Unsplash) or use a local image generation model. Different CMS — Swap the Blogger HTTP Request node with WordPress or any other CMS API (just change the URL and body format). Human-in-the-Loop — Add a Slack or email approval step before publishing to review the AI-generated content. Newsletter Integration — Instead of posting to a blog, send the formatted content as an email newsletter via Gmail or SendGrid.

16 nodes

AI Chat Agent with OpenAI, Memory, and Web Search

Overview This workflow creates an intelligent AI chat agent that combines OpenAI's language model with conversational memory and real-time web search capabilities via SerpAPI. It is designed to power interactive chat applications where the AI can remember context across messages and fetch up-to-date information from the internet when needed. This is particularly useful for building customer support bots, research assistants, or any conversational interface that requires both knowledge retention and live data access. The workflow is triggered by incoming chat messages and processes them through an AI agent that coordinates between the language model, memory buffer, and search tool. The agent can decide when to use web search to answer questions that require current information, while maintaining conversation history for coherent multi-turn dialogues. Workflow Steps Manual Trigger (No auth) — This node allows you to manually start the workflow for testing purposes. It has no parameters configured and simply provides a button to execute the workflow on demand. When chat message received (No auth) — This is a webhook-based trigger that listens for incoming chat messages. It generates a unique webhook URL that you can integrate with your chat frontend or messaging platform. The parameter is empty, meaning default webhook behavior is used. AI Agent (No auth) — This is the core orchestrator node that manages the conversation flow. It coordinates between the OpenAI model, memory buffer, and SerpAPI tool. The agent decides which tool to use based on the user's query and maintains the conversation state. OpenAI Chat Model (API Key auth) — This node connects to OpenAI's GPT-4o-mini model to generate responses. It requires an OpenAI API key configured in n8n credentials. The parameter is set to , which is a cost-effective and fast model suitable for chat applications. The parameter is empty, using default model settings. Window Buffer Memory (No auth) — This node implements a sliding window memory that stores recent conversation history. It allows the AI to remember context from previous messages within a configurable window size. The parameters are empty, using default memory settings. SerpAPI (API Key auth) — This tool node enables web search functionality via SerpAPI (Google Search API). It requires a SerpAPI API key configured in n8n credentials. The parameter is empty, using default search settings. The agent calls this node when it determines that real-time web data is needed to answer a query. Setup Instructions To use this workflow, you need the following accounts and credentials: OpenAI Account: Sign up at platform.openai.com and create an API key. In n8n, create an "OpenAI" credential and paste your API key. SerpAPI Account: Register at serpapi.com and obtain an API key. In n8n, create a "SerpAPI" credential with your key. Webhook URL: After activating the workflow, copy the webhook URL from the "When chat message received" node. Integrate this URL into your chat application (e.g., a custom web chat widget, Slack app, or Telegram bot). Optional: Configure the memory window size in the "Window Buffer Memory" node if you want to limit or extend conversation context. Use Cases and Variations This workflow can be adapted for multiple scenarios: Customer Support Bot: Replace SerpAPI with a knowledge base tool (e.g., vector store or database lookup) to answer product-specific questions. Research Assistant: Keep SerpAPI for web search and add additional tools like Wikipedia or news APIs. Multi-Platform Chat: Connect the webhook to different messaging platforms (Slack, Discord, Telegram) by adding appropriate trigger nodes. Personal Assistant: Add calendar or email tools to let the AI manage schedules and send messages. Language Translation: Replace the OpenAI model with a translation-specific model or add a translation tool node. To extend the workflow, you can add more tool nodes (e.g., database queries, file operations) and connect them to the AI Agent. The agent will automatically learn to use new tools based on their descriptions.

6 nodes

Telegram RAG Chatbot with File Upload and Groq LLM

This workflow creates a Telegram chatbot that uses Retrieval-Augmented Generation (RAG) to answer questions based on documents you upload. Users can send PDF or CSV files to a Telegram chat, and the workflow processes them into a vector database. When a user then sends a text message, the AI agent retrieves relevant chunks from the stored documents and generates an answer using the Groq Llama 3.1 model. It's like having a personal assistant that learns from your files and responds via Telegram. Node-by-Node Walkthrough Telegram Message Trigger (Telegram Trigger, no authentication required on the node itself — authentication is handled via the Telegram Bot API credentials configured in the n8n credentials store). This trigger listens for all types of updates (messages, commands, etc.) from a Telegram bot. When a new update arrives, it starts the workflow. Get a chat1 (Telegram node, Telegram Bot API token auth). It extracts the from the incoming message and passes it to the next node, ensuring the AI agent knows which chat to reply to. AI Agent1 (LangChain Agent, no auth). This is the core of the workflow. It uses a system message that instructs the AI to answer only from the knowledge base. The agent has access to the Groq Chat Model as its language model and the Retrieve documents tool to fetch relevant document chunks. It also uses Simple Memory to keep conversation context within a session (keyed by the Telegram chat ID). Groq Chat Model (Groq LLM, Groq API key auth). Uses the model. This provides fast, coherent answers. Simple Memory (Memory Buffer Window, no auth). Stores the last few turns of conversation to give the agent context. The session key is set to the Telegram chat ID from the trigger. Retrieve documents (Vector Store as Tool, no auth). This tool allows the agent to query the in-memory vector store. It returns the top 10 most similar document chunks. Embeddings HuggingFace Inference1 (Hugging Face Inference, Hugging Face API key auth). Generates embeddings for the user's query so the vector store can find relevant documents. Upload your file here (Form Trigger, no auth). This form trigger provides a web form where users can upload or files. The uploaded file(s) are passed to the Default Data Loader1. Default Data Loader1 (Document Default Data Loader, no auth). Converts the uploaded binary file into a LangChain document object. Recursive Character Text Splitter (Text Splitter, no auth). Splits the document into chunks of up to 3,000 characters with 200 character overlap. This ensures the vector store indexes manageable pieces. Simple Vector Store (In-Memory Vector Store, no auth). Stores the document chunks along with their embeddings. The embedding model used is Embeddings HuggingFace Inference. Embeddings HuggingFace Inference (Hugging Face Inference, Hugging Face API key auth). Generates embeddings for each document chunk before storing them. Reply in Telegram1 (Telegram node, Telegram Bot API token auth). Sends the AI agent's output back to the same Telegram chat. Setup Instructions Telegram Bot: Create a bot via @BotFather and get its API token. In n8n, add a Telegram credential using this token. Groq: Sign up at GroqCloud to get an API key. Add a Groq credential in n8n. Hugging Face: Create a free account at Hugging Face and generate an Inference API token. Add a Hugging Face Inference credential in n8n. n8n Form Trigger: This node is built-in. Ensure your n8n instance is publicly accessible (or use a tunnel like ngrok) so the form can be accessed by users. Deploy: Activate the workflow. Share the Telegram bot username with users. They can upload files by visiting the form URL (the one generated by the Upload your file here node) and then send text messages to the bot. Use Cases and Variations Personal knowledge base: Upload company policies, technical documentation, or study materials and ask questions about them via Telegram. Customer support bot: Replace the file upload with an HTTP node that fetches FAQs from a database, and use the same RAG architecture to answer customer queries. Multi-user support: The session memory is already scoped by Telegram chat ID, so multiple users can use the bot simultaneously without interfering. Switch LLM: Replace Groq with OpenAI, Anthropic, or any other supported LLM provider by changing the model node. Persistent vector store: Swap the in-memory vector store for Pinecone, Weaviate, or Qdrant to retain documents across restarts.

15 nodes

Ready to automate with n8n?

Get affordable managed n8n hosting with 24/7 support.