---
title: "Connect Botify to ChatGPT: Automate SEO Audits & Crawl Management"
slug: connect-botify-to-chatgpt-automate-seo-audits-crawl-management
date: 2026-08-07
author: Riya Sethi
categories: ["AI & Agents"]
excerpt: "Learn how to connect Botify to ChatGPT using a managed MCP server. Automate SEO audits, crawl management, and complex BQL data queries with AI."
tldr: "Connecting Botify to ChatGPT requires translating complex Botify Query Language (BQL) payloads and nested project slugs into AI tools. This guide shows how to deploy a managed MCP server to give ChatGPT secure, structured read/write access to Botify."
canonical: https://truto.one/blog/connect-botify-to-chatgpt-automate-seo-audits-crawl-management/
---

# Connect Botify to ChatGPT: Automate SEO Audits & Crawl Management


If you need to connect Botify to ChatGPT to automate technical SEO audits, manage web crawls, or extract deep log file analytics, you need a [Model Context Protocol (MCP) server](https://truto.one/what-is-mcp-and-mcp-servers-and-how-do-they-work). This server acts as the translation layer between ChatGPT's tool calls and Botify's REST APIs. If your team uses Claude instead, check out our guide on [connecting Botify to Claude](https://truto.one/connect-botify-to-claude-analyze-search-performance-url-insights/), or explore our architectural overview on [connecting Botify to AI Agents](https://truto.one/connect-botify-to-ai-agents-run-bql-queries-large-scale-exports/) for broader multi-agent setups.

Giving a Large Language Model (LLM) read and write access to an enterprise SEO platform like Botify is a massive engineering challenge. You have to handle deeply nested authentication architectures, [map fluid data models to MCP tool definitions](https://truto.one/what-is-llm-function-calling-for-integrations-2026-guide), and deal with highly specific rate limits. Every time an endpoint shifts or a custom field is added, you have to update your server code, redeploy, and test the integration. 

This guide breaks down exactly how to use Truto to dynamically [generate a secure, authenticated MCP server for Botify](https://truto.one/how-to-generate-mcp-servers-for-your-saas-users-2026-architecture-guide), connect it natively to ChatGPT, and execute complex technical SEO workflows using natural language.

## The Engineering Reality of the Botify API

A custom MCP server is a self-hosted integration layer. While the open MCP standard provides a predictable way for models to discover tools, implementing it against Botify's massive enterprise architecture - or [maintaining custom connectors for 100+ other platforms](https://truto.one/bring-100-custom-connectors-to-chatgpt-with-superai-by-truto/) - is painful.

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

**The BQL (Botify Query Language) Complexity**
Botify does not just give you a flat list of URLs. To analyze crawl data, you must use Botify Query Language (BQL). BQL payloads are heavily nested JSON objects containing `filters`, `aggs`, and specific dimension declarations. Furthermore, the valid fields for a BQL query change dynamically based on the project's specific `datamodel`. If your MCP server doesn't first fetch the dynamic datamodel schema and perfectly translate it into JSON Schema for the LLM, ChatGPT will hallucinate invalid BQL queries and every request will fail with a 400 Bad Request.

**Hierarchical State Management**
Almost every actionable endpoint in Botify is deeply nested. To get crawl statistics, the API requires the `username`, the `project_slug`, and the `analysis_slug`. LLMs are notorious for losing context in long conversations. If your custom server doesn't enforce these required parameters strictly via JSON schema validation, the LLM will drop the `project_slug` mid-conversation and the API calls will crash.

**Asynchronous Exports and Job Polling**
Extracting large URL sets from Botify isn't a synchronous GET request. You must POST to create a CSV export job, store the resulting `job_id`, and then repeatedly poll the job status endpoint until it succeeds. Forcing an LLM to manage asynchronous polling states via MCP tool calls requires strict instruction sets - otherwise, the agent will assume the first HTTP 201 means the data is ready to download.

**Rate Limits and 429 Errors**
Factual note on rate limits: Truto does not retry, throttle, or apply backoff on rate limit errors. When an upstream API like Botify returns an HTTP 429, Truto passes that error directly to the caller. Truto normalizes upstream rate limit info into standardized headers (`ratelimit-limit`, `ratelimit-remaining`, `ratelimit-reset`) per the IETF spec. The caller - your agentic framework or ChatGPT itself - is responsible for handling retry/backoff logic. Do not build an integration expecting the middle tier to absorb these limits.

## The Managed MCP Approach

Instead of forcing your engineering team to build, host, and maintain a custom Node.js or Python MCP server to handle BQL translation and nested slugs, you can use Truto.

Truto's MCP servers feature turns any connected Botify account into a fully compliant JSON-RPC 2.0 endpoint. Truto dynamically derives the tool definitions from the integration's resource schema. If Botify updates their API, Truto's definitions update automatically. 

Here is how to generate your Botify MCP server and connect it to ChatGPT.

### Step 1: Create the MCP Server

You can generate an MCP server for Botify using either the Truto UI or the API. Both methods output a secure, token-protected URL.

**Method A: Via the Truto UI**
1. Log into your Truto dashboard and navigate to the integrated account page for your Botify connection.
2. Click the **MCP Servers** tab.
3. Click **Create MCP Server**.
4. Select your configuration (e.g., allow `read` and `write` methods, set an expiration date if needed).
5. Copy the generated MCP server URL (it will look like `https://api.truto.one/mcp/abc123def456...`).

**Method B: Via the API**
You can programmatically generate MCP servers for your end-users by calling the Truto API. This validates that tools are available, stores the hashed token in Cloudflare KV for low-latency lookup, and returns the URL.

```bash
curl -X POST https://api.truto.one/integrated-account/{integrated_account_id}/mcp \
  -H "Authorization: Bearer YOUR_TRUTO_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Botify SEO Agent",
    "config": {
      "methods": ["read", "write", "custom"]
    }
  }'
```

*Response:*
```json
{
  "id": "mcp_srv_9x8y7z",
  "name": "Botify SEO Agent",
  "config": { "methods": ["read", "write", "custom"] },
  "expires_at": null,
  "url": "https://api.truto.one/mcp/a1b2c3d4e5f67890"
}
```

### Step 2: Connect the Server to ChatGPT

With the URL generated, you now connect it to your client. 

**Method A: Via the ChatGPT UI**
1. Open ChatGPT and navigate to **Settings -> Apps -> Advanced settings**.
2. Enable **Developer mode** (MCP capabilities are behind this flag).
3. Under **MCP servers / Custom connectors**, click to add a new server.
4. Enter a name (e.g., "Botify SEO Ops").
5. Paste the Truto MCP URL into the Server URL field.
6. Save. ChatGPT will immediately perform the protocol handshake and list the discovered Botify tools.

**Method B: Via Manual Config File**
If you are using a headless setup, Claude Desktop, or an agent framework like Cursor, you configure the connection using the standard SSE transport.

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

## Hero Tools for Botify

Once connected, ChatGPT instantly inherits a powerful set of tools mapped directly from Botify's API documentation. Here are the core "hero" tools you will use to automate technical SEO.

### list_all_botify_analyses
This tool retrieves all analyses (crawls) for a specific project. This is almost always the first tool ChatGPT must call to establish context, as it needs to extract the `analysis_slug` for downstream operations.

> "Fetch all recent crawl analyses for my Botify project with the slug 'global-ecommerce' under the username 'seo-team'. I need the analysis slug for the most recently completed crawl."

### list_all_botify_crawl_statistics
Retrieves global crawl statistics for an analysis. This exposes the high-level metrics required for immediate triage - total URLs crawled, depth distributions, and top-level HTTP status codes.

> "Get the global crawl statistics for the analysis slug 'crawlv5-2026' in the 'global-ecommerce' project. Summarize the percentage of non-200 HTTP status codes."

### list_all_botify_urls_datamodels
Because Botify data schemas are highly dynamic based on crawl settings, this tool fetches the active datamodel. The agent must use this to understand which fields are queryable before attempting to write a BQL query.

> "Retrieve the URLs datamodel for the 'crawlv5-2026' analysis. Tell me the exact JSON field name used to query URLs that contain missing H1 tags."

### get_single_botify_urls_agg_by_id
This is the workhorse tool. It executes BQL aggregation queries against the URLs collection. ChatGPT formulates the payload using dimensions and metrics derived from the datamodel tool, pushing massive data processing onto Botify's servers instead of pulling raw rows.

> "Run an aggregation query on the 'crawlv5-2026' analysis to group all 404 URLs by their 'segment' dimension. Return the count of URLs in each segment."

### list_all_botify_search_console_stats
Blends crawl data with real search performance. This tool fetches Google Search Console clicks and impressions per day for the specified analysis, allowing the LLM to cross-reference traffic drops with crawl errors.

> "Fetch the Google Search Console stats for the 'crawlv5-2026' analysis. Are we seeing a correlation between impression drops and the dates the crawl ran?"

### list_all_botify_sitemaps_reports
Retrieves the sitemaps report, providing global intelligence on sitemap indexes and invalid sitemap URLs found during the crawl. Critical for diagnosing indexation leaks.

> "Get the sitemaps report for the 'crawlv5-2026' analysis. List all URLs found in the sitemap that returned a 404 or were blocked by robots.txt."

For the complete inventory of available Botify operations and schema requirements, view the [Botify integration page](https://truto.one/integrations/detail/botify).

## Workflows in Action

Providing ChatGPT with isolated tools is useful, but the real power of MCP is chaining these operations into autonomous agentic workflows.

### Workflow 1: SEO Audit Triage
When a new crawl finishes, SEO managers manually hunt for red flags. ChatGPT can automate this entire diagnostic run.

> "Look up the latest completed analysis for project 'blog-network' under username 'seo-ops'. Get the global crawl statistics. If the percentage of 5xx errors is higher than 1%, fetch the sitemaps report to see if those 5xx errors are currently being submitted to Google."

1. ChatGPT calls `list_all_botify_analyses` using the provided username and project slug to find the newest `analysis_slug`.
2. ChatGPT calls `list_all_botify_crawl_statistics` to extract the global HTTP error distribution.
3. Detecting >1% 5xx errors, ChatGPT conditionally calls `list_all_botify_sitemaps_reports` to cross-reference the errors against submitted sitemap URLs.
4. The agent returns a synthesized Slack-ready summary warning the team of critical indexation risks.

```mermaid
sequenceDiagram
    participant LLM as ChatGPT
    participant MCP as Truto MCP Server
    participant Upstream as Botify API

    LLM->>MCP: list_all_botify_analyses
    MCP->>Upstream: GET /analyses/seo-ops/blog-network
    Upstream-->>MCP: Analysis List
    MCP-->>LLM: analysis_slug: "crawl-run-12"
    
    LLM->>MCP: list_all_botify_crawl_statistics
    MCP->>Upstream: GET /crawl_stats/crawl-run-12
    Upstream-->>MCP: Stats (2.4% 5xx errors)
    MCP-->>LLM: 5xx threshold breached
    
    LLM->>MCP: list_all_botify_sitemaps_reports
    MCP->>Upstream: GET /sitemaps/crawl-run-12
    Upstream-->>MCP: Sitemap Data
    MCP-->>LLM: 42 sitemap URLs returning 5xx
```

### Workflow 2: Investigating Traffic Drops via Dynamic BQL
When traffic dips, SEOs need to isolate specific page templates or segments. ChatGPT can inspect the data model, write the BQL, and execute the aggregation.

> "Traffic dropped this week. Find the latest analysis for 'ecomm-main'. First, check the search console stats. Then, check the URLs datamodel for how segment fields are named. Finally, run an aggregation grouping URLs by segment where the HTTP status code is 404, so we know which template is broken."

1. ChatGPT calls `list_all_botify_analyses` to establish the `analysis_slug`.
2. ChatGPT calls `list_all_botify_search_console_stats` to verify the traffic drop dates.
3. Crucially, ChatGPT calls `list_all_botify_urls_datamodels` to discover that segments in this specific configuration are queried using the key `metadata.segments.type`.
4. ChatGPT formats a valid BQL payload and calls `get_single_botify_urls_agg_by_id`, filtering for `http_code: 404` and aggregating by `metadata.segments.type`.
5. The agent returns a list proving that the 'Product Pages' segment is driving the 404 spike.

```mermaid
flowchart TD
    A["Get Analysis Slug<br>(list_all_botify_analyses)"] --> B["Check GSC Stats<br>(search_console_stats)"]
    B --> C["Fetch Datamodel Schema<br>(list_all_botify_urls_datamodels)"]
    C --> D["Format Valid BQL Payload<br>(Using dynamic schema keys)"]
    D --> E["Execute BQL Aggregation<br>(get_single_botify_urls_agg_by_id)"]
    E --> F["Isolate Broken Segment"]
```

## Security and Access Control

Giving an AI agent programmatic access to enterprise SEO architecture requires strict guardrails. Truto's MCP tokens are designed to enforce least-privilege principles at the API gateway layer.

*   **Method Filtering**: You can restrict an MCP server to only allow `read` operations. If a user prompts the LLM to "pause the current analysis" (`botify_analyses_pause`), the MCP server will reject the `write` request before it ever reaches Botify.
*   **Tag Filtering**: Limit the server to specific operational domains. For instance, you can expose only `analytics` tagged tools while blocking `configuration` tools, ensuring the LLM cannot alter project settings.
*   **Time-to-Live (TTL)**: Servers can be generated with an `expires_at` timestamp. This is ideal for CI/CD automation where an agent is spun up to audit a staging environment and its access is automatically revoked an hour later via Cloudflare KV expiration.
*   **Require API Token Auth**: For internal enterprise deployments, possessing the MCP URL isn't enough. By setting `require_api_token_auth: true`, the client must also pass a valid Truto API token in the `Authorization` header, mapping the AI's actions to an authenticated corporate identity.

## Architecting for Scale

Building an AI-driven SEO practice requires predictable infrastructure. Custom scripts that attempt to translate conversational requests into valid Botify Query Language will inherently fail at edge cases. By deploying a dynamic, schema-aware integration layer, your AI agents gain a deterministic interface into your SEO operations.

Using a managed MCP server removes the overhead of manual token rotation, webhook management, and endpoint translation. It guarantees that when Botify updates its datamodels, your ChatGPT workflows remain operational without engineering intervention.

> Stop building custom integrations for every AI agent. Let Truto handle the authentication, schema translation, and MCP architecture while your engineering team focuses on core product velocity.
>
> [Talk to us](https://cal.com/truto/partner-with-truto)