Connect Attio to ChatGPT: Manage Relationships and Sales Workflows

To connect Attio to ChatGPT, you need a Model Context Protocol (MCP) server that translates the LLM's standardized tool calls into Attio's specific object, record, and list API requests. You can either build, host, and maintain this translation layer yourself (we compare the top options in our guide to the best MCP servers for Attio in 2026), or use a managed integration platform like Truto to dynamically generate a secure, authenticated MCP server URL. If your team uses Claude, check out our guide to connecting Attio to Claude, or explore our broader guide on connecting Attio to AI Agents.

Attio is a highly flexible, data-dense CRM used by AI-native companies like Replicate and Modal. Unlike legacy CRMs with rigid schemas, Attio relies heavily on custom objects, complex attribute types, and a unique list-entry architecture. Exposing this complexity to a Large Language Model (LLM) requires precise tool definitions and strict schema enforcement.

This guide breaks down exactly how to generate a managed MCP server for Attio, connect it natively to ChatGPT, and execute complex CRM workflows using natural language.

The Engineering Reality of Attio's API

A custom MCP server is a self-hosted integration layer. While the Model Context Protocol provides a predictable way for models to discover tools, implementing it against vendor APIs is a massive engineering sink. Just as we've seen when connecting Affinity to ChatGPT, if you decide to build a custom MCP server for Attio, you own the entire API lifecycle.

Attio's API introduces several specific integration challenges that break standard CRUD assumptions:

The Record vs. Entry Hierarchy In Attio, global entities (like a Company or a Person) are called Records. However, pipelines and workflows are managed via Lists. When you add a Record to a List, it becomes an Entry. Updating a deal's stage means updating the Entry attribute, not the global Record attribute. LLMs frequently hallucinate this distinction unless the MCP tools explicitly separate Record operations from Entry operations.

The Assert Pattern Standard POST /create endpoints often lead to duplicate data if an LLM creates a company that already exists. Attio uses an Assert pattern (attio_companies_assert). This acts as an intelligent upsert - you provide a matching attribute (like an email domain), and Attio either updates the existing record or creates a new one. Your MCP server must expose these assert endpoints as primary tools to prevent database pollution.

Complex Attribute Typing Attio attributes are strictly typed. A status attribute expects a specific status ID or normalized string, while a collaborator attribute expects an actor ID. When an LLM attempts to update an entry, the MCP server must provide the exact JSON schema for the request body, or the Attio API will reject the payload.

Rate Limits and Pagination When an AI agent requests all notes for a massive enterprise account, the response will be paginated. If the agent hits Attio's rate limits, the API returns a HTTP 429 error. Truto passes this error directly to the caller, normalizing the upstream rate limit info into standardized headers (ratelimit-limit, ratelimit-remaining, ratelimit-reset). The LLM must read these headers to implement intelligent backoff, a pattern that is equally critical when connecting Airtable to ChatGPT.

How to Create the Attio MCP Server

Instead of building this translation layer from scratch, you can use Truto to generate a secure MCP server URL. Truto reads Attio's API documentation, derives the exact query and body schemas, and exposes them as JSON-RPC 2.0 compatible tools.

Method 1: Via the Truto UI

This is the fastest path for internal tooling and testing.

1. Navigate to the Integrated Accounts page in your Truto dashboard and select your connected Attio account.
2. Click the MCP Servers tab.
3. Click Create MCP Server.
4. Select your desired configuration (e.g., restrict to read-only methods, or filter by specific tags).
5. Copy the generated MCP server URL (e.g., https://api.truto.one/mcp/a1b2c3d4e5f6...).

Method 2: Via the API

For B2B SaaS platforms provisioning AI agents programmatically for their end-users, you can generate MCP servers via the Truto REST API.

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": "Attio Sales Agent MCP",
    "config": {
      "methods": ["read", "write", "custom"]
    }
  }'

The response returns the self-contained URL. The token in the URL securely encodes the integrated account context and configuration filters.

How to Connect the MCP Server to ChatGPT

Once you have your MCP server URL, you need to register it with your LLM client. ChatGPT's Developer Mode supports direct MCP connections.

Method A: Via the ChatGPT UI

1. Open ChatGPT and navigate to Settings -> Apps -> Advanced settings.
2. Toggle Developer mode on (this feature requires a Pro, Plus, Team, or Enterprise account).
3. Under the MCP servers / Custom connectors section, click to add a new server.
4. Set the Name to something descriptive like "Attio CRM".
5. Paste the Truto MCP URL into the Server URL field.
6. Save the configuration. ChatGPT will immediately perform an initialization handshake and list the available Attio tools.

Method B: Via Manual Config (SSE Bridge)

If you are running a custom agent framework (like LangGraph or CrewAI) or testing locally, you can connect to the remote MCP server using Server-Sent Events (SSE). You specify the connection using the official MCP SSE client.

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

graph TD
    A[ChatGPT / Agent] -->|JSON-RPC 2.0 over HTTP| B(Truto MCP Router)
    B -->|Token Validation| C{KV Token Storage}
    B -->|Schema Mapping| D[Proxy API Layer]
    D -->|Standardized REST| E[(Attio API)]
    E -->|Raw JSON Response| D
    D -->|MCP Result Content| B
    B -->|Tool Execution Result| A

Core Attio Tools for AI Agents

Truto automatically generates descriptive snake_case tool names based on Attio's resource definitions. Here are the hero tools your AI agents will use most frequently.

attio_companies_assert

• Description: Creates or updates a company record in Attio using a unique matching attribute (typically domain or email). This is the safest way for an LLM to add new accounts without creating duplicates.
• Example Prompt: "Check if acme.com exists in Attio. If not, create a new company record for them and set their industry to SaaS."

attio_entries_assert

• Description: Adds a record to a specific list (pipeline) or updates its attributes if it already exists in that list.
• Example Prompt: "Add the Acme Corp record to the 'Enterprise Sales' list and set the deal stage to 'Discovery'."

update_a_attio_entry_by_id

• Description: Updates a specific list entry. This is the primary tool used for moving deals through pipeline stages or updating deal sizes.
• Example Prompt: "Update the Acme Corp entry in the Enterprise Sales list. Move the status to 'Closed Won' and update the ARR to $150,000."

list_all_attio_notes

• Description: Fetches historical notes attached to a parent object or record. Generated with limit and next_cursor parameters for pagination.
• Example Prompt: "Pull the last 5 notes for the Acme Corp deal and summarize any technical blockers mentioned by the sales engineer."

attio_records_attribute_values

• Description: Lists all values for a specific attribute on a record. Highly useful for inspecting custom fields before attempting an update.
• Example Prompt: "What are the current values for the 'Technical Requirements' custom attribute on the Acme Corp record?"

Complete Tool Inventory

Here is the complete inventory of additional Attio tools available. For full schema details, visit the Attio integration page.

• attio_entries_attribute_values: List all values for a specific attribute on an entry.
• attio_entries_overwrite: Update a list entry, overwriting existing multiselect values.
• create_a_attio_entry: Create an entry by adding a record to a list.
• attio_records_record_entries: List all entries for which this record is the parent.
• update_a_attio_record_by_id: Update a record and append new multiselect attribute values.
• attio_records_overwrite: Update a specific record, overwriting existing multiselect values.
• create_a_attio_record: Create a new record for a specific object.
• delete_a_attio_record_by_id: Delete a record by object and id.
• get_single_attio_record_by_id: Fetch a specific record.
• list_all_attio_records: List records for a specific object.
• attio_workspaces_record_entries: List all entries for a workspace record.
• attio_workspaces_attribute_values: List attribute values for a workspace record.
• attio_workspaces_assert: Create or update a workspace record.
• create_a_attio_workspace: Create a workspace record.
• list_all_attio_workspaces: List workspace records.
• get_single_attio_workspace_by_id: Get a specific workspace record.
• update_a_attio_workspace_by_id: Update a workspace record.
• delete_a_attio_workspace_by_id: Delete a workspace record.
• attio_users_attribute_values: List all values for an attribute on a user record.
• attio_users_record_entries: List all entries for a user record.
• update_a_attio_user_by_id: Update a user record.
• delete_a_attio_user_by_id: Delete a user record.
• attio_users_assert: Create or update a user record.
• get_single_attio_user_by_id: Get a user record.
• list_all_attio_users: List user records.
• create_a_attio_user: Create a user record.
• attio_deals_attribute_values: List deal record attribute values.
• attio_deals_record_entries: List all entries for a deal record.
• get_single_attio_deal_by_id: Get a specific deal record.
• delete_a_attio_deal_by_id: Delete a deal record.
• attio_deals_assert: Create or update a deal record.
• update_a_attio_deal_by_id: Update a deal record.
• attio_companies_record_entries: List all entries for a company record.
• attio_companies_attribute_values: List attribute values for a company record.
• delete_a_attio_company_by_id: Delete a company record.
• attio_people_attribute_values: List all values for a person record.
• attio_people_record_entries: List all entries for a person record.
• update_a_attio_person_by_id: Update a person record.
• get_single_attio_person_by_id: Get a person record.
• attio_people_assert: Create or update a person record.
• delete_a_attio_person_by_id: Delete a person record.
• list_all_attio_auth_session: Identify the current access token and scopes.
• delete_a_attio_webhook_by_id: Delete a webhook.
• create_a_attio_webhook: Create a webhook.
• update_a_attio_webhook_by_id: Update a webhook.
• get_single_attio_webhook_by_id: Get detailed webhook info.
• list_all_attio_webhooks: List all active webhooks.
• get_single_attio_comment_by_id: Get a specific comment.
• delete_a_attio_comment_by_id: Delete a comment.
• create_a_attio_comment: Create a comment on a thread, record, or entry.
• get_single_attio_thread_by_id: Get all comments in a thread.
• list_all_attio_threads: List threads.
• update_a_attio_task_by_id: Update a specific task.
• get_single_attio_task_by_id: Get a single task.
• delete_a_attio_task_by_id: Delete a task.
• delete_a_attio_note_by_id: Delete a note.
• get_single_attio_note_by_id: Get a note.
• get_single_attio_workspace_member_by_id: Get a workspace member.
• get_single_attio_entry_by_id: Get a specific list entry.
• list_all_attio_attribute_options: List select options for an attribute.
• get_single_attio_attribute_by_id: Get information about an attribute.
• update_a_attio_attribute_by_id: Update an attribute.
• list_all_attio_attributes: List attributes for an object or list.
• create_a_attio_attribute: Create an attribute.
• create_a_attio_object: Create a new custom object.
• list_all_attio_objects: List all objects.
• update_a_attio_object_by_id: Update an object definition.
• get_single_attio_object_by_id: Get an object definition.
• list_all_attio_tasks: List all tasks.
• create_a_attio_task: Create a new task.
• list_all_attio_workspace_members: List all members in a workspace.
• create_a_attio_note: Create a note attached to a record.
• list_all_attio_deals: List deal records.
• create_a_attio_deal: Create a new deal record.
• create_a_attio_person: Create a person record.
• list_all_attio_people: List person records.
• update_a_attio_company_by_id: Update a company record.
• get_single_attio_company_by_id: Get a company record.
• create_a_attio_company: Create a company record.
• delete_a_attio_entry_by_id: Delete an entry from a list.
• list_all_attio_entries: List entries in a specific list.
• update_a_attio_status_by_id: Update a status value.
• update_a_attio_list_by_id: Update a list definition.
• list_all_attio_statuses: List available statuses.
• create_a_attio_status: Create a new status.
• create_a_attio_list: Create a new list.
• get_single_attio_list_by_id: Get a single list definition.
• list_all_attio_lists: List all accessible lists.
• update_a_attio_attribute_option_by_id: Update a select option.
• create_a_attio_attribute_option: Create a select option.
• list_all_attio_me: Check validity of an access token.
• list_all_attio_companies: List company records.

Workflows in Action

Exposing an API to an LLM is only useful if the model understands how to chain those tools together. Here is how ChatGPT executes real-world Attio workflows using the Truto MCP server.

Scenario 1: Inbound Lead Triage

Prompt: "A new lead just signed up: jane@vertexanalytics.io. Check if Vertex Analytics exists in Attio. If they don't, create them. Then, ensure they are added to the 'Inbound Q3' list with the status 'New Lead'."

Execution Steps:

1. attio_companies_assert: ChatGPT calls this tool with the domain vertexanalytics.io. Attio checks for an existing record. If none exists, it creates the Company record and returns the new record_id.
2. attio_entries_assert: Using the record_id from the previous step, ChatGPT calls the entries assert tool targeting the 'Inbound Q3' list ID, passing "status": "New Lead" in the attribute payload.

Result: The model successfully creates the global record and inserts it into the specific pipeline view without duplicating existing data.

Scenario 2: Executive Deal Briefing

Prompt: "I have a sync with the CEO in 10 minutes. Get me the latest status on the 'Stark Industries' deal in the Enterprise list, and summarize the last 3 notes left by the sales engineering team."

Execution Steps:

1. list_all_attio_records: ChatGPT queries the company object to find the record_id for Stark Industries.
2. get_single_attio_entry_by_id: ChatGPT fetches the specific entry in the Enterprise list to read the current deal stage, ARR, and owner.
3. list_all_attio_notes: ChatGPT pulls the notes associated with the record_id, using the limit parameter to fetch the most recent entries.
4. Synthesis: The LLM parses the JSON responses and generates a concise, natural-language briefing for the user.

Security and Access Control

Giving an AI agent write access to your production CRM requires strict operational boundaries. Truto MCP servers provide several layers of access control:

• Method Filtering: Restrict an MCP server to read-only operations by passing config.methods: ["read"] during creation. The server will silently drop create, update, and delete tools from the LLM's available context.
• Tag Filtering: Scope access to specific functional areas. For example, use config.tags: ["companies", "people"] to prevent the agent from accessing internal workspace or user settings.
• Token Authentication: For enterprise deployments, enable require_api_token_auth: true. This forces the MCP client to pass a valid Truto API token in the Authorization header, meaning the URL alone is useless if leaked.
• Ephemeral Access: Set an expires_at timestamp when generating the server. Truto's scheduled cleanup tasks will automatically invalidate the token and revoke access at the specified time - ideal for temporary contractor access or sandboxed agent testing.

Strategic Wrap-Up

Connecting Attio to ChatGPT transforms conversational interfaces into actionable CRM command centers. By utilizing the Model Context Protocol, you decouple the LLM's reasoning engine from the underlying API mechanics.

Building this infrastructure in-house requires managing OAuth flows, parsing strict attribute schemas, and handling rate limit headers. Offloading this to a managed platform allows your engineering team to focus on prompt design and workflow orchestration rather than maintaining API boilerplate.