Keyword Clustering for Content Planning: From CSV Dump to Editorial Calendar

Keyword clustering for content planning is the step that turns a 500-row keyword export into a slot-by-slot editorial calendar. The catch most "free clustering" guides miss is structure: dump a flat list into ChatGPT and you get a few loose groups any junior editor could have produced by eye. The prompt below forces the LLM to return strict JSON clusters scored by centroid, dominant intent, buyer stage, and a suggested article format — so the output is a content plan, not a brainstorm.

Works in ChatGPT, Claude, or Gemini on any free tier. No paid SERP scrape, no clustering API, no spreadsheet macros. Five minutes from a CSV export to a prioritized list of articles your writer can scope today.

Why flat keyword lists don't become content plans on their own

A keyword export from Google Search Console, a free tool, or a paid scrape is a list of demand signals. It is not a plan. Three reasons keep coming up.

• Search intent collapses queries into the same article. "keyword clustering tool", "keyword clustering software", and "best keyword grouping tool" are three rows in your CSV but one article on the SERP. Treat them as separate briefs and you ship duplicates that compete with each other.
• Buyer-stage drift is invisible per row. "how does keyword clustering work" is problem-aware. "keyword clustering for SaaS" is comparison. "keyword clustering API pricing" is decision-stage. Same root, three different pages.
• Priority gets lost in volume sorting. Sort the CSV by monthly volume and the head terms float to the top — the ones a smaller domain cannot win. The cluster you actually want first is the one with high intent and a beatable SERP, not the one with the biggest number.

Clustering is the routing layer between the keyword research and the brief. Skip it and the content calendar fills with single-row articles competing for the same slot. The strategic question is not "which keyword wins?" — it is "which cluster is one article, scoped to which buyer stage, anchored by which centroid term." See the five-stage keyword research pipeline for the upstream context — clustering is stage four.

What the keyword-import wizard accepts and what it produces

The wizard's input is intentionally permissive. Three accepted shapes cover roughly 95% of keyword exports we have seen:

• A pasted CSV. Columns can be in any order. The wizard reads the header row and maps "keyword" or "query" to the term, "volume" or "search volume" to monthly searches, and "difficulty", "kd", or "competition" to a competitiveness score. Empty columns are tolerated.
• A pasted bullet list. One keyword per line. No volume, no difficulty — the LLM inherits the cluster centroid from the keyword text alone. Useful when the source is a brain-dump or a Search Console screenshot.
• A pasted JSON array. Already-structured keyword objects. Useful when piping output from another tool. The wizard validates against a small schema and rejects rows missing the keyword field.

The output is a JSON document with one cluster per object: centroid (the canonical query that anchors the cluster), members (the keywords inside it), dominant_intent (informational, commercial, transactional, navigational), buyer_stage (TOFU, MOFU, BOFU), suggested_format (pillar, comparison, tutorial, glossary), and a priority_score from 1 to 10. Strict JSON beats a Markdown table because the next step — turning each cluster into a brief — wants typed data, not prose.

Step-by-step: paste keywords, run the clustering prompt, get JSON clusters

The prompt does five jobs in one round-trip. Groups the rows by topical centroid. Labels each cluster with dominant intent and buyer stage. Suggests an article format. Scores priority. Returns strict JSON.

Inputs: the keyword list (one of the three shapes above), one niche line, and one buyer line. No SERP scrape, no API key. Drop the three context lines plus the pasted keywords into the prompt and send it to ChatGPT, Claude, or Gemini.

Prompt to paste:

• ROLE — You are a senior SEO strategist running keyword clustering for content planning. Output strict JSON only — no preamble, no closing remarks, no Markdown.
• CONTEXT — Niche: <one-sentence niche>. Buyer: <one-sentence buyer plus the action you want them to take>. Keywords: <paste your CSV, bullet list, or JSON array>.
• TASK — Cluster the keywords above into 6-12 clusters. Each cluster groups queries that share a topical centroid AND dominant search intent — not surface-similar wording. A query whose intent disagrees with its cluster mates does not belong; route it elsewhere or drop it.
• STRUCTURE — Return a JSON object with a single key "clusters" whose value is an array. Each cluster object has these fields: centroid (string), members (array of strings), dominant_intent ("informational" | "commercial" | "transactional" | "navigational"), buyer_stage ("TOFU" | "MOFU" | "BOFU"), suggested_format ("pillar" | "comparison" | "tutorial" | "glossary" | "landing"), priority_score (integer 1-10), notes (string, max 140 chars).
• RULES — No invented search volumes. No invented keywords (every member must come from the input). Each cluster must have at least 2 members. priority_score reflects intent-times-fit-with-niche, not raw search volume. notes must name the specific reader pain the cluster solves, not a SEO platitude.
• FORMAT — Strict JSON. No code fences. No trailing commas. The first character of the response is "{" and the last is "}".

Hit enter. The model returns the JSON document in roughly 25 to 40 seconds depending on list size. The "Strict JSON" line is the one that earns its keep — without it, ChatGPT and Gemini both wrap the output in triple backticks half the time, and Claude likes to add an "Here are your clusters:" preface. Both break a JSON parser downstream.

The JSON validator: what valid output looks like and how to spot malformed responses

A valid response parses cleanly into the schema in the STRUCTURE block. The fields you should sanity-check first, in order:

1. Top-level shape. The response must start with a "{" and end with a "}". Nothing else. If you see a triple-backtick "json" fence at the front or "Here are your clusters" before the brace, the model ignored the FORMAT block.
1. Cluster array. The "clusters" key must hold an array of 6 to 12 objects. Fewer than 6 means the model collapsed too aggressively. More than 12 means it failed to merge near-duplicates.
1. Member coverage. Every keyword from your input must appear in exactly one cluster's members array. Diff input vs output — silently dropped rows are the most common failure on long lists.
1. Intent and stage labels. Both fields must use the enum values from the prompt. "Mid-funnel" instead of "MOFU" or "info" instead of "informational" means the LLM is improvising.
1. Priority distribution. If every priority_score is 8 or above, the model is rubber-stamping. Push back: ask for a re-score with stricter criteria — see the search intent five-minute method for an SERP-based audit you can apply per cluster.

Run the JSON through any browser DevTools console (JSON.parse(text)) or an online validator. Five seconds. If parsing throws, the next section is the round-trip you need.

The JSON fixer-prompt round-trip: when the LLM output is malformed

Two failure modes account for nearly all malformed responses. Triple-backtick wrappers (the model added a "json" code fence) and unescaped quotes inside the notes field. Both are repaired in one round-trip without re-running the cluster work.

Repair prompt to paste:

• ROLE — You are a JSON repair tool. Return ONLY valid JSON. No preamble. No code fences.
• TASK — Fix the JSON below so it parses with strict JSON.parse. Do not change semantics, do not re-cluster, do not invent fields. Only repair: remove code fences, escape inner quotes, remove trailing commas, fix mismatched brackets.
• INPUT — <paste the malformed response verbatim, including any preface or fence the model added>
• RULES — If the input is a complete cluster JSON wrapped in fences, strip the fences and return the JSON unchanged. If a string field has unescaped inner quotes, escape them. If a trailing comma appears, remove it. Do not collapse or merge clusters. Do not change priority scores.
• FORMAT — Strict JSON. First character "{", last character "}". No commentary.

The repair pass succeeds on the first try roughly 95% of the time on outputs from GPT-4o, Claude 3.7 Sonnet, and Gemini Flash. When it fails, the underlying problem is usually that the cluster pass also dropped half the members — re-run the original prompt against a smaller batch (no more than 200 keywords per pass) instead of debugging a hopeless response.

Bulk-creating article suggestions from the cluster output

A clean clusters JSON is one transformation away from a writer-ready backlog. Each cluster maps to one article suggestion with a predictable shape:

• Working title from the centroid. The centroid query — "keyword clustering for SaaS" or "free keyword grouping tool" — drops directly into a title generator as the seed phrase.
• Buyer-stage from the cluster. The buyer_stage label routes the brief: TOFU clusters become problem-led tutorials, MOFU clusters become comparison or "how to choose" pages, BOFU clusters become decision-stage pages with strong CTAs.
• Internal-link anchors from cluster siblings. Adjacent clusters with related centroids become the candidate anchor list. A four-axis search intent framework is a useful second pass when two clusters look adjacent on intent and you have to decide whether to merge.
• Priority order from the score. Sort by priority_score descending and you have your sprint queue. Tie-break by buyer_stage — ship one BOFU cluster per sprint even when the priority math says otherwise, because BOFU compounds revenue faster than TOFU compounds traffic.

The whole transformation is a 30-line script — or one paste into a tool that already understands the schema. The point is the JSON is your contract. Once it is valid and grouped right, the editorial calendar writes itself, and the same artifact also feeds a free content brief generator so the next downstream step skips a re-strategy pass.

Do this in 5 minutes: keyword clustering for content planning from one prompt

The end-to-end run, with no prep besides your CSV export and two context lines.

1. Minute 0 — Open ChatGPT, Claude, or Gemini. Have your keyword list ready (CSV paste, bullet list, or JSON), plus your one-sentence niche line and one-sentence buyer line.
1. Minute 1 — Paste the clustering prompt. Replace the CONTEXT block with your three inputs. Hit enter.
1. Minute 2 — Wait for the JSON document. Validate by pasting into a JSON parser. If it fails, run the repair prompt — do not re-run the cluster pass.
1. Minute 3 — Sanity-check the cluster count (6-12), the priority distribution (not all 8+), and member coverage (every input keyword appears once).
1. Minute 4 — Sort the clusters by priority_score. Pick the top three for this sprint. Tie-break with one BOFU cluster if the math skews toward TOFU.
1. Minute 5 — Drop the three centroids into your brief generator or your editorial calendar. Each centroid is one article; each member is one supporting query.

Total elapsed: under five minutes from CSV export to a triaged content plan. Compare to the alternative — a spreadsheet, manual labeling, and three days of "we will get to clustering next week."

Weaknesses & Drawbacks

Where the free wizard falls short

The workflow above is honest about the destination, but not about the friction. Plan around these constraints before you commit to running it every sprint:

• Hard ~500-keyword ceiling per pass. The clustering prompt has to fit inside the model's context window, so anything larger than a mid-size GSC export needs to be split, deduped, and re-stitched manually.
• Quality is bounded by the model. Two runs of the same list can return different groupings, and weaker models drift toward broad topic buckets that do not map cleanly to individual articles.
• The round-trip is manual. Paste keywords, copy the prompt, paste into the chat UI, copy JSON back, run the validator, feed the fixer prompt when it breaks. Five minutes when it works, twenty when it does not.
• No demand validation. Grouping by semantic similarity does not guarantee search volume — a tight, coherent cluster can still represent queries nobody makes.
• No deduplication against existing content. The wizard will propose ideas you already shipped or rejected; filtering is your responsibility.
• No SERP grounding. Clusters reflect the model's notion of relatedness, not Google's — you can end up targeting a single article at queries the SERP treats as two distinct intents.

When automated clustering removes the ceiling

Dedicated clustering pipelines are built to eliminate exactly these constraints. The same move — list to clusters to article suggestions — becomes a single async run without a keyword cap, manual JSON handling, or volume-blind groupings. Coverage detection and demand weighting come standard, so the output is sorted by what is actually worth writing rather than what the model found semantically similar.

If your list fits in a single chat window, the manual workflow is the right tool. When it no longer does, an automated pipeline removes the bottleneck without changing the underlying logic.

How VarynForge fits in

VarynForge ships the keyword-import wizard on every free project: paste your CSV, bullet list, or JSON, and the tool runs the clustering prompt with your saved niche and buyer context, validates the output against the JSON schema, and falls back to the repair prompt automatically if parsing fails. Each surviving cluster becomes an article suggestion in one click, with the centroid pre-populated as the working title and the priority_score driving sprint order. Create a free VarynForge project to skip the manual paste-validate-repair loop and run clustering against your real domain.

Frequently Asked Questions

Is keyword clustering really better than just sorting by volume?

For sites under about 200 published articles, yes. Volume sorting picks the head terms a smaller domain cannot rank for; clustering picks the centroid where one article can win the SERP for a basket of related queries. The compounding math favors clustering — a cluster that ranks at position 3 captures traffic from the centroid plus the long tail, while a head term at position 12 captures nothing.

How big can the keyword list be before the LLM degrades?

Roughly 200 keywords per pass on free GPT-4o and free Claude 3.7 Sonnet. Free Gemini Flash holds context for closer to 300. Beyond those thresholds the model silently drops members or collapses too many clusters. For a 1000-row export, batch into five passes of 200 each, then run a final cluster-of-clusters pass on the centroids.

What if the LLM returns clusters that don't match the search intent on the live SERP?

Spot-check the top three priority clusters by typing the centroid into Google. If the SERP is dominated by a different format (informational results when the cluster says BOFU, for example), the cluster's intent label is wrong. Paste the centroid and the SERP titles back into the model with "the SERP for centroid X is dominated by format Y; re-classify this cluster" and re-run.

Should I cluster before or after I filter the keyword list?

Filter first, then cluster. Drop misspellings, brand keywords for competitors, and obvious off-niche queries before running the prompt. A cleaner input list produces tighter clusters and a higher-signal priority distribution. Filtering after clustering forces a re-cluster when you remove members.

Which model produces the best clusters — ChatGPT, Claude, or Gemini?

All three on free tiers, with different strengths. Claude 3.7 Sonnet writes the cleanest dominant_intent labels. GPT-4o is the most reliable on strict-JSON output. Gemini Flash holds the largest list before degrading. "Use whichever you have open" is fine for first runs; switch models if the JSON parse keeps failing — the prompt itself does not need editing.

Key Takeaways

Keyword clustering for content planning turns a flat CSV into a slot-by-slot editorial calendar in five minutes. The structured JSON output — centroid, members, intent, buyer stage, suggested format, priority — is the contract that makes every downstream step (briefing, internal linking, sprint planning) cheap. Skip clustering and your content calendar fills with single-row articles competing for the same SERP.

The leverage is the prompt's strict JSON contract plus the repair-prompt round-trip. Run the cluster pass once, validate the output, repair if needed, sort by priority, and ship one BOFU cluster per sprint alongside the highest-scoring TOFU and MOFU centroids. The whole loop is under five minutes, and the resulting plan does not need a re-strategy pass when the writer picks it up.

Further Reading

• Free Keyword Research Tool Alternative: 5-Min ChatGPT Workflow
• How to Determine Search Intent for Keywords (5-Minute Method)
• Free Content Gap Audit: 5-Minute Workflow With ChatGPT
• How to Outline an SEO Article in 5 Minutes (Free Prompt)
• Free Content Brief Generator: From Cluster to Brief in 5 Minutes
• Keyword Research for SEO: From Seed Terms to High-Intent Targets
• How to Do Keyword Research for Topic Clusters in 2026
• Types of Search Intent: A Vector Framework for Content Teams
• What Is a Content Strategy and How to Create One That Works

Sources

• Google Search Central — Helpful, reliable, people-first content
• Google Search Console — official documentation
• json.org — the JSON specification
• Claude 3.7 Sonnet — Anthropic announcement
• Gemini API models — Google AI for Developers