---
title: "Connect Virtuous to ChatGPT: Manage Donors, Gifts, and Communications"
slug: connect-virtuous-to-chatgpt-manage-donors-gifts-and-communications
date: 2026-09-24
author: Nachi Raman
categories: ["AI & Agents"]
excerpt: Learn how to connect Virtuous to ChatGPT using a managed MCP server. This step-by-step guide covers how to bypass Virtuous API complexities and automate donor workflows.
tldr: "Connect Virtuous to ChatGPT securely using Truto's MCP servers. Auto-generate AI tools to manage contacts, queue gift transactions, and log notes without writing custom integration code."
canonical: https://truto.one/blog/connect-virtuous-to-chatgpt-manage-donors-gifts-and-communications/
---

# Connect Virtuous to ChatGPT: Manage Donors, Gifts, and Communications


If you want to connect Virtuous to ChatGPT so your AI agents can look up major donors, log prospect communications, and queue gift transactions, you need a [Model Context Protocol (MCP) server](https://truto.one/blog/what-is-mcp-model-context-protocol-the-2026-guide-for-saas-pms/). 

If your team uses Claude, check out our guide on [connecting Virtuous to Claude](https://truto.one/connect-virtuous-to-claude-sync-pledges-projects-and-grants/) or explore our broader architectural overview on [connecting Virtuous to AI Agents](https://truto.one/connect-virtuous-to-ai-agents-automate-events-tasks-and-volunteers/).

Giving a Large Language Model (LLM) read and write access to a highly specialized nonprofit CRM like Virtuous is a complex engineering task. You either spend weeks [building, hosting, and maintaining a custom MCP server](https://truto.one/blog/the-hands-on-guide-to-building-mcp-servers-for-ai-agents-2026/) to translate LLM JSON arguments into Virtuous's exact relational data models, or you use a managed infrastructure layer.

This guide breaks down exactly how to use Truto to generate a secure, authenticated MCP server for Virtuous, connect it to ChatGPT, and execute complex donor management workflows using natural language.

::cta{buttonText="Talk to us" buttonUrl="/book-a-demo/"}
Stop writing boilerplate API integration code. Let Truto generate secure, managed MCP servers for your AI agents in seconds.
:::

## The Engineering Reality of the Virtuous API

A custom MCP server is essentially a self-hosted API translation and integration layer. While the open MCP standard provides a predictable JSON-RPC interface for LLMs to discover tools, implementing it against Virtuous reveals several highly specific integration hurdles.

If you decide to build a custom MCP server for Virtuous from scratch, you own the entire integration lifecycle. Here are the specific engineering realities you will face:

### The Contact vs. Contact Individual Split
Unlike traditional B2B CRMs where a "Contact" is a person, Virtuous is built for fundraising. A `Contact` is typically a household, a foundation, or a corporation. The actual human beings live in a nested `ContactIndividual` array. 

If an LLM tries to update an address for "John Smith" by patching a `ContactIndividual` record, the API request will fail or corrupt the household data. Addresses belong to the `Contact`. Name prefixes and communication preferences belong to the `ContactIndividual`. Your MCP server must expose these as separate tools and explicitly instruct the LLM on which endpoint to call depending on the entity it is trying to mutate.

### The Transaction/Import Engine Paradigm
Directly POSTing to the `Contact` or `Gift` endpoints in Virtuous is technically possible but strongly discouraged by their architecture. Direct creation bypasses Virtuous's proprietary matching and deduplication engine. 

If ChatGPT creates a gift directly, and that donor already exists with a slightly different spelling, you create a duplicate household. A production-grade MCP server must steer the LLM away from direct CRUD endpoints and force it to use the `virtuous_transactions_create_gift` and `virtuous_transactions_create_contact` endpoints. These endpoints drop data into the Import Tool queue, allowing Virtuous to intelligently match the record.

### Complex Query Filter Groups
Virtuous does not use standard REST query parameters for filtering (e.g., `?status=active&type=major`). Instead, their query endpoints require a complex JSON body consisting of "Filter Groups." These groups contain arrays of conditions with `parameter`, `operator`, and `value` fields.

An LLM will hallucinate these parameters unless your MCP tool schemas explicitly map the exact string values expected by the Virtuous query engine. 

### [Handling Rate Limits](https://truto.one/blog/how-to-handle-third-party-api-rate-limits-when-an-ai-agent-is-scraping-data/)
When an upstream API returns an HTTP 429 (Too Many Requests), Truto does not absorb, retry, or apply backoff logic. Truto passes this 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. When connecting Virtuous to ChatGPT, the LLM client or agent framework is entirely responsible for detecting these 429s and implementing exponential backoff.

## Step 1: Generating a Virtuous MCP Server

To bypass writing custom integration code, you can use Truto to [auto-generate an MCP server dynamically derived from the Virtuous API schemas](https://truto.one/blog/auto-generated-mcp-tools-for-ai-agents-a-2026-architecture-guide/). Truto handles the OAuth lifecycle, token refresh, and JSON-RPC tool generation.

First, authenticate your Virtuous account in the Truto dashboard (creating an "Integrated Account"). Once connected, you can spawn an MCP server scoped specifically to that tenant.

### Method A: Via the Truto UI

1. Navigate to the **Integrated Accounts** page in the Truto dashboard.
2. Select your connected Virtuous account.
3. Click the **MCP Servers** tab.
4. Click **Create MCP Server**.
5. Select your desired configuration (e.g., restrict methods to `read` and `write`, or filter tags to just `contacts` and `gifts`).
6. Click Save and copy the generated MCP server URL (it will look like `https://api.truto.one/mcp/<token>`). Treat this URL as a secure secret.

### Method B: Via the API

For teams building programmatic agent infrastructure, you can generate MCP servers via a simple POST request. You will need your `integrated_account_id`.

```bash
curl -X POST https://api.truto.one/integrated-account/<integrated_account_id>/mcp \
  -H "Authorization: Bearer $TRUTO_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Virtuous Major Donor Assistant",
    "config": {
      "methods": ["read", "write", "custom"],
      "tags": ["contacts", "contact_individuals", "gifts", "tasks"]
    }
  }'
```

The response contains the secure routing URL:

```json
{
  "id": "mcp_01H...",
  "name": "Virtuous Major Donor Assistant",
  "url": "https://api.truto.one/mcp/a1b2c3d4e5f6..."
}
```

## Step 2: Connecting the MCP Server to ChatGPT

Once you have the Truto MCP URL, you simply point ChatGPT to it. Truto handles all the protocol handshakes, schema mapping, and API proxying.

### Method A: Via the ChatGPT UI

If you are using ChatGPT Pro, Plus, Business, Enterprise, or Education accounts, you can add the server directly through the interface:

1. Open ChatGPT and navigate to **Settings -> Apps -> Advanced settings**.
2. Enable **Developer mode**.
3. Under the **MCP servers / Custom connectors** section, click to add a new server.
4. Enter a name (e.g., "Virtuous CRM").
5. Paste the Truto MCP URL into the **Server URL** field.
6. Click **Add**.

ChatGPT will immediately connect, perform the MCP handshake, and discover the available Virtuous tools.

### Method B: Via Manual SSE Configuration File

If you are running a custom headless agent, cursor, or utilizing the official `@modelcontextprotocol/server-sse` transport, you can connect via a JSON configuration file:

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

## Hero Tools for Virtuous

Truto automatically generates tools for every documented Virtuous API endpoint. Do not expose all of them to your LLM at once—use method and tag filtering to provide only the tools necessary for the agent's persona.

Here are 7 high-leverage hero tools for automating nonprofit CRM workflows.

### Search Virtuous Contacts

**Tool:** `virtuous_contacts_search`

Searches the top-level Contact (Household/Organization) records by keyword. This is the required first step before logging notes or finding specific individuals.

> "Search Virtuous for the 'Henderson Household' in Austin and return their primary contact ID."

### List Contact Individuals

**Tool:** `list_all_virtuous_contact_individuals`

Retrieves the specific people attached to a Household or Organization. Use this when you need a specific person's email address, phone number, or internal individual ID.

> "Fetch the contact individuals for Household ID 8842 and list their names, email addresses, and primary status."

### Queue a Contact Transaction

**Tool:** `create_a_virtuous_contact_transaction`

Queues a new contact for creation via the Virtuous Import Tool. This avoids duplicates by allowing the native Virtuous matching engine to evaluate the record before it becomes a permanent CRM entity.

> "Queue a new contact transaction for a prospective donor named Sarah Jenkins at s.jenkins@example.com. Ensure it is marked for review in the import queue."

### Queue a Gift Transaction

**Tool:** `create_a_virtuous_gift_transactions_v_2`

Places a batch of gift transactions into a holding state. At midnight, these are bundled into imports and processed by the gift matching algorithms. This is the safest way for an LLM to process offline donations.

> "Queue a gift transaction of $5,000 for Contact ID 9921. Mark the gift date as today, and assign it to the 'Annual Fund' project code."

### Create a Contact Note

**Tool:** `create_a_virtuous_contact_note`

Logs an interaction, email, or meeting summary directly onto a Contact record. 

> "Log a note on Contact ID 3321. Set the type to 'Meeting', and summarize the following call transcript: The donor is highly interested in the clean water initiative and requested a proposal by next Tuesday."

### Create a Task (Reminder)

**Tool:** `create_a_virtuous_task`

Creates a follow-up task (called a Reminder in the Virtuous schema) assigned to an owner.

> "Create a task for Contact ID 3321 due next Monday. The task message should be 'Send clean water initiative proposal to major donor.'"

### List Campaigns

**Tool:** `list_all_virtuous_campaigns`

Queries active campaigns. Essential for an LLM that needs to categorize a gift or look up the `campaignId` before generating a communication.

> "List all active Virtuous campaigns and return their names, IDs, and financial goals. Filter out archived campaigns."

*For the complete inventory of available tools, query schemas, and body schemas, visit the [Virtuous integration page](https://truto.one/integrations/detail/virtuous).* 

## Workflows in Action

LLMs are most effective when orchestrating multi-step workflows. Here is how ChatGPT utilizes Truto MCP tools to execute domain-specific Virtuous processes.

### Persona 1: Major Gift Officer Logging a Meeting

Major gift officers often record voice memos or write rough notes after a donor lunch. ChatGPT can parse these rough notes, find the correct record, log the meeting, and set a follow-up task.

> "I just had lunch with Robert Chen. He loved the update on the downtown shelter project. Log a note summarizing this, and set a task for me to send him the Q3 impact report next Thursday."

```mermaid
sequenceDiagram
  participant User
  participant GPT as ChatGPT
  participant Truto as Truto MCP Server
  participant Virtuous as Virtuous API

  User->>GPT: "I just had lunch with Robert Chen..."
  GPT->>Truto: Call virtuous_contacts_search (Robert Chen)
  Truto->>Virtuous: GET /api/Contact/Search
  Virtuous-->>Truto: Contact ID 4122
  Truto-->>GPT: Return Contact details
  
  GPT->>Truto: Call create_a_virtuous_contact_note<br>(ContactId: 4122, Type: Meeting)
  Truto->>Virtuous: POST /api/ContactNote
  Virtuous-->>Truto: 200 OK (Note Created)
  
  GPT->>Truto: Call create_a_virtuous_task<br>(ContactId: 4122, targetDate: Next Thursday)
  Truto->>Virtuous: POST /api/Task
  Virtuous-->>Truto: 200 OK (Task Created)
  Truto-->>GPT: Task ID
  GPT->>User: "Note logged and follow-up task created for Robert Chen."
```

### Persona 2: Gift Processor Handling Offline Checks

A gift processor uploads a CSV or text block of offline donations. The LLM must queue these securely into the matching engine rather than creating raw data.

> "Here are three checks we received in the mail today: $100 from Jane Doe, $500 from the Smith Family Trust, and $50 from an unknown donor. Queue these as gift transactions for the Fall Drive."

```mermaid
sequenceDiagram
  participant User
  participant GPT as ChatGPT
  participant Truto as Truto MCP Server
  participant Virtuous as Virtuous API

  User->>GPT: "Here are three checks..."
  
  GPT->>Truto: Call list_all_virtuous_campaigns<br>(Search: Fall Drive)
  Truto->>Virtuous: POST /api/Campaign/Query
  Virtuous-->>Truto: Campaign ID 89
  Truto-->>GPT: Return Campaign Info
  
  GPT->>Truto: Call create_a_virtuous_gift_transactions_v_2<br>(Batch of 3 gifts)
  Truto->>Virtuous: POST /api/v2/GiftTransactions/Batch
  Virtuous-->>Truto: 200 OK (Queued for matching)
  Truto-->>GPT: Success Confirmation
  GPT->>User: "Gifts successfully queued in the Virtuous Import Tool."
```

## Security and Access Control

When bridging an LLM to a production CRM, least-privilege access is critical. Truto MCP servers enforce security through configuration at the routing layer, ensuring ChatGPT only accesses what it strictly needs.

*   **Method Filtering:** Restrict an MCP server to only allow `read` operations (`get`, `list`). If ChatGPT hallucinates a `delete` or `update` request, the Truto router rejects the JSON-RPC call before it ever touches Virtuous.
*   **Tag Filtering:** Limit the LLM's scope by filtering exposed tools via tags. For example, pass `tags: ["gifts", "campaigns"]` to expose financial reporting tools while completely hiding `contacts` and `tasks`.
*   **API Token Authentication:** Set `require_api_token_auth: true` on the MCP server. This requires the client to pass a valid API Bearer token in addition to the server URL, preventing unauthorized access if the URL is leaked.
*   **Automatic Expiration:** Use the `expires_at` field to create ephemeral MCP servers. This is perfect for CI/CD pipelines or temporary agent sessions that should automatically self-destruct after a few hours.

## Stop Writing API Integration Boilerplate

Connecting ChatGPT to Virtuous manually means spending weeks studying the CRM+ data model, handling complex filter group queries, and maintaining custom JSON-RPC transport code. 

With Truto, you bypass the boilerplate entirely. By connecting an integrated account and generating an MCP URL, you give ChatGPT instant, documentation-driven access to the exact Virtuous capabilities it needs to automate complex donor workflows.

::cta{buttonText="Talk to us" buttonUrl="/book-a-demo/"}
Stop writing boilerplate API integration code. Let Truto generate secure, managed MCP servers for your AI agents in seconds.
:::