Connect ButterCMS to ChatGPT: Manage Content & SEO via MCP

You want to connect ButterCMS to ChatGPT so your AI agents can draft blog posts, update landing pages, query localized content, and manage SEO feeds automatically. If your team uses Claude, check out our guide on connecting ButterCMS to Claude, or explore our broader architectural overview on connecting ButterCMS to AI Agents.

Giving a Large Language Model (LLM) read and write access to a headless CMS like ButterCMS is an engineering challenge. Headless CMS platforms heavily decouple read operations (content delivery) from write operations (content management). You either spend weeks building, hosting, and maintaining a custom Model Context Protocol (MCP) server to handle this dichotomy, or you use a managed infrastructure layer that handles the boilerplate for you.

This guide breaks down exactly how to use Truto to generate a secure, managed MCP server for ButterCMS, connect it natively to ChatGPT, and execute complex content workflows using natural language.

The Engineering Reality of the ButterCMS API

A custom MCP server is a self-hosted integration layer that translates an LLM's tool calls into REST API requests. While the open MCP standard provides a predictable way for models to discover tools, implementing it against vendor-specific APIs is painful.

If you decide to build a custom MCP server for ButterCMS, you own the entire API lifecycle. Here are the specific integration challenges that break standard CRUD assumptions when working with ButterCMS:

Asynchronous Write API Operations

Unlike typical REST APIs that return the fully constructed object upon a POST or PUT request, the ButterCMS Write API relies on asynchronous processing. When you create a page or a blog post, the API returns a 202 Accepted status indicating that the request is queued. The LLM must be explicitly instructed on how to handle this asynchronous pattern. If your custom server assumes a 201 Created response with the full resource payload, the tool call will fail, and the LLM will hallucinate the outcome. You have to build polling mechanisms or train the LLM to understand that successful creation simply returns a status: "pending" acknowledgement.

Strict Rate Limits and 429 Passthroughs

ButterCMS enforces rate limits to protect its infrastructure, particularly on the Write API. When an LLM aggressively loops through content collections or tries to batch-update 50 localized pages, it will hit these limits.

Truto does not retry, throttle, or apply backoff on rate limit errors. When the ButterCMS API returns an HTTP 429 (Too Many Requests), Truto passes that error directly to the caller. However, Truto normalizes the upstream rate limit information into standardized headers (ratelimit-limit, ratelimit-remaining, ratelimit-reset) per the IETF specification. This means your MCP client or AI agent is fully responsible for reading these headers and executing exponential backoff. If you build this yourself, you have to parse ButterCMS's specific rate limit headers and map them to the MCP protocol manually.

Immutable Slugs and Partial Patching

When updating existing content via the Write API, certain fields like slug and title on pages are often immutable depending on the resource configuration. If an LLM attempts a full PUT request and includes the original slug, the API might reject the payload. Your server must support partial PATCH updates and dynamically filter out immutable fields based on the specific page type schema. Maintaining these schemas across dozens of custom page types is a massive maintenance burden.

How to Generate the ButterCMS MCP Server

Instead of building this translation layer from scratch, you can use Truto to dynamically generate a fully authenticated, schema-aware MCP server for ButterCMS.

Truto derives tools dynamically from the underlying ButterCMS API schemas. Tools are never cached or pre-built. Every time ChatGPT requests available tools, Truto builds the tool definitions based on the exact configuration of the connected ButterCMS account.

There are two ways to generate this MCP server: via the UI or programmatically via the API.

Method 1: Via the Truto UI

For IT admins or developers setting up manual workspaces:

1. Log in to your Truto dashboard and navigate to the Integrated Accounts page.
2. Select your connected ButterCMS account.
3. Click the MCP Servers tab.
4. Click Create MCP Server.
5. Select your desired configuration. You can restrict the server to specific methods (e.g., read only) or specific tags (e.g., content, seo).
6. Copy the generated MCP server URL (e.g., https://api.truto.one/mcp/abc123def456...).

Method 2: Via the Truto API

For platform engineers building multi-tenant AI products, you can generate MCP servers programmatically. Make a POST request to the /integrated-account/:id/mcp endpoint.

curl -X POST https://api.truto.one/integrated-account/YOUR_ACCOUNT_ID/mcp \
  -H "Authorization: Bearer YOUR_TRUTO_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "ChatGPT Content Editor Workspace",
    "config": {
      "methods": ["read", "write"],
      "require_api_token_auth": false
    },
    "expires_at": null
  }'

The API returns a ready-to-use MCP server URL. The token in the URL is cryptographically hashed before storage. The raw URL is only returned once, so store it securely.

{
  "id": "mcp_8x9y0z",
  "name": "ChatGPT Content Editor Workspace",
  "config": {
    "methods": ["read", "write"]
  },
  "expires_at": null,
  "url": "https://api.truto.one/mcp/a1b2c3d4e5f67890"
}

How to Connect the MCP Server to ChatGPT

Once you have the MCP server URL, connecting it to ChatGPT takes seconds. You can do this through the ChatGPT interface for individual users, or via a configuration file for custom desktop agents.

Method A: Via the ChatGPT UI

If you are using ChatGPT Plus, Enterprise, or Pro:

1. Open ChatGPT and navigate to Settings.
2. Select Apps and open Advanced settings.
3. Enable Developer mode (MCP support is gated behind this flag).
4. Under the MCP servers / Custom connectors section, click Add a new server.
5. Enter a Name (e.g., "ButterCMS Integration").
6. Paste your Truto MCP Server URL into the Server URL field.
7. Click Save.

ChatGPT will immediately ping the /initialize endpoint, execute a handshake, and request the list of available ButterCMS tools. No restart is required.

Method B: Via Manual Config File

If you are running a local MCP proxy, a custom LangChain agent, or integrating with an IDE like Cursor, you configure the connection using a JSON file. Use the @modelcontextprotocol/server-sse package to connect to Truto's Server-Sent Events (SSE) endpoint.

{
  "mcpServers": {
    "buttercms-prod": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-sse",
        "https://api.truto.one/mcp/a1b2c3d4e5f67890"
      ]
    }
  }
}

Security and Access Control

Exposing a production CMS to an autonomous agent requires strict boundaries. Truto provides four native security controls to restrict what ChatGPT can do:

• Method Filtering: Restrict the server to safe operations. Setting config.methods = ["read"] ensures the LLM can only execute get and list operations, physically preventing it from creating or deleting pages.
• Tag Filtering: Group operations by business logic. Setting config.tags = ["blog"] ensures the LLM only sees tools related to blog posts, hiding core page schemas and collections.
• Extra Authentication (require_api_token_auth): By default, the MCP URL alone is sufficient for access. Setting this flag to true forces the MCP client to also pass a valid Truto API token in the Authorization header, preventing unauthorized access if the URL leaks in logs.
• Expiration (expires_at): Schedule the server to self-destruct. Setting a future ISO datetime creates a cleanup alarm in the managed storage layer that permanently invalidates the token at the exact second specified.

Hero Tools for ButterCMS

Truto automatically maps ButterCMS's REST endpoints to descriptive, snake_case tools with highly optimized JSON schemas. Here are the highest-leverage tools available for your AI agents.

list_all_butter_cms_pages_searches

Searches ButterCMS pages by text query, returning matching pages sorted by relevancy. Only direct page content is searched; nested references are excluded from search indexing but are still included in the response payload based on the depth level configuration.

"Search the CMS for any landing pages that mention 'Enterprise SSO' and list their current slugs and last updated dates."

create_a_butter_cms_page

Creates a new ButterCMS page via the Write API. This tool supports multiple locales and automatic media uploads. The page_type schema must already exist in your ButterCMS account. Pages are created as drafts by default, and processing is asynchronous.

"Draft a new landing page using the 'marketing_lander' page_type. Set the title to 'Q4 Promo', the slug to 'q4-promo', and populate the header field with 'Start your Q4 strong'."

update_a_butter_cms_page_by_id

Updates an existing ButterCMS page using a partial PATCH request. This is critical for AI workflows because it modifies only the included fields while leaving the rest of the page intact. The id (slug) and title are immutable through this tool.

"Update the page with slug 'pricing-2026'. Change the 'hero_subtitle' field to 'Flexible plans for teams of all sizes'. Leave all other fields exactly as they are."

list_all_butter_cms_posts

Retrieves a paginated list of published ButterCMS blog posts sorted by publication date. You can filter by author_slug, category_slug, or tag_slug. Using the exclude_body parameter is highly recommended for LLMs to reduce payload size and save context window tokens.

"Fetch the latest 5 blog posts in the 'engineering' category. Use exclude_body to keep the response small, I only need the titles and URLs."

create_a_butter_cms_post

Creates a new ButterCMS blog post via the Write API. This tool supports author assignment, category mapping, tags, and media integration. Posts default to draft status and processing is asynchronous (202 Accepted). Scheduling is not supported directly on the create step.

"Create a new draft blog post titled 'How we scaled PostgreSQL'. Assign it to the author slug 'jane-doe' and add the tags 'database' and 'engineering'."

list_all_butter_cms_contents

Retrieves items from a user-defined ButterCMS Collection. This tool handles filtering, pagination, and relationship serialization. Because Collection fields are user-defined in the dashboard, the LLM will dynamically adapt to your specific schema.

"Query the 'customer_testimonials' collection and return all items where the 'rating' field is exactly 5."

list_all_butter_cms_feeds_sitemaps

Generates a standards-compliant XML sitemap of ButterCMS blog posts for search engine discovery. This returns the complete XML string with <loc> and <lastmod> entries, which is perfect for AI agents performing technical SEO audits.

"Generate the XML sitemap for the blog. Check the lastmod dates for the top 5 URLs and tell me which ones haven't been updated in over a year."

For the complete tool inventory, including endpoints for managing Authors, Categories, Atom feeds, and destructive operations, visit the ButterCMS integration page.

Workflows in Action

Connecting tools is just the prerequisite. The real value of an MCP server is orchestrating multi-step workflows autonomously. Here is how ChatGPT utilizes the ButterCMS tools in production scenarios.

Scenario 1: Automated SEO Audits & Feed Generation

Marketing teams often need to audit which localized pages are indexed and when they were last updated. Instead of manually exporting data, you can ask ChatGPT to run an analysis.

"Generate the XML sitemap for our blog. Find the 3 oldest posts based on the lastmod date. Then, run a text search on the CMS to see if any pages mention 'Legacy API'. If they do, outline a plan to update them."

Execution flow:

1. list_all_butter_cms_feeds_sitemaps: The agent fetches the raw XML sitemap and parses the <url> nodes to extract the oldest <lastmod> dates.
2. list_all_butter_cms_posts_searches: The agent executes a full-text search across the CMS querying "Legacy API".
3. Reasoning Engine: ChatGPT cross-references the old posts with the search results and generates a markdown report detailing exactly which slugs need content refreshes.

sequenceDiagram
    participant User as User
    participant LLM as ChatGPT
    participant MCP as Truto MCP Server
    participant API as ButterCMS API
    
    User->>LLM: "Audit old posts and search for 'Legacy API'"
    LLM->>MCP: Call list_all_butter_cms_feeds_sitemaps
    MCP->>API: GET /v2/feeds/sitemap
    API-->>MCP: Returns XML sitemap
    MCP-->>LLM: Returns XML sitemap
    LLM->>MCP: Call list_all_butter_cms_posts_searches(query: "Legacy API")
    MCP->>API: GET /v2/search/?query=Legacy API
    API-->>MCP: Returns matching pages
    MCP-->>LLM: Returns matching pages
    LLM-->>User: Delivers content refresh plan

Scenario 2: Draft to Publish Content Pipeline

Engineers shouldn't spend time copying markdown from Google Docs into CMS fields. You can ask ChatGPT to ingest raw text and structure it natively into ButterCMS.

"Take this raw text about our new SSO feature. Turn it into a well-formatted blog post. Create it as a draft in ButterCMS assigned to author 'product-team' with the category 'releases'."

Execution flow:

1. Reasoning Engine: ChatGPT processes the unstructured text, writes SEO-optimized headings, and formats the body as HTML/Markdown depending on your CMS setup.
2. create_a_butter_cms_post: The agent constructs the JSON payload with title, body, author_slug: "product-team", and categories: ["releases"].
3. create_a_butter_cms_post: The Truto proxy API executes the Write API request, returning the 202 Accepted status.
4. Reasoning Engine: The agent informs the user that the post is successfully queued as a draft in the ButterCMS dashboard.

flowchart TD
    A["User provides<br>raw text"] --> B["ChatGPT formats<br>SEO structure"]
    B --> C["Call create_a_butter_cms_post"]
    C --> D["Truto validates<br>schema parameters"]
    D --> E["ButterCMS returns<br>202 Accepted"]
    E --> F["ChatGPT confirms<br>draft creation"]

Scenario 3: Bulk Collection Updates

Managing structured data in Collections (like customer testimonials or event listings) is tedious. You can instruct ChatGPT to surgically update records.

"Search the 'events' collection for any items where the 'location' field is 'San Francisco'. Update those specific items to change the 'status' field to 'sold_out'."

Execution flow:

1. list_all_butter_cms_contents: The agent queries the events collection to retrieve the current payload.
2. Reasoning Engine: ChatGPT filters the JSON array in its context window, isolating records matching location == "San Francisco".
3. butter_cms_contents_partial_update: For each matched record, the agent calls the partial update tool, passing the specific id and a payload containing only {"status": "sold_out"}.
4. Rate Limit Handling: If the batch update triggers a 429 Too Many Requests, Truto passes the error back with ratelimit-reset headers. The LLM waits the required seconds and retries the failed item.

Summary

Connecting ButterCMS to ChatGPT via a custom-built integration requires engineering teams to solve complex problems: managing asynchronous Write API states, enforcing schema validation on custom page types, and handling strict rate limit backoffs.

Truto abstracts this complexity entirely. By automatically translating ButterCMS's API definitions into standardized, highly optimized MCP tools, Truto allows your engineering team to connect AI agents to your CMS in minutes instead of months. The dynamic tool generation ensures that as your team adds new collections or page types to ButterCMS, ChatGPT instantly understands the new schemas without requiring a single line of deployment code.