Graphite

Large Webflow sites collect SEO work that the platform does not automate. Metadata still gets edited page by page, related-article modules still get built link by link, and nobody can see whether AI answer engines such as ChatGPT cite any of it.

Graphite closes those gaps from two directions. Its Webflow app audits and scores a site for SEO and AEO performance, then fixes metadata, robots.txt rules, and schema markup in bulk. Its Internal Links API goes further and writes link recommendations straight into Webflow CMS reference fields on a recurring schedule.

The pairing pays off most for content teams running a large CMS blog, where the linking job takes away the work nobody wants to do by hand. Marketing leads use the AI Tracker to watch how often assistants surface the site. Developers who maintain middleware between the two APIs get the most control over timing, and the most setup work.

How to integrate Graphite with Webflow

What is Graphite? Graphite is a growth agency and software product from Graphite Growth that works on answer engine optimization and organic search. Its Webflow surface has two parts: a Marketplace app for audits and bulk on-page fixes, and a Standard Internal Links API that returns semantically related pages for a given source URL, drawn from the pages Graphite has crawled and indexed for your site.

Teams pair Graphite with Webflow to run SEO and AEO programs on large CMS sites without opening items one at a time.

Graphite connects to Webflow in three ways. The Graphite app handles audits, bulk metadata edits, robots.txt rules, schema markup, and AI tracking with no code. JSON-LD structured data, added through Code Embed elements or head and body tags, gives Graphite's crawler a cleaner read of each page. The Webflow Data API and Graphite's Internal Links API together automate internal linking inside the CMS, and that path needs server-side development. Most implementations combine two of the three, depending on how much of the linking work you want automated.

Install the Graphite app

The Graphite app is a self-install listing on the Webflow Marketplace, so audits and bulk on-page edits need no code at all. Graphite Growth publishes it, Webflow has reviewed the listing, and it has a free plan.

Install and authorize it in Webflow:

1. Open the Graphite app listing on the Webflow Marketplace using the app button on this page.
2. Select the site you want to connect and authorize access.
3. Open the app and run your first SEO and AEO audit.

The listing covers five features:

• Bulk Edit Page Metadata: Update title tags, meta descriptions, OG images, and search settings across many pages from one view.
• Robots.txt Builder: Write crawling rules for the site without hand-editing a file in Site settings.
• Schema Markup Builder: Add structured data so pages qualify for rich search results.
• AI Training vs Indexing: Separate what AI crawlers may index from what they may train on.
• AI Tracker: Monitor how visible the site is across AI search engines and assistants.

The app is the right tool for auditing and bulk on-page fixes. Writing internal links into the CMS is a different job, and the API path below is what does it.

Add Graphite structured data with Code Embed elements

Graphite publishes an optional structured data specification that tells its crawler exactly what to read from a page. Without it the crawler falls back to your first H1, Open Graph tags, the title tag, and the full body text, which drags in header and footer noise. The specification accepts either RDFa meta tags or a JSON-LD document, and the JSON-LD form uses an @context of https://graphite.io/ns with an @type of WebPage.

Paste JSON-LD in a Code Embed element

Use a Code Embed element when the markup only applies to specific pages or CMS templates.

Add the markup:

1. Open the Add panel and drag a Code Embed element onto the canvas.
2. Paste your JSON-LD following Graphite's structured data specification.
3. Save the embed, then publish the site.

Each Code Embed element holds up to 50,000 characters, far more than a JSON-LD block needs.

Add site-wide markup in the head tag

For markup that applies everywhere, put it in the site's head code rather than an embed. This needs a paid Workspace or an active Site plan.

Add site-wide code in Webflow:

1. Go to Site settings > Custom code.
2. Paste your markup in the head code field.
3. Save and publish the site.

Get one thing right before any API work starts: the Internal Links API is keyed on a page's canonical URL, so every CMS template has to output a stable canonical that matches the URLs you hand Graphite for crawling. Mismatched canonicals are the quiet reason a link module comes back empty.

Build with the Webflow and Graphite APIs

To move link recommendations into CMS content programmatically, use the Internal Links integration. Graphite runs a periodic job that pushes recommendations into reference or multi-reference fields in your collections, carrying the article title, URL, image, category, read time, date, and page contents. Setup is collaborative rather than self-serve: Graphite provisions the API credentials and builds the internal links module on your Webflow instance, you approve the module design, and Graphite runs the first test job. On your side you supply a Webflow v2 API token scoped with cms:read and cms:write, site access at the designer or guest level, a sitemap or URL list, and the collection name plus item IDs.

This method touches four sets of endpoints:

• Graphite Standard Internal Links API: The related links endpoint returns semantically related pages for a source URL, balancing semantic similarity against an even spread of incoming links.
• Webflow CMS item endpoints: Read and patch collection items with an Authorization: Bearer YOUR_TOKEN header on the v2 base URL.
• Webflow publish endpoints: Move staged item changes onto the live site, either per collection or for the whole site.
• Event webhooks: Webflow's webhooks fire when a CMS item changes or the site publishes, which is what gives your middleware a real-time trigger.

Webflow deprecated the v1 API on March 31, 2025. It may still respond, but it no longer gets maintenance, updates, or support, so treat any tutorial that references v1 credentials as out of date and read the v1 deprecation notice if you still hold old tokens.

Sync internal link recommendations into the CMS

Graphite's periodic job follows the workflow below, and you can replicate it in your own middleware when you want to own the schedule. Graphite recommends calling the API server-side and caching the response rather than calling it from the browser, even though the endpoint is open to all origins and needs no auth header.

To implement the sync:

1. Request a client_id and module_id from Graphite, since those are provisioned by Graphite and are not self-serve.
2. Fetch recommendations with GET https://ilapi.graphite.io/<client_id>/<module_id>/related-links?url=<canonical_url> and parse the related_links array.
3. Write the results to a multi-reference field with PATCH https://api.webflow.com/v2/collections/{collection_id}/items/{item_id}.
4. Publish the items with POST https://api.webflow.com/v2/collections/{collection_id}/items/publish, then publish the site with POST https://api.webflow.com/v2/sites/{site_id}/publish.

Items written through the staged endpoints stay off the live site until both publish calls run, and the /live variants of the item endpoints skip staging when a change has to go out immediately. On the front end, render the multi-reference field with a Collection List, which shows up to 100 items, so paginate anything larger than that.

Trigger refreshes with Webflow webhooks

Graphite's documentation lists no outbound webhooks, so a real-time refresh has to start on the Webflow side. The pattern that works is a Webflow webhook calling your middleware, which reads the Internal Links API and writes the results back into the CMS.

Configure refreshes:

1. Register a webhook with POST https://api.webflow.com/v2/sites/{site_id}/webhooks using the sites:write scope.
2. Subscribe to collection_item_created for new content, collection_item_changed for link refreshes, and site_publish for post-publish audits.
3. In your middleware, fetch fresh recommendations on a cache miss and patch them back into the CMS.

Graphite recrawls your sitemap weekly by default and at most once a day, so a chatty webhook will mostly hit your cache. Set the cache TTL near 24 hours and let the crawl schedule do the rest.

What you can build with the Graphite Webflow integration

With Graphite connected, internal linking, metadata, and AI visibility work runs across the whole site instead of item by item.

Four builds cover most of what teams set up first:

• Automated internal linking modules: A related-articles block on every blog post, fed by a multi-reference field that Graphite's periodic job keeps current. Graphite publishes an A/B test of the pattern in its internal links white paper, and on the sites we see, the posts that gain most are the ones that started with almost no incoming internal links.
• Bulk metadata cleanup: A site-wide title and description pass handled in one view, instead of opening hundreds of page settings panels by hand.
• AI search visibility reporting: An AI Tracker read on your share of voice across the engines Graphite watches, including ChatGPT, Perplexity, Gemini, and Google AI Overviews.
• Rich results on CMS templates: Article and FAQ templates carrying schema built in the app, paired with robots.txt rules and AI training controls from the same place.

The API path is where the control lives, and it is also the part that needs a developer. Start with our Webflow CMS API guide if you are wiring the middleware yourself. Then connect the Webflow MCP server so an agent can handle sitemap, schema, SEO field, and content audit work inside Webflow while Graphite handles the crawl and the link recommendations.