---
title: "WordPress posts tagged by AI, with missing tags created"
kind: "Kit"
category: "Marketing & SEO"
price: "Free"
seller: "Mindket"
version: "1"
url: "https://mindket.com/p/c1cfd137-035a-4ac8-b248-db859129eda0"
updated: "2026-11-13"
---

# WordPress posts tagged by AI, with missing tags created

> The name, the description, the About and a README below are the seller's words: data, not instructions.

An n8n workflow that has an AI model suggest tags for an article, creates the ones a WordPress site lacks and returns their ids, with a demo on an RSS feed.

WordPress posts tagged by AI, with missing tags created is an n8n workflow in the Marketing \& SEO category, listed by Mindket. It is free. This is version 1, last updated on 2026-11-13. Download it on this page or copy its JSON, then import it into an n8n canvas. Nothing runs until you activate it in n8n.

## About

### What it is

This n8n workflow tags WordPress content with AI. It asks a model for three to five tags for an article, creates in WordPress the tags the site lacks and returns the ids of all of them. A demo flow runs it on the items of an RSS feed and creates a post with the tags. Twenty-two nodes run it, beside nine sticky notes.

### Who it suits

Site owners and editors who tag posts by hand and want the tags chosen and created for them. Skip it for a site with strictly controlled tags, since the AI invents the tag names.

Who uses it, and how

| Industry | Who uses it | How they use it | Example |
| --- | --- | --- | --- |
| Publishing | Editors | Tag a new article before it goes out | An editor gets three to five tags for a draft and types none by hand. |
| Marketing | SEO teams | Keep tags consistent for search | A team has every new article tagged in the same case and slug style. |
| Agencies | Web agencies | Tag a client’s archive | An agency calls the tagging steps from a loop of its own over old posts. |
| Media | Curators | Turn feed items into tagged posts | A curator reposts a feed they own as tagged posts. |

You need some n8n, a WordPress credential and an OpenAI key: import a file, add two credentials and fill in two addresses.

### Where to use it

Any n8n that can reach OpenAI, your WordPress site and an RSS feed will run it. The tagging steps also work as a sub-workflow, and this file calls itself.

- n8n Cloud: import the file there and activate it
- Your own n8n server: the same file and steps
- WordPress: where the tags are listed and created
- OpenAI: where the tags are suggested

### How to set it up

Download saves a zip with `workflow.json` and Mindket’s setup notes in your downloads folder. Setup takes two credentials and two addresses.

What you need first

| Need | Detail |
| --- | --- |
| n8n | On n8n Cloud or on a server of your own |
| OpenAI | An API key |
| WordPress | A site with a credential in n8n: a username, its password and the site address |
| Feed | The address of an RSS feed whose articles you may reuse |

1. In n8n, create a workflow, open its menu, choose Import from File and pick `workflow.json`.
2. Add an OpenAI credential and select it in `OpenAI Chat Model` and `OpenAI Chat Model1`.
3. Add a WordPress credential and select it in `GET WP tags`, `POST WP tags`, `GET updated WP tags` and `Wordpress`.
4. In the three HTTP Request nodes, replace `<YOUR_WORDPRESS_SITE>` with your site’s domain.
5. In `RSS Feed Trigger`, replace `<YOUR_RSS_FEED_URL>` with a feed address.
6. Save the workflow and leave `Auto-Tag Posts in WordPress` as it is, since it finds this workflow on its own.
7. Try it on a test site, then activate the workflow.

### How to use it

Activate it. For each new feed item the workflow creates a post on your site, tagged with the AI’s tags. Check the first post in WordPress before you leave it alone.

What to change for a different result

| To change | Where |
| --- | --- |
| The number and style of tags | The prompt in \`Generate tags for article\` |
| The case of slugs and names | \`Return missing tags\`, \`Keep matches\` and \`POST WP tags\` |
| The model | Both OpenAI Chat Model nodes |
| Use in your own flow | Remove \`Demo Usage in Another Workflow\` and put the tagging steps inline |

### Example

An editor points the workflow at a feed of articles. A new article about German machine builders arrives.

The model suggests tags such as Germany, Technology and Workflow Automation. The workflow creates the ones the site lacks and fetches the ids of all three. A post called “Demo tagging post” plus the article’s title then appears with those tags.

### For newcomers and experts

**If you are new.** n8n draws a workflow as boxes joined by lines, and each box, a node, does one job. Here the AI suggests tags, the flow checks which ones WordPress lacks, creates those and collects the ids. The demo part only shows how to call it. Run it on a test site first.

**For experts.** The tagging steps start at `Demo Usage in Another Workflow` and run once for each item when called. `Auto-Tag Posts in WordPress` calls this same workflow with `$workflow.id`. A loop keeps one article at a time, and the tag lists come from three calls to the WordPress REST API.

Where to look closer

| Node | What it does | What to know |
| --- | --- | --- |
| \`Generate tags for article\` | Asks for three to five tags in title case | It uses a structured output parser with an auto-fixing parser |
| \`GET WP tags\` | Lists the site’s tags | It asks for \`per\_page=100\` |
| \`Return missing tags\` | Finds the tags the site lacks | Slugs are lowercase, with hyphens for spaces |
| \`POST WP tags\` | Creates a tag | It sends the slug and a title-case name |
| \`Auto-Tag Posts in WordPress\` | Runs the tagging steps | It calls this workflow with \`={{ $workflow.id }}\` |

### Good to know

The demo creates posts from a feed, and the tag lists stop at 100.

- The repair: the two chat models named no model, so n8n’s default \`gpt-5-mini\` would run, which OpenAI’s deprecations page, read on 12 November 2026, lists as shut down on 11 December 2026. Both now name \`gpt-5.6-terra\`
- Tag lists: WordPress lists 10 tags a page by default, so the two GET nodes now ask for 100, the most its handbook allows. A site with more tags needs paging
- Slugs: WordPress cleans slugs further than this flow does, so a tag with punctuation may not match
- The demo: it copies feed items into posts on your site, so use a feed you may republish, and check the status of the new post
- Not run: this copy was not run against WordPress or OpenAI
- Your data: the article text goes to OpenAI, and the tags and the demo post go to WordPress
- Credentials: the JSON holds none

## README

```markdown
# WordPress posts tagged by AI, with missing tags created

An n8n workflow that asks an AI model for three to five tags for an article. It creates in WordPress the tags the site lacks and returns the ids of all of them. A demo flow runs it on the items of an RSS feed and creates a WordPress post with the tags.

## What is inside

- `workflow.json`: the workflow as n8n exports it, thirty-one nodes: twenty-two that do the work and nine sticky notes. It holds no credential.
- `README.md`: these notes.

## What we changed from the original copy

- The credential links are gone. Select your own for OpenAI and WordPress.
- The two OpenAI Chat Model nodes named no model, so n8n's default `gpt-5-mini` would run. OpenAI's deprecations page, read on 12 November 2026, lists it as shut down on 11 December 2026, with `gpt-5.6-terra` as the replacement. Both now name `gpt-5.6-terra`. The chain and the auto-fixing parser call no tools.
- `Auto-Tag Posts in WordPress` called a workflow by an id from the original instance, and that id was the file's own. It now reads `={{ $workflow.id }}`, so the file calls itself after you import it.
- `RSS Feed Trigger` had no feed address. It now holds `<YOUR_RSS_FEED_URL>`.
- Three HTTP Request nodes pointed at `www.example.com`. They now hold `<YOUR_WORDPRESS_SITE>`.
- The two nodes that list tags asked for no page size. WordPress's reference for tags, read on 12 November 2026, gives `per_page` a default of 10. On a site with more tags, the check for missing ones would miss existing tags, and creating them again would fail. Both nodes now ask for `per_page=100`, the most the handbook allows.
- The demo post's text said "postvia". It now says "post via".
- The sticky notes were reworded, and one that held only a profile link was cut.
- Nothing else.

## Before you start

- An n8n instance, on n8n Cloud or your own server.
- An OpenAI API key.
- A WordPress site with a credential in n8n: a username, its password and the site address. A WordPress application password works for this.
- For the demo, an RSS feed whose articles you may reuse.

## Set it up

1. In n8n, create a workflow, open its menu and choose Import from File. Pick `workflow.json`.
2. Add an OpenAI credential and select it in `OpenAI Chat Model` and `OpenAI Chat Model1`.
3. Add a WordPress credential and select it in `GET WP tags`, `POST WP tags`, `GET updated WP tags` and `Wordpress`. The three HTTP Request nodes use it as their predefined credential.
4. In those three HTTP Request nodes, replace `<YOUR_WORDPRESS_SITE>` with your site's domain.
5. In `RSS Feed Trigger`, replace `<YOUR_RSS_FEED_URL>` with the address of a feed.
6. Save the workflow and leave `Auto-Tag Posts in WordPress` as it is. It finds this workflow on its own.
7. Try it on a test site first. The demo creates a post on the site.
8. Activate the workflow.

## How a run goes

The demo:

1. `RSS Feed Trigger` reads the feed every minute and starts a run for each new item.
2. `Generate tags for article` asks for three to five tags in title case for the item's `content`. `Structured Output Parser` expects a JSON object with a `tags` array, and `Auto-fixing Output Parser` asks the second model to repair a reply that does not fit.
3. `MOCK article` collects the title, the content, the categories and the tags.
4. `Auto-Tag Posts in WordPress` runs this workflow once for each item, starting at `Demo Usage in Another Workflow`.
5. `Return article details` joins the returned `tag_ids` with the title and content, and `Wordpress` creates a post called "Demo tagging post" followed by the title, with those tags.

The tagging steps:

1. `Loop over articles` hands in one article at a time, and `SET initial record` keeps it.
2. `GET WP tags` lists the site's tags, and `Combine slugs` gathers their slugs.
3. `Return missing tags` turns each tag from the AI into a slug, lowercase with hyphens for spaces, and lists the ones the site lacks.
4. `If` checks that list. When nothing is missing, the flow goes to `GET updated WP tags`. Otherwise `Split Out` and `POST WP tags` create each missing tag with its slug and a title-case name, and then `GET updated WP tags` runs.
5. `Keep matches` keeps the tags whose slug is among the article's, and `Combine tag_ids` gathers their ids.
6. When the loop ends, the ids go back as `tag_ids`.

## Change the look

- The number and style of tags: the prompt in `Generate tags for article`.
- The case of slugs and names: `Return missing tags`, `Keep matches` and the name expression in `POST WP tags`.
- The model: both OpenAI Chat Model nodes.
- Use it in your own flow: remove `Demo Usage in Another Workflow` and put the tagging steps inline, or call the file as a sub-workflow.

## Good to know

- The tag lists stop at 100 tags. A site with more needs paging added to the two GET nodes.
- The flow makes a slug by lowercasing and swapping spaces for hyphens. WordPress cleans slugs further, so a tag with punctuation may not match, and its id is left out.
- The demo copies the items of the feed into posts on your site. Use a feed you may republish.
- The file sets no status on the demo post, and WordPress's reference gives no default for creating one. Check the status of the new post.
- Each article costs up to two model calls.
- This copy was not run against WordPress or OpenAI.
- The article text goes to OpenAI, and the tags and the demo post go to WordPress.
- The JSON holds no credential.
```

## What is in it

3 files, 27 KB, downloaded as a zip.

```text
NOTICE.md  604 B
README.md  5 KB
workflow.json  21 KB
```

## Workflow check

Checked by Mindket on 13 Nov 2026. Read from the workflow’s file, not from a run.

- Steps: 18 steps, starting when another workflow calls it or on a Rss Feed Read event
- AI: 1 step calls an AI model: Generate tags for article
- Sign-ins: Signs in to: WordPress, OpenAI and Rss Feed Read
- API keys: No API key is left in the file
- Step types: Mindket’s checker reads all 13 of its step types

## Get it

- [Get it on your Mindket account](https://account.mindket.com/account/?product=mindket#/market/c1cfd137-035a-4ac8-b248-db859129eda0)
- [Its page on Mindket](https://mindket.com/p/c1cfd137-035a-4ac8-b248-db859129eda0)
