Programmatic SEO With MCP: How to Publish 100+ Pages From Claude or Cursor (2026)

Updated April 2026. Programmatic SEO with MCP is the practice of using the Model Context Protocol to let an AI agent generate, score, internally link, and publish hundreds of unique pages directly on your domain. Done right, it scales. Done wrong, it gets deindexed. This guide is the difference.

The old way of programmatic SEO died on March 5, 2024, when Google rolled its scaled content abuse policy into the core algorithm. The new way started eight months later, when Anthropic shipped the Model Context Protocol. By Q1 2026, the MCP SDK is being downloaded 97 million times a month, up from 100,000 in month one — a 970x jump in 18 months. Anthropic counted over 10,000 public MCP servers at the December 2025 Linux Foundation handover, and an independent census from Nerq puts the number above 17,000 today.

Meanwhile, 34% of enterprise marketing teams now run at least one autonomous agent in production — more than double the 14% from Q4 2025, per Lyzr's State of AI Agents. Forrester predicts 30% of enterprise app vendors will publish their own MCP servers in 2026. If you produce content for a living and you haven't moved to an agent-driven loop, the builders who have are about to lap you.

This is the playbook. It's the same one we use to run Quillly's own blog.

What "programmatic SEO with MCP" actually means

Programmatic SEO means generating many pages from a structured data source plus a content template — Zapier's 50,000 integration pages, Wise's currency converter, TripAdvisor's destination guides. First-generation programmatic SEO used spreadsheets, scripts, and a CMS API. Every step needed engineering glue. Every page needed manual QA.

The Model Context Protocol collapses that workflow into a single conversation. MCP is an open standard, donated by Anthropic to the Linux Foundation's Agentic AI Foundation in December 2025, that lets any LLM call external tools through a uniform interface. Once your CMS, SEO scorer, and Search Console all expose MCP servers, an agent can plan a content set, write each page individually, score it, fix it, link it, and publish it — without you ever copy-pasting between apps.

Kevin Indig framed the underlying opportunity in his Growth Memo: "Programmatic SEO is the most effective way to scale SEO. The idea is simple: build a lot of pages — sometimes hundreds of thousands — for a keyword pattern." MCP is the layer that finally makes that idea operationally cheap.

That's the layer that didn't exist in 2023. It's what turns "I have an idea for 200 landing pages" into "200 landing pages went live overnight, 188 of them are indexed, and three are already on page one."

The keyword phrase you need to remember: agent → MCP → CMS → index, in one loop.

Why programmatic SEO mostly failed before MCP arrived

Old-style programmatic SEO had a survivorship-bias problem. Everyone cited Zapier. Almost nobody cited the failures. There were a lot of failures.

In late 2025, a travel site built 50,000 "hotels in [city]" pages from a single template. Google deindexed 98% of them within three months. A separate analysis of 500+ failed programmatic projects found that 93% of penalized sites lacked meaningful differentiation between pages. The losing pattern repeated: city name swap, currency swap, plumber-in-Chicago swap, ship.

Google's view is blunt. The scaled content abuse policy doesn't distinguish AI from human writing. It looks for "unoriginal, low-value content created at scale to manipulate rankings." SpamBrain — Google's anti-spam ML model — gets better at spotting the pattern every quarter.

A separate Semrush study of 42,000 blog pages across 20,000 keywords found that human-written content is 8x more likely to occupy the #1 organic position — but the gap closes from position five down. The reading: AI-generated programmatic pages can rank fine in the long tail if each one demonstrates something a model can't synthesize from training data alone. Most templated AI output cannot.

Then Google's John Mueller ramped the warnings. In August 2025, he warned that sites using LLMs to spin topic clusters were building "liability — reasons not to visit any part of your site." A few months later, he said rewriting AI content by hand will not reset how Google views the domain. Once you're flagged at scale, the cleanup might be longer than starting a new site.

The contrarian truth most "publish 1,000 pages overnight" tutorials still skip: substance, not scale, is the constraint. The failure mode is template homogeneity. The failure mode has never been page count. Wise has 60.5 million monthly organic visits with thousands of pages and zero deindexing risk because each page sits on top of unique exchange-rate data, not text variations. The data underneath is the moat.

The 4-layer programmatic SEO stack in 2026

A modern programmatic SEO setup has four distinct layers. If you're missing one, the system breaks under volume.

1. The agent — Claude, Cursor, ChatGPT, Gemini, Windsurf. The orchestrator that plans, writes, and decides. This is where reasoning lives.

2. The MCP layer — The tool surface the agent talks to. Quillly exposes 23 MCP tools on Pro for blog creation, SEO scoring, internal linking, indexing, GSC analytics, and publishing. Other servers handle keyword data, image search, GitHub, analytics.

3. The CMS / publishing layer — Where the page actually lives and is served to crawlers. Critically, the page should sit at yourdomain.com/blog/your-slug, not on a subdomain — subdomains inherit weaker authority and complicate canonicalization.

4. The indexing and feedback layer — Sitemap, RSS, the Google Indexing API, Search Console. This is the loop that closes: ship a page, watch impressions, refresh what underperforms.

When all four layers expose MCP, you stop having a "stack." You have one conversation.

The Agentic Programmatic SEO Loop: 6 steps that don't get you deindexed

Most failed programmatic SEO projects skip steps 3, 5, and 6. The agentic loop forces all six because each is a distinct MCP tool call.

Step 1: Harvest the head term and entity space

Start with one keyword cluster, not a sitemap. Use a research tool — DataForSEO, Ahrefs, or your AI agent crawling SERPs — to map the head term, the entities Google associates with it, and the long-tail variations. For each variation, capture three signals: search volume, difficulty, and whether the SERP wants a unique answer per variation (it often doesn't — "best CRM for [industry]" is genuinely different per industry; "weather in [city]" is not).

Step 2: Build the data spine

Programmatic SEO without a unique data spine is template SEO, and template SEO is what gets deindexed. The spine is whatever makes each page non-substitutable: pricing data, API specs, integration capabilities, real exchange rates, hand-collected reviews, scraped public records, or your own customer data. No spine means no post. This is the rule you don't break.

Step 3: Generate the page draft through the agent

The agent reads one row of the spine and writes one page. Not a template with three swappable variables. A real page that explains this row's specifics, with structure that responds to this search intent. The MCP layer carries the spine into the prompt so the model has hard facts, not hallucinations.

Step 4: Score and fix in-place

Every draft hits an SEO scoring tool before it touches the live site. Quillly's scorer runs 14+ criteria — title, meta, H-tag hierarchy, keyword density, semantic coverage, internal links, image alt text, schema markup, and more. Calling get_blog_seo_patches returns the exact fix strings; one update_blog call applies them all. Pages below 75 don't move forward.

Step 5: Internal-link before publish

The single biggest difference between Wise's 60M-visit programmatic system and the deindexed travel site is internal linking. Wise's currency pages link to each other in dense topical webs. The travel site's pages were islands. Quillly's suggest_internal_links MCP tool reads the new draft, scans your existing posts, and proposes contextual anchors. Apply the good ones; ignore the loose ones.

Step 6: Publish, ping, monitor, refresh

Publishing isn't the end of the loop — it's the start. Sitemap regenerates. RSS pings. The page goes to Google's Indexing API. After 7–14 days, the agent checks get_gsc_performance for that URL. If impressions land but CTR is under 1.5%, the agent rewrites the title and meta. If impressions don't land, the page goes to a "needs more data" review queue, not back into the loop.

That's the named framework: the 6-step Agentic Programmatic SEO Loop. Harvest, spine, draft, score, link, publish. If you stop linking the steps together, you're back doing 2023 programmatic SEO.

Real example: 100 comparison pages in one Claude Code conversation

Here's what this looks like in practice. You sell project management software. You want a comparison page for every plausible "Asana vs X" / "Linear vs X" / "Notion vs X" search someone might run.

The agent runs roughly this prompt sequence:

1. List the top 30 PM tools by search volume.
2. Build a 30 × 30 matrix of vs-pairings,
   excluding self-pairs and duplicates.
3. For each pairing, fetch:
   - pricing
   - core feature differences
   - target user
   - one real customer review per side
4. Use bulk_create_blogs (max 10 at a time)
   to draft each comparison as a unique page.
5. Run check_blog_seo on each draft.
   Apply patches until score ≥ 85.
6. Run suggest_internal_links per page,
   apply contextual anchors.
7. Stagger publishes: 10/day across 10 days.
8. After 14 days, fetch GSC data,
   refresh anything below 0.5% CTR.

That's 435 pages from a single conversation, sequenced across two weeks. Compare it to the 2023 version: a Google Sheet, a Zapier zap, four CMS plugins, and three weekend evenings of cleanup. (For the single-page Claude Desktop version of this workflow, see How to Publish Blogs from Claude Desktop — same MCP loop, just one post at a time.)

The Quillly MCP server processes bulk_create_blogs in chunks of 10 per call, so a 100-page run is 10 calls. Each draft returns a fresh SEO score. You see in the same response which pages need work, and the agent fixes them before any of them go live.

The key constraint: stagger your publishes. Indexing 100 fresh pages overnight looks suspicious. Indexing 10 a day for ten days looks like a publishing schedule. Google's John Mueller has consistently advised progressive rollout for very large sites, and the 2026 version of that advice is "let your scheduler think for you."

What good programmatic pages have that bad ones don't

The difference between a programmatic page that ranks and one that gets deindexed lives in seven concrete attributes. Use this as a pre-publish checklist.

A real-world data point: a client documented in late 2025 had 8,000 comparison pages built with a legacy template tool, with only 1,200 indexed (15%). After rebuilding 2,000 pages with an agentic, per-page approach, 1,940 of 2,000 (97%) got indexed. Same data, same domain, completely different indexation rate. The variable was uniqueness per page, applied at the source.

Three programmatic SEO patterns that still work in 2026

Not every shape of programmatic page is equally durable. These three patterns have survived every Helpful Content update and continue to print traffic in 2026.

Pattern 1: The integration directory (Zapier, Slack, Make)

Zapier built more than 50,000 integration landing pages and drives roughly 2.6 million monthly organic visits on the back of them — Salt Agency credits the program with quadrupling Zapier's organic traffic over three years. The pattern: one page per integration, plus one page per pair. Each page has a unique data spine — the actual Zapier triggers, actions, popular use cases, and customer-submitted templates. The text describing each integration is generated, but the underlying capabilities are real and verified.

To replicate: take your product's API surface, every public integration partner, every plausible use case, and treat each combination as one page. Don't generate beyond what your product actually does.

Pattern 2: The data converter (Wise, Currencyfair, XE)

Wise generates more than 60.5 million monthly organic visits from currency-conversion programmatic pages. Each page has live exchange rates, fee comparisons against banks, and historical rate charts. The data behind every page changes by the minute, which means each page is functionally never duplicate.

To replicate: find the variable in your product that updates frequently and that your customers actively query. Real-time inventory, pricing, weather, sports stats, market data — anything dynamic creates a moat.

Pattern 3: The local landing page (with real local data)

The TripAdvisor model — destination guides — generates 226M+ monthly visits. The pattern works for service businesses too, but only with real local data. AI-generated city descriptions copied across 500 pages get deindexed; real reviews, real photos, real local rankings, and real on-the-ground content survives.

To replicate: combine your customer reviews, real local photography (or contextually relevant Unsplash queries), service-area-specific pricing, and embedded GSC-tracked local intent. We covered the exact build for service businesses in AI-Powered Local SEO: How Small Businesses Create 10+ Localized Landing Pages in Hours.

The throughline across all three: the data is the moat, the agent just renders it.

A modern challenger case study

For a 2025-native data point, an AI image generator documented by Omnius grew organic traffic from 102 to 8,500 monthly visits in 10 months — an 850% jump — with monthly signups climbing from 67 to 2,100. Q1 2025 alone grew 220% over Q4 2024. The team did not use a 2018-style template; they used an AI-assisted programmatic stack with per-page differentiation. Same playbook, faster compounding.

The quality gate: what to check before any page publishes

Programmatic SEO without a quality gate is a deindexing pipeline. The 2025 case studies are unanimous on this. A good gate is automated, runs on every draft, and blocks publishes below threshold.

A working quality gate checks at least these eight criteria:

• Word count floor. 800 words minimum for category pages, 1,200 for comparison pages. Below the floor, the page goes to "needs expansion."

• Title and meta length. Meta title ≤ 60 characters. Meta description ≤ 160 characters — Quillly's publish_blog tool actively rejects descriptions over 160.

• Keyword placement. Primary keyword in H1, first 100 words of body, and at least two H2s.

• Heading hierarchy. One H1, multiple H2s, H3s only as sub-steps. Skipped levels fail.

• Image with alt text. At least one contextually relevant image, alt text descriptive (not stuffed).

• Internal links. Minimum three internal links, descriptive anchors, no generic "click here."

• Schema markup. FAQPage schema if FAQs exist; HowTo if it's a sequence; ProductComparison or Article otherwise.

• Uniqueness threshold. Less than 30% n-gram overlap with any other page on the same site.

Quillly bakes most of this into the 14+ criteria its scorer checks, and the bulk_seo_audit MCP tool runs the same gate across an entire site at once — useful before a big publish push or when you inherit a content set you didn't write. Pages below 75 surface for fixes; pages above 85 publish.

This gate is the part most "publish 1,000 pages with AI" tutorials skip. It's the part that separates Wise from the deindexed travel site.

Indexation: what to expect when you publish at scale

Publishing 100 pages does not equal indexing 100 pages. Track this metric or you're flying blind.

Healthy indexation benchmarks for programmatic content in 2026:

• 70%+ indexation rate is the floor. Below 70%, Google is signaling the pages are thin.

• 1.5%+ CTR on impressions earned. Below this, your titles and metas need a rewrite.

• 45 second+ average engagement time. Below this, your content isn't matching intent.

• Time-to-index of 7–21 days for Pro-tier sites with sitemap pings. Beyond 30 days suggests crawl budget issues or quality flags.

Use the get_gsc_performance MCP tool to pull these numbers per URL. The agent can flag the bottom decile of pages and queue them for refresh. This is what "agentic SEO" actually looks like in practice — not a one-shot publish, but a closed loop where each page's GSC data feeds back into prompts for either a rewrite or a kill decision.

Two other indexation rules from late-2025 case studies: don't publish all at once, and don't expand your sitemap by more than 30% in any 30-day window. Both trigger SpamBrain attention. Stagger.

Programmatic SEO + AEO: getting cited by ChatGPT and AI Overviews

The newer leverage on programmatic content isn't ranking on Google — it's getting cited as a source by ChatGPT, Google's AI Overviews, and Perplexity. Citations send traffic, and they're a ranking signal in their own right.

Three programmatic-friendly AEO tactics earned the most citation lift in our 2026 testing:

1. Front-load definitions. Open every page with a 40–60 word direct-answer paragraph that defines the topic in plain language. ChatGPT lifts this kind of paragraph at a 41% rate when the headline directly answers the query. The stakes here are real — the top 5 domains capture 38% of AI Overview citations and the top 20 capture 66% across an analysis of 36 million AI Overviews. Citation share concentrates fast.

2. Use definite language. "X is defined as," "X means," "X refers to" — pages using definite phrasing get cited 1.8x more than pages using "could be" or "may include."

3. Include 5+ data points with sources. Pages with 5+ statistics get cited by ChatGPT 20% more often. Pages with 19+ data points average 5.4 citations vs. 2.8 for pages with minimal data.

These tactics scale beautifully to programmatic content because the data spine already exists per page. You're not retrofitting numbers; you're surfacing the ones already underneath.

For the deeper version of this tactic set, see Answer Engine Optimization: The 2026 AEO Playbook.

Eight common programmatic SEO mistakes (and how to fix them)

These mistakes show up in nearly every audit of a programmatic SEO project that went sideways in 2025. Each has a one-step fix.

Mistake 1: Publishing everything at once. Indexing a 500-page site dump in 48 hours triggers crawl-budget caps and SpamBrain pattern-matching. Fix: stagger across 30–60 days. Quillly's scheduled publishing on Pro handles this natively.

Mistake 2: Treating the AI as the data source. When the LLM hallucinates pricing or specs because there's no data spine feeding it, every page becomes wrong in a different way. Fix: the agent reads from a real database row or spreadsheet via MCP. The agent renders; the data leads.

Mistake 3: Skipping the SEO score gate. Pages publish at whatever quality the model produced on first pass. Fix: check_blog_seo on every draft. Block publishes below 75. Loop fixes until 85+.

Mistake 4: No internal linking strategy. Every page is an island. Authority doesn't flow. Fix: run suggest_internal_links per draft, accept context-relevant anchors, push the rest to a backlog. Aim for 3–5 inbound internal links per page within 30 days of publish.

Mistake 5: Publishing on a subdomain. blog.yoursite.com versus yoursite.com/blog doesn't sound like much. It is. Subdomains inherit weaker authority and Google historically treats them as semi-distinct sites for some signals. Fix: publish to a subdirectory. Quillly does this by default.

Mistake 6: No GSC feedback loop. You publish, you forget. Fix: schedule a weekly agent run that calls get_gsc_performance, surfaces the bottom-decile pages, and queues them for refresh or removal.

Mistake 7: Ignoring schema markup. No FAQPage, no HowTo, no rich-result eligibility. Fix: the agent generates JSON-LD as part of every draft. Quillly attaches it via the schema_markup field on update_blog.

Mistake 8: One-shot publish, no refresh. Content updated within 30 days gets 3.2x more ChatGPT citations than content older than 90 days. Fix: the agent loops every 60–90 days, refreshes the spine, rewrites obviously stale sections, and rerun the SEO gate.

Most programmatic SEO obituaries trace back to two or three of these eight. Skip none.

Where MCP is heading next (and why this matters now)

iPullRank founder Mike King put the moment plainly at SEO Week 2025: "Do you all really want to stay the janitors of the web? This is our moment to really stand up and be something different." The agentic stack he was describing is the same one this guide outlines.

The MCP ecosystem is in the steep part of the adoption curve. As of April 2026:

• 17,468 MCP servers indexed across registries (Nerq Q1 2026 census).

• 97 million SDK downloads per month, a 970x year-over-year jump.

• OpenAI adopted MCP in March 2025, integrating it across ChatGPT desktop and the API.

• Anthropic donated the spec to the Linux Foundation in December 2025 — it's now a vendor-neutral standard.

• Forrester forecasts 30% of enterprise app vendors will ship their own MCP server in 2026.

• WordPress shipped its MCP Adapter into core in version 6.9 (December 2025) — every WordPress site can now expose itself as an MCP server. WordPress.com made every paid site MCP-ready by default on October 7, 2025.

• One caveat: The Register reported in April 2026 that a researcher claims roughly 200,000 MCP servers carry a design-flaw risk. Use first-party servers from vendors you trust, audit auth scopes, and don't expose credentials beyond what each tool needs.

The signal is loud: MCP is becoming the default integration surface for AI agents. The window for "we built a programmatic SEO system that's MCP-native" being a competitive edge is open right now and will narrow over the next 18 months. Sites built on this layer in 2026 will look the way Zapier-built integration directories looked in 2018: obvious in retrospect, hard to catch up on once the lead is established.

If you want the wider context on what MCP servers do for SEO beyond programmatic content, see MCP Servers for SEO: The 2026 Builder's Guide.

The minimum tooling stack you actually need

A programmatic SEO + MCP setup needs five components, and only five. Anything more is yak-shaving.

1. An AI agent. Claude Desktop (free), Cursor (free tier), ChatGPT Plus, or Gemini. Pick one.

2. Keyword and entity research. DataForSEO MCP, Ahrefs API, or your agent doing live SERP analysis.

3. A data spine. A spreadsheet, a Notion database, your own API, or scraped public data — whatever feeds unique facts per page.

4. A publishing layer with SEO scoring + internal linking + indexing baked in. Quillly fills this slot natively; the alternatives we benchmarked in Best AI Blog Writing Tools in 2026 require stitching together three or four tools to match the same surface.

5. Search Console connection. Without GSC, you can't close the feedback loop. Connect on day one, not month three.

If you have these five and the agentic loop above, you have everything a 2018 enterprise SEO team had — minus 95% of the headcount, the engineering glue, and the manual review.

Frequently asked questions

What is programmatic SEO with MCP?

Programmatic SEO with MCP is the practice of using the Model Context Protocol to let an AI agent like Claude or Cursor generate, score, internally link, and publish many unique pages directly to your domain. Unlike legacy programmatic SEO — which used spreadsheets and brittle CMS scripts — MCP collapses every step into one conversation, so the agent reads your data spine, writes a unique page per row, runs SEO checks, and ships.

Will Google penalize programmatic SEO content in 2026?

Google penalizes scaled content abuse, not programmatic content per se. Pages that rely on a real data spine, pass quality gates, and serve genuine search intent rank fine. Pages that swap a city name across 50,000 templates get deindexed — one travel site lost 98% of its programmatic pages within three months in late 2025. The dividing line is uniqueness and substance per page, not page count.

How many pages can I publish in a day?

A safe staggered publishing rate is 5–20 pages per day for a site under 1,000 total pages, ramping to 50/day once you're over 5,000 pages. Publishing all 100 at once on day one is the single most common trigger for SpamBrain flagging. Use scheduled publishing to spread releases across 7–30 days. Quillly's Pro plan includes scheduled publishing native.

What's the difference between programmatic SEO and AI content generation?

Programmatic SEO generates many pages from a structured data source plus a content layer. AI content generation produces individual pieces of writing. The two combine cleanly: AI is the writing layer; the data spine and templates are the programmatic layer. The pages that survive in 2026 use both together, with the agent doing the rendering and the data doing the differentiating.

Do I need to know how to code to do programmatic SEO with MCP?

Not anymore. Connecting an MCP server like Quillly's takes a config-file edit in Claude Desktop, Cursor, or ChatGPT. After that, every interaction is natural-language: "draft 30 comparison pages from this CSV." If you can run an Excel formula, you can run a 100-page programmatic project in 2026. The technical barrier is gone.

How long until programmatic pages get indexed?

For sites with sitemap pings and the Google Indexing API, 7–21 days is typical for healthy programmatic content in 2026. Beyond 30 days suggests either crawl budget caps (publishing too fast) or quality flags (thin content). Track indexation rate per cohort using get_gsc_performance and look for at least 70% indexed within 45 days. Anything lower means the gate let weak pages through.

What's the cheapest way to start with programmatic SEO with MCP?

Start with a free Quillly account — you get 1 site, 500 monthly credits, and 12 MCP tools. That's enough to test the loop on 20–30 pages. Bring your own AI (Claude Desktop is free; Cursor has a free tier) and you have a complete programmatic stack at $0/month. Move to Pro at $9/month when you need bulk creation, scheduled publishing, or more sites.

Is programmatic SEO better than ranking individual blog posts?

They serve different goals. Programmatic SEO captures long-tail head-plus-modifier searches at scale ("CRM for [industry]") where intent is consistent and templated answers are useful. Individual blog posts capture head terms and high-effort topics where one definitive piece outperforms many shallow pages. The strongest content programs in 2026 run both: programmatic for the long tail, hand-crafted pillar posts for the head. We covered the pillar side in AI Blog Automation: The Ultimate Guide.

The bottom line

Programmatic SEO with MCP is the cleanest scaling path content has had since Zapier built its integration directory. Three takeaways to put on a post-it:

1. Substance, not scale, is the constraint. A real data spine per page is the difference between Wise's 60.5M monthly visits and a deindexed travel site. Don't publish without a spine.

2. Score every page before it goes live. A 14+ criteria SEO gate plus internal linking is the difference between 15% and 97% indexation rates on the same domain.

3. Close the loop. The agentic part of agentic SEO is the GSC feedback cycle. Publish, measure, refresh — every 60–90 days, forever.

The builders winning in 2026 aren't the ones writing the most pages. They're the ones who turned their CMS, their SEO scorer, and their analytics into MCP servers and let an agent run the loop overnight.

Want your AI to actually publish the pages it just drafted? Connect Quillly to Claude, Cursor, or ChatGPT in 30 seconds. Free plan, your domain, no copy-paste.