---
title: "Connect Breeze to ChatGPT: Manage Member Data and Event Attendance"
slug: connect-breeze-to-chatgpt-manage-member-data-and-event-attendance
date: 2026-11-10
author: Sidharth Verma
categories: ["AI & Agents"]
excerpt: "Learn how to build a secure MCP server for Breeze to automate member management, track event attendance, and sync contributions directly from ChatGPT."
tldr: "Connect Breeze to ChatGPT using a managed MCP server. This guide covers overcoming Breeze's unique API quirks, generating MCP tools for member data and events, and orchestrating complex church management workflows."
canonical: https://truto.one/blog/connect-breeze-to-chatgpt-manage-member-data-and-event-attendance/
---

# Connect Breeze to ChatGPT: Manage Member Data and Event Attendance


If you need to connect Breeze to ChatGPT to automate member directories, track event attendance, or process contribution data, 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 Breeze's highly idiosyncratic REST API. You can either spend weeks building and hosting this infrastructure yourself, 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 on [connecting Breeze to Claude](https://truto.one/connect-breeze-to-claude-sync-giving-records-and-volunteer-rosters/) or explore our broader architectural overview on [connecting Breeze to AI Agents](https://truto.one/connect-breeze-to-ai-agents-automate-tagging-forms-and-calendars/).

Giving a Large Language Model (LLM) read and write access to a Church Management Software (ChMS) platform like Breeze is an engineering challenge. Breeze's API deviates significantly from standard REST conventions, making generic API-to-LLM wrappers fail. Every time you need to update a member profile, log attendance, or map custom fields, your custom server code must manipulate payloads into bizarre stringified arrays and query parameters. 

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

> Stop writing boilerplate API integration code. Let Truto generate secure, managed MCP servers for your AI agents in seconds.
>
> [Talk to us](https://truto.one/book-a-demo/)

## The Engineering Reality of the Breeze API

A custom MCP server is a self-hosted integration layer. While the [open MCP standard](https://truto.one/what-is-mcp-and-mcp-servers-and-how-do-they-work/) provides a predictable way for models to discover tools via JSON-RPC, implementing it against Breeze's API is exceptionally painful. 

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

### Query String Writes and Wrapper Quirks
In a standard REST API, when you create or update a record (POST or PUT), you send the payload in the JSON body. Breeze's API does not work this way. Its native API wrapper forces arguments for creation and deletion into the URL query string, often executing as GET requests internally. For example, creating a family member or deleting an attendance record requires passing the data via query parameters. If your custom MCP server attempts to pass standard JSON bodies to these endpoints, the requests will fail silently or return validation errors. Your server must parse the LLM's JSON arguments and reconstruct them as URL-encoded query strings.

### The fields_json Complexity for Profiles
When updating or creating a person in Breeze, you cannot pass a flat JSON object like `{"email": "user@example.com"}`. Instead, Breeze requires a `fields_json` parameter. This is a stringified JSON array containing objects with specific internal field IDs (e.g., `[{"field_id": "92913", "field_type": "email", "response": "user@example.com"}]`). This means your MCP server must first fetch the dynamic profile fields (`list_all_breeze_profile_fields`), map the LLM's natural language field names to Breeze's internal numeric IDs, construct the array, stringify it, and append it to the query string. Expecting an LLM to navigate this mapping natively guarantees hallucinations.

### Composite Keys for Deletion
Standard APIs allow you to delete a record by its unique ID (e.g., `DELETE /attendance/123`). Breeze often lacks single record IDs for associative data. To remove an attendance record or a family member association, you must pass named composite fields - for example, `person_id` and `instance_id`. If an LLM attempts to pass a primary key ID it found in a previous list response, the deletion will fail because the endpoint expects a composite key structure.

### Rate Limiting and Pagination Inconsistencies
Breeze has strict rate limits and wildly inconsistent pagination models. The `list_all_breeze_people` endpoint requires traditional `limit` and `offset` parameters to page through large congregations. However, endpoints like `list_all_breeze_events` accept a `limit` but do not support offsets - meaning they do not page normally. Furthermore, you must handle backoff manually. 

**A factual note on rate limits:** Truto does not retry, throttle, or apply backoff on rate limit errors. When the upstream Breeze API returns an HTTP 429, Truto passes that error directly to the caller. Truto normalizes the upstream rate limit information into standardized headers (`ratelimit-limit`, `ratelimit-remaining`, `ratelimit-reset`) per the IETF spec. ChatGPT or your custom agent framework is entirely responsible for reading these headers and executing retry/backoff logic.

## Step 1: Creating the Breeze MCP Server

Instead of building a translation layer from scratch, Truto [dynamically derives MCP tool definitions](https://truto.one/auto-generated-mcp-tools-for-ai-agents-a-2026-architecture-guide/) from Breeze's API documentation and endpoint schemas. You can generate a scoped MCP server for a specific Breeze account using either the Truto UI or the API.

### Method A: Via the Truto UI

For teams managing integrations manually or testing workflows, the dashboard provides a one-click server generation flow:

1. Log into your Truto account and navigate to the **Integrated Accounts** page.
2. Select the connected Breeze account you want to expose to ChatGPT.
3. Click the **MCP Servers** tab.
4. Click **Create MCP Server**.
5. Configure the server (name, allowed methods, tags, and expiration).
6. Copy the generated MCP server URL (e.g., `https://api.truto.one/mcp/a1b2c3d4e5f6...`).

### Method B: Via the API

If you are dynamically provisioning AI agents for your users, you can generate MCP servers programmatically. This endpoint verifies that tools exist, generates a secure cryptographic token hashed in Cloudflare KV, and returns a ready-to-use URL.

**Request:**
```bash
curl -X POST https://api.truto.one/integrated-account/$BREEZE_ACCOUNT_ID/mcp \
  -H "Authorization: Bearer $TRUTO_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Breeze ChatGPT Assistant",
    "config": {
      "methods": ["read", "write"],
      "tags": ["people", "events", "attendance"]
    }
  }'
```

**Response:**
```json
{
  "id": "mcp_8a9b0c1d",
  "name": "Breeze ChatGPT Assistant",
  "config": {
    "methods": ["read", "write"],
    "tags": ["people", "events", "attendance"]
  },
  "expires_at": null,
  "url": "https://api.truto.one/mcp/a1b2c3d4e5f67890"
}
```

Treat this `url` as a highly sensitive secret. It encodes the tenant routing and authentication required to execute tools against that specific Breeze instance.

## Step 2: Connecting the MCP Server to ChatGPT

Once you have your Truto MCP URL, you need to register it with ChatGPT. The [MCP architecture](https://truto.one/what-is-mcp-and-mcp-servers-and-how-do-they-work/) allows ChatGPT to send a JSON-RPC `tools/list` request to discover capabilities, and `tools/call` to execute them.

### Method A: Via the ChatGPT UI (Developer Mode)

If you are using a ChatGPT Pro, Plus, Business, Enterprise, or Education account, you can attach the server directly in the web interface:

1. Open ChatGPT and navigate to **Settings -> Apps -> Advanced settings**.
2. Enable **Developer mode** (MCP support requires this flag).
3. Under the **MCP servers / Custom connectors** section, click **Add new server**.
4. Set the **Name** to something recognizable (e.g., "Breeze ChMS").
5. Paste the Truto MCP URL into the **Server URL** field.
6. Click **Save**.

ChatGPT will immediately ping the server, run the initialization handshake, and populate its context window with the available Breeze tools.

### Method B: Via Manual Config File (SSE Proxy)

If you are orchestrating custom OpenAI agents via code or need to proxy the connection through a local development environment, you can use the official MCP SSE transport module. 

Create an `mcp.json` file to route traffic to Truto's endpoint:

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

When your agent framework starts, it will spawn the proxy process, establishing a secure connection to Truto and retrieving the Breeze schemas.

## Security and Access Control

Giving an LLM unconstrained access to a church database containing sensitive donor records and pastoral notes is a massive security risk. Truto's MCP servers provide strict, granular controls defined at creation time:

*   **Method Filtering (`methods`):** Restrict the server to specific operation types. Setting `methods: ["read"]` ensures the LLM can only retrieve data (via GET/LIST tools) and physically cannot modify records or delete attendance data.
*   **Tag Filtering (`tags`):** Scope tools by domain. If you only want the LLM to analyze event data, passing `tags: ["events"]` will strip out all tools related to contributions, profile fields, or tags.
*   **Additional Authentication (`require_api_token_auth`):** By default, the MCP URL acts as a bearer token. For high-security environments, setting this flag to `true` requires the connecting client to also pass a valid Truto API token in the Authorization header, preventing URL leakage exploits.
*   **Ephemeral Servers (`expires_at`):** You can pass an ISO datetime to automatically revoke the server. Truto uses Cloudflare KV expiration and Durable Object alarms to permanently destroy the server and its hashed tokens at the exact millisecond requested. 

## Hero Tools for Breeze Automation

Truto dynamically translates Breeze's API surface into discrete, schema-validated tools. Here are the highest-leverage operations for building church administration workflows in ChatGPT. 

### list_all_breeze_people
Retrieves member records from the database. Truto handles the offset loop internally if a limit is provided, paging through the records. You can filter the results using a `filter_json` string to isolate specific demographics or tag groups.

> "Find all active members in the 'Youth Ministry' tag and summarize their contact information into a markdown table."

### create_a_breeze_person
Adds a new member to the database. Truto intercepts the flat JSON arguments provided by ChatGPT and structures them into the required `fields_json` array and query string parameters before submitting to Breeze.

> "Add John Doe to the database. His email is john.doe@example.com and his phone number is 555-0192."

### list_all_breeze_events
Fetches scheduled events from the calendar. Because Breeze does not page this list naturally, the `limit` argument caps the returned array. This is critical for pulling context before logging attendance.

> "What events are scheduled for this upcoming Sunday morning? Give me the exact event IDs."

### create_a_breeze_attendance
Logs attendance for a specific person at a specific event. Requires the `person_id` and the event `instance_id`. 

> "Log attendance for person ID 10452 at the Sunday Service event instance ID 99281."

### create_a_breeze_contribution
Records financial donations. This tool requires the `person_json` payload so Breeze can match the giver to an existing profile, grouping identical contributions into a unified batch.

> "Log a $500 contribution to the general fund for Sarah Jenkins. Match her using her email address sarah.j@example.com."

### create_a_breeze_tag_assignment
Assigns an existing organizational tag to a person record. Often used in workflows after a person checks into an event for the first time (e.g., tagging them as a 'First Time Guest').

> "Assign the 'Volunteer' tag (ID 4021) to the person with ID 10452."

To view the complete inventory of available Breeze tools, JSON schemas, and parameter requirements, visit the [Breeze integration page](https://truto.one/integrations/detail/breezechms).

## Workflows in Action

Connecting tools together is where the MCP architecture shines. Because ChatGPT understands the schemas returned by Truto, it can chain multiple API calls together to execute complex workflows without human intervention.

### Scenario 1: Sunday Service Check-in and Follow-up

Church administrators often need to process manual sign-in sheets on Monday mornings. By passing a photo or text list to ChatGPT, the LLM can automate the data entry.

> "Here is the list of visitors from yesterday's 10 AM service. Find the event ID for yesterday's 10 AM service. Then, for each name on this list, search the database to see if they exist. If they don't, create a new person record. Finally, log their attendance for the service and assign them the 'Recent Visitor' tag."

**How ChatGPT executes this:**
1. Calls `list_all_breeze_events` to locate the `instance_id` for the 10 AM service.
2. Iterates through the list, calling `list_all_breeze_people` with `filter_json` to search for existing names.
3. For missing names, calls `create_a_breeze_person` to generate a new record, extracting the new `person_id` from the response.
4. Calls `create_a_breeze_attendance` using the `person_id` and `instance_id`.
5. Calls `create_a_breeze_tag_assignment` to attach the 'Recent Visitor' tag ID to the profiles.

### Scenario 2: Processing Third-Party Donation Exports

Many churches use external payment processors that don't natively sync with Breeze. You can feed a CSV export to ChatGPT to reconcile the ledger.

> "I've attached our stripe donation export for last week. Process these donations into Breeze. If you can't find a matching person based on the email address in the CSV, create a basic profile for them first before logging the contribution."

**How ChatGPT executes this:**

```mermaid
sequenceDiagram
    participant User as User (Prompt)
    participant ChatGPT as ChatGPT
    participant Truto as Truto MCP Server
    participant Breeze as Breeze API

    User->>ChatGPT: Upload CSV & Prompt
    ChatGPT->>ChatGPT: Parse CSV rows
    
    loop For each donation
        ChatGPT->>Truto: Call list_all_breeze_people (filter by email)
        Truto->>Breeze: GET /people with filter_json
        Breeze-->>Truto: Return profile array
        Truto-->>ChatGPT: Return JSON-RPC result
        
        alt If profile not found
            ChatGPT->>Truto: Call create_a_breeze_person
            Truto->>Breeze: POST via query string
            Breeze-->>Truto: Return new person_id
            Truto-->>ChatGPT: Return new person_id
        end
        
        ChatGPT->>Truto: Call create_a_breeze_contribution (with person_id)
        Truto->>Breeze: POST /contributions
        Breeze-->>Truto: Success
        Truto-->>ChatGPT: JSON-RPC Success
    end
    
    ChatGPT-->>User: "All 45 donations have been successfully logged in Breeze."
```

## Stop Writing Point-to-Point Integration Code

Writing custom API wrappers for legacy SaaS platforms is a massive drain on engineering resources. Between reverse-engineering query string mutations, normalizing custom field arrays, and managing OAuth token lifecycles, maintaining a custom MCP server for Breeze is a full-time job. 

Truto abstracts this completely. By deriving tool schemas directly from API documentation and executing them through a secure proxy layer, Truto allows your AI agents to interact with Breeze as if it were a modern, beautifully designed REST API. 

> Ready to give your AI agents secure, schema-validated access to Breeze? Let Truto manage the infrastructure so you can focus on building agents.
>
> [Talk to us](https://truto.one/book-a-demo/)