Adding one internal link to a Webflow blog post goes like this. Open the item, find the sentence, highlight the anchor text, click the link icon, go dig up the URL of the post you are pointing at, paste it, save. Then the next post, and the next, with your own spreadsheet tracking which ones you have covered, because Webflow does not track it for you. That ritual is the entire native feature: there is no automatic internal linking and no site-wide find and replace, and both sit on the Webflow Wishlist as open ideas. Every publish lands on the live site, where there is no undo.
Internal linking is pairwise work: whether post A should point at post B is a judgment about both posts, made across every possible pair in the collection, and the Editor only ever shows you one. AI changes that, and not by typing faster. Pulled into files on your laptop, the collection becomes something an agent can read end to end, decide which posts should point where, and place the links, with each inserted sentence coming back as a diff for you to read. The routes below split on two questions: whether the tool can read the whole blog, and who reads the links it adds.
Your options
Hand-linking in the Editor
For one link, Webflow's rich-text link box is honest work: highlight the anchor, paste the URL of the post you are pointing at, save. Full human judgment on every placement, no tooling, no token, nothing to configure. The trouble starts at link number two. There is no batch view, no record of which posts you have already covered, and no enforcement of an anchor standard beyond your own memory; nothing checks the URL for you, so a wrong one ships to the live page. At a careful 4 minutes per link, 200 links is over 13 hours in the Editor, plus the spreadsheet you keep on the side to remember where you have been.
A CSV round trip
Since 2022, a CSV import can update existing items instead of only creating new ones: export the collection, edit, re-import with "Link and update matching items" checked, matched on the Item ID column. It is native, free, and genuinely bulk. It is also rich text through a keyhole. The post body arrives as one spreadsheet cell of raw HTML, so you are hand-writing anchor tags inside a cell that nothing renders, validates, or diffs. An Item ID that does not match exactly is not flagged as a mismatch; those rows quietly import as new items. Webflow warns that code embeds may be cleaned up on the way back in. And between "import" and "live in the CMS", nothing shows you what the re-import will overwrite inside the body.
SEO linking tools
The finding half of this job is solved, and these tools earn the credit. A site audit takes the keywords each post ranks for, finds the unlinked mentions of them across the rest of the site, and hands you source, target, and suggested placement. Webflow-native linking apps go further, crawling your collections, syncing with Search Console, and queueing suggestions to approve or reject. Two gaps remain. With the report-only tools, every approved opportunity is still a manual edit in a rich-text field, so the report shortens the thinking and none of the typing. And an approve button is not a diff: you are approving an anchor and a target, not reading the changed sentence beside its original, and the result lands on a live site with no undo.
An MCP server on the live CMS
Wire an agent to the official Webflow MCP server and you get real speed and real judgment: it can list a whole collection, rewrite items, and stage the edits as drafts. API writes leave the Designer alone, which is the right boundary. What the loop is missing is a reader. The same tool surface that stages edits can publish them in the same run, so nothing between the agent's confidence and your live site requires a human to look. The token that updates items can also delete them. And Webflow's own tool schema warns, twice, that a slug update breaks every link pointing at the old one. On a platform with no undo, that is a lot resting on one prompt.
Scratch
Scratch keeps the agent and moves the work. Your collections pull down as local files, one per item, and the agent gets full read and write on the prose while holding no token to your site. Flag slugs, SEO fields, and publish state as never-touch and they are locked for the run. Every inserted link comes back as a word-level diff, one changed sentence next to its original, and only what you approve publishes back through the Webflow CMS API. An approved item that lands wrong reverts per item, even after publish. The cost is real and intentional: the review is you, reading every link before it ships.
| Option | Whole collection | Picks the link | Review before live | Undo after publish |
|---|---|---|---|---|
| Hand-linking in the Editor | No | You do | Your eyes, per link | No |
| CSV re-import | Yes | Bring your own | No | Full-site restore only |
| SEO linking tools | Yes | Suggests, you approve | An approve button, no diff | No |
| MCP server on the live CMS | Yes | Yes | Not required by anything | No |
| Scratch | Yes | Yes, your agent | Every link, as a diff | Per item, even after publish |
How the loop works on your blog
- Scratch pulls your collections into files. Every blog post lands as its own file on your laptop: the rich-text body, the plain-text fields, the slug and SEO fields beside it, locked where you flag them. Designer layout, components, and bindings are never exposed for editing. Nothing on the live site has changed.
- Your agent maps the blog, then places the links. Point Claude, Codex, Cursor, or Copilot at the folder and hand it the brief. Read every post. Where a post mentions a topic another post covers, link the first natural mention. One link per pair, anchors that read like prose, skip any post that already links there. This is where files beat endpoints. Linking is a pairwise job: a 200-post blog has 19,900 possible pairs, and the Webflow CMS API hands you items a page at a time, with no way to ask which posts mention a topic. On disk, the agent greps the corpus, builds a slug-and-topic index in seconds, and scores the pairs with a short script in about a minute. It does 99% of the work, and the only Webflow token in the loop stays with Scratch, so the agent cannot touch the live site even by accident.
- You review every diff and publish. Each inserted link is one changed sentence, the new anchor highlighted next to the original. Validators run first, if you set them: never-touch fields held, length caps, slug uniqueness. Approve per item, and Scratch publishes only those items back through the Webflow CMS API. The last 1%, deciding which links your readers actually follow, stays with you. So does the way back: reject a published item and the old body returns.
Start with the 20 posts that pull the most traffic, read those diffs closely, then send the agent through the rest. The pattern is already proven in the other direction: the outbound links skill runs this exact loop from a Webflow blog out to a product site, prompt included. Internal linking is the same job with the destinations already in the folder.
Here is the loop on a real Webflow site, in four and a half minutes:
What people run in the same pass
- Find the posts nothing links to and give each one inbound links from the posts where the mention already exists.
- Standardize anchor text, the site-wide find and replace Webflow does not have, so the 6 posts pointing at the same guide stop calling it 6 different things.
- Re-point every link aimed at a post you are about to retire, before it turns up in next quarter's broken-link pass.
- Backfill missing SEO titles and meta descriptions in the same pull, since page metadata is editable too.
Questions people ask
Can I read every link before it goes live?
Yes. Each insert shows up in Scratch as one changed sentence, the old version on one side and the new anchor highlighted on the other, before anything publishes. The agent only ever sees the folder of posts; the publish button, and the token behind it, live in Scratch, not in the agent.
Webflow has no undo. What happens when a link is wrong?
Nothing irreversible. Caught in review, you reject the row and the live site never knew. Caught after publish, you reject the published item and the original body goes back, per item. Webflow's own recovery path is restoring a backup of the entire site to roll back one bad publish. Per-item revert is the difference.
Will this touch my Designer layout, components, or bindings?
No. The links land inside rich-text fields on CMS items, and CMS data is a separate system from the Designer in Webflow itself. Scratch never exposes layout, components, bindings, or reference targets for editing, so there is nothing there for the agent to break.
What happens to my slugs?
Nothing, if you flag them. Mark slugs never-touch and validators hold them for the whole run, and that is not caution for its own sake. Internal links in rich text are plain URLs; Webflow does not update them when a slug changes, and Webflow's own developer tooling warns that a slug update breaks every link pointing at the old one. A linking pass is the worst moment to let slugs drift.
How does the AI decide which posts should link to each other?
It reads the whole blog first. The index it builds, what every post covers, plus what each ranks for if you hand it a Search Console export, turns linking from guesswork into scoring. It links a mention only where the target post genuinely covers the topic, and it skips a post rather than force a weak link. It reports the posts it skipped and why, so you can overrule it.
What about links the posts already have?
It skips them. Existing hrefs are greppable, so "already linked" is a check the agent runs, not a memory you keep. The rule in the brief is one link per post pair, and the diff is where you confirm it held.
Will adding links across the whole blog at once hurt my SEO?
It can. The failure mode is exact-match anchors stamped across 200 posts, which reads as manipulation to search engines and to people. The brief is the defense: anchors that read like prose, one link per pair, skip when nothing fits. Ship in reviewed batches and watch the target posts between them, their rankings and whether crawlers have picked up the new anchors. A batch that drags a target down reverts per item.
Is this a Webflow app or an MCP server?
Neither. Scratch is a desktop app on your laptop. Nothing installs into your Webflow site, and the agent never gets the keys: it edits files, and Scratch publishes only the items you approved through the Webflow CMS API. The agent and your live site never meet.
Do I need to be technical?
No. You write the brief in plain English and read the diffs; the index and the scoring script are things the agent writes for itself along the way. If the word grep meant nothing in step 2, nothing changes. The diffs read the same.
See it on your own blog
Two hundred posts is an afternoon, and most of it is the agent's. See it run on your Webflow blog →, or download Scratch free, connect Webflow, and pull your blog collection; the first 20 diffs will tell you whether you trust the rest. Scratch is free to try, and the AI is whichever agent you already pay for.