---
title: "Connect Raiser's Edge NXT to ChatGPT: Manage Donors, Gifts & Actions"
slug: connect-raiser-s-edge-nxt-to-chatgpt-manage-donors-gifts-actions
date: 2026-10-31
author: Nidhi KN
categories: ["AI & Agents"]
excerpt: "Learn how to build and configure a secure Raiser's Edge NXT MCP server to give ChatGPT read and write access to constituents, gifts, and donor actions."
tldr: "A comprehensive engineering guide to connecting Raiser's Edge NXT to ChatGPT using Truto's managed MCP server. Covers dynamic tool generation, API complexities, and secure token lifecycle management."
canonical: https://truto.one/blog/connect-raiser-s-edge-nxt-to-chatgpt-manage-donors-gifts-actions/
---

# Connect Raiser's Edge NXT to ChatGPT: Manage Donors, Gifts & Actions


If you need to connect Raiser's Edge NXT to ChatGPT to automate donor intelligence, process major gifts, or manage prospect actions, you need a [Model Context Protocol (MCP) server](https://truto.one/what-is-mcp-model-context-protocol-the-2026-guide-for-saas-pms/). This server acts as the translation layer between ChatGPT's JSON-RPC tool calls and the underlying Blackbaud SKY API. You can either [build and maintain this infrastructure yourself](https://truto.one/auto-generated-mcp-tools-for-ai-agents-a-2026-architecture-guide/), or use a managed integration platform like Truto to dynamically generate a [secure, authenticated MCP server URL](https://truto.one/zero-data-retention-mcp-servers-building-soc-2-gdpr-compliant-ai-agents/).

If your team uses Claude, check out our guide on [connecting Raiser's Edge NXT to Claude](https://truto.one/connect-raiser-s-edge-nxt-to-claude-sync-records-appeals-funds/) or explore our broader architectural overview on [connecting Raiser's Edge NXT to AI Agents](https://truto.one/connect-raiser-s-edge-nxt-to-ai-agents-automate-giving-workflows/).

Giving a Large Language Model (LLM) read and write access to a complex fundraising CRM like Raiser's Edge NXT is a massive engineering challenge. You have to handle deeply nested relational data payloads, map dynamic custom fields to MCP tool definitions, and deal with shifting API versions. Every time Blackbaud deprecates an endpoint or introduces a new data model, your custom server code must be updated, redeployed, and tested. 

This guide breaks down exactly how to use Truto to generate a secure, managed MCP server for Raiser's Edge NXT, [connect it natively to ChatGPT](https://truto.one/bring-100-custom-connectors-to-chatgpt-with-superai-by-truto/), and execute complex donor 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 Raiser's Edge NXT API

A custom MCP server is essentially a self-hosted API proxy. While the open MCP standard provides a predictable way for models to discover tools, implementing it against Blackbaud's SKY API is exceptionally painful. 

If you decide to build a custom MCP server for Raiser's Edge NXT, you own the entire integration lifecycle. Here are the specific engineering challenges that break standard REST assumptions when working with this platform:

### The V2 Gift Endpoints and Payload Complexity
Raiser's Edge NXT is aggressively migrating core financial objects to V2 "PREVIEW" endpoints (e.g., `gift_v_2_gift`, `gift_v_2_planned_gifts`). Unlike simple CRUD APIs, creating a gift in V2 requires handling an intricate web of related objects—installments, benefits, planned gift assets, and matching gifts. If an LLM attempts to construct a gift payload without a strictly enforced JSON schema, it will hallucinate the structure. Your custom MCP server must implement an exhaustive schema translation layer to force the LLM to provide exact enumerations for `gift_type` (One-time, pledge, stock, gift-in-kind) and manage the array structures for split gifts.

### Complex Cursor Pagination Mechanisms
Most LLMs are notoriously bad at handling pagination. Blackbaud's API makes this even harder by utilizing multiple pagination strategies depending on the endpoint. Action and constituent lists often require tracking a `next_link` URL, which internally carries a `continuation_token` (or a `sort_token` if `last_modified` sorting is applied). If your MCP server simply passes the raw API response to ChatGPT, the context window will blow up on large databases, and the LLM will fail to track the `next_link` properly. A production-grade MCP server must inject specialized `next_cursor` instructions into the tool schema, explicitly forcing the LLM to return cursor values unmodified during iterative tool calls.

### Strict Rate Limiting Without Absorption
Blackbaud strictly enforces rate limits on the SKY API to protect tenant performance. **Note on rate limits:** Truto does not retry, throttle, or apply backoff on rate limit errors. When the Raiser's Edge NXT API returns an HTTP 429, Truto passes that error directly to the caller (the MCP client). Truto normalizes the upstream rate limit information into standardized headers (`ratelimit-limit`, `ratelimit-remaining`, `ratelimit-reset`) per the IETF specification. The caller—in this case, your custom AI agent orchestrator or ChatGPT client—is fully responsible for handling the 429 error and implementing its own retry or backoff logic. 

## How to Generate a Raiser's Edge NXT MCP Server

Instead of building a schema parser, auth layer, and JSON-RPC router from scratch, you can use Truto to dynamically generate a Raiser's Edge NXT MCP server. 

Truto's MCP servers are derived directly from integration resource configurations and documentation records. Every server is scoped to a single integrated account (a connected Raiser's Edge NXT tenant) and authenticated via a secure, hashed token in the URL. 

You can generate the MCP server in two ways: via the Truto UI or programmatically via the API.

### Method 1: Via the Truto UI

For internal teams and quick prototyping, the dashboard is the fastest path.

1. Log into your Truto account and navigate to **Integrated Accounts**.
2. Select your connected Raiser's Edge NXT instance.
3. Click the **MCP Servers** tab.
4. Click **Create MCP Server**.
5. Select your desired configuration. You can filter tools by method (e.g., only allow `read` operations) or by tags (e.g., only expose `gifts` and `constituents`).
6. Click **Generate** and copy the resulting MCP server URL (e.g., `https://api.truto.one/mcp/a1b2c3d4...`). Treat this URL like a secret—it contains the routing logic and authentication required to execute tools against the CRM.

### Method 2: Via the Truto API

If you are building an AI product and need to generate MCP servers dynamically for your end-users, you can use the Truto API.

Make a POST request to `/integrated-account/:id/mcp` using your Truto API token. You can pass a configuration object to strictly constrain what the LLM is allowed to do.

```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": "ChatGPT Donor Agent",
    "config": {
      "methods": ["read", "write"],
      "tags": ["constituents", "gifts", "actions"]
    }
  }'
```

The API responds with the token record and the ready-to-use URL:

```json
{
  "id": "abc-123",
  "name": "ChatGPT Donor Agent",
  "config": { 
    "methods": ["read", "write"], 
    "tags": ["constituents", "gifts", "actions"] 
  },
  "expires_at": null,
  "url": "https://api.truto.one/mcp/a1b2c3d4e5f6..."
}
```

## How to Connect the MCP Server to ChatGPT

Once you have your Truto MCP URL, connecting it to an LLM client requires zero additional coding. The URL dynamically serves the `initialize`, `tools/list`, and `tools/call` JSON-RPC methods required by the open standard.

### Method A: Via the ChatGPT UI

If you are using ChatGPT Pro, Plus, Enterprise, or Education, you can attach the server directly in the browser or desktop app.

1. In ChatGPT, click your profile picture and go to **Settings > Apps > Advanced settings**.
2. Toggle **Developer mode** on (custom MCP connectors are currently behind this flag).
3. Under **MCP servers / Custom connectors**, click **Add new server**.
4. **Name:** Give it a recognizable name (e.g., "Raiser's Edge NXT").
5. **Server URL:** Paste the `https://api.truto.one/mcp/...` URL generated in the previous step.
6. Click **Save**. ChatGPT will immediately ping the endpoint, execute the handshake, and list the available Blackbaud tools.

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

If you are running a custom agent framework, using Cursor, or leveraging Claude Desktop alongside standard JSON configuration files, you can connect via Server-Sent Events (SSE). 

Truto's MCP servers support the official `@modelcontextprotocol/server-sse` package to bridge standard config files to remote HTTP endpoints.

Add the following JSON to your agent configuration file (e.g., `claude_desktop_config.json` or your framework's equivalent connector registry):

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

When your agent boots up, it executes the `npx` command, which translates local JSON-RPC requests into HTTP POSTs against Truto's proxy layer.

## Hero Tools for Raiser's Edge NXT

Truto automatically generates highly descriptive snake_case tools from the SKY API documentation. Instead of a single generic "API call" tool, the LLM receives discrete operations with exact JSON schemas dictating required fields, data types, and query parameters. 

Here are 6 high-leverage hero tools your AI agent can use to orchestrate donor workflows.

### 1. `raisers_edge_nxt_constituents_search`

This is the critical entry point for almost any workflow. It allows the LLM to search for individuals, organizations, and related contacts using first name, last name, email address, phone number, or lookup ID.

**Usage note:** Because names can be ambiguous, always prompt the LLM to verify the `constituent_id` and match it against secondary data (like an email address) before executing write operations.

> "Search for a constituent named 'Robert Smith' who lives in Chicago. If you find multiple matches, list their emails so I can confirm the right one."

### 2. `list_all_constituent_giving_summary_lifetime_giving`

This tool retrieves the aggregated lifetime giving metrics for a specific constituent. It returns a single object containing total gift amounts, years of consecutive giving, and major donor status flags.

**Usage note:** This tool requires a `constituent_id`. The LLM should typically call `constituents_search` first, extract the ID, and then call this tool.

> "Get the lifetime giving summary for constituent ID 14592. What is their total giving amount to date?"

### 3. `list_all_raisers_edge_nxt_actions`

Returns a paginated list of actions (calls, meetings, tasks, mailings) across the database or for a specific constituent. It supports filtering and overriding default sorting using the `last_modified` parameter.

**Usage note:** Instruct the LLM to use the `next_cursor` parameter exactly as it is returned in the API response to page through large histories without hallucinating offsets.

> "List the 10 most recent actions logged for constituent ID 14592. Sort them by the date they were last modified."

### 4. `create_a_raisers_edge_nxt_action`

Creates a new constituent action. The schema explicitly enforces required fields like `category`, `constituent_id`, and `date`. 

**Usage note:** Ensure the LLM provides a valid ISO-8601 string for the `date` parameter. If custom fields are required by your organization's business logic, you will need to utilize the associated custom field tools.

> "Log a new action for constituent 14592. Set the category to 'Phone Call', the date to today, and add a summary stating 'Left a voicemail regarding the annual fund'."

### 5. `create_a_raisers_edge_nxt_gift`

Creates a standard gift record. The LLM must supply the `amount`, `constituent_id`, `gift_splits` array, `type`, and `payments` information.

**Usage note:** This is a highly complex schema. For V2 gift endpoints (PREVIEW), Truto exposes `create_a_raisers_edge_nxt_gift_v_2_gift`. Always specify which tool the LLM should use in your system prompt based on your organization's API configuration.

> "Create a new one-time gift of $500 for constituent ID 8831. Assign the full amount to the 'General Operating' fund split."

### 6. `list_all_raisers_edge_nxt_constituent_notes`

Retrieves a list of textual notes attached to a constituent profile (excluding RE NXT Summary notes). This is vital for AI agents summarizing relationships before donor meetings.

**Usage note:** Combine this with the giving summary tool to give the LLM full context on a prospect's history.

> "Fetch all the notes for constituent ID 8831. Summarize their relationship with the organization over the last two years based on these notes."

For the complete inventory of available tools, query parameters, and JSON schemas, view the [Truto Raiser's Edge NXT integration page](https://truto.one/integrations/detail/blackbaudrenxt).

## Workflows in Action

Giving an AI agent discrete tools is powerful, but true automation happens when the LLM chains them together. Because Truto's MCP router processes the inputs based on strict schemas and handles the underlying authentication, ChatGPT can execute multi-step workflows flawlessly.

Here are two real-world scenarios.

### Scenario 1: The Major Gift Officer Briefing

**User Prompt:**
> "I have a lunch meeting with Eleanor Vance tomorrow. Search our database to find her record, pull her lifetime giving summary, and summarize the last 5 notes and actions logged on her account so I know exactly where our relationship stands."

**Tool Execution Sequence:**
1. `raisers_edge_nxt_constituents_search` — The agent searches for "Eleanor Vance" and identifies her `constituent_id` as `90210`.
2. `list_all_constituent_giving_summary_lifetime_giving` — The agent queries ID `90210` to discover she has given $125,000 over 8 consecutive years.
3. `list_all_raisers_edge_nxt_constituent_notes` — The agent pulls her profile notes, learning she is passionate about the new scholarship initiative.
4. `list_all_raisers_edge_nxt_actions` — The agent retrieves recent actions, noting a phone call from the Director of Development last month.

**Result:** ChatGPT outputs a highly structured, accurate briefing document combining financial metrics with qualitative relationship history, saving the Gift Officer 30 minutes of manual CRM digging.

```mermaid
sequenceDiagram
    participant User as Gift Officer
    participant GPT as ChatGPT (LLM)
    participant MCP as Truto MCP Server
    participant RENXT as Raiser's Edge NXT
    User->>GPT: "Brief me on Eleanor Vance"
    GPT->>MCP: Call constituents_search
    MCP->>RENXT: GET /constituent/v1/constituents/search
    RENXT-->>MCP: Constituent ID 90210
    MCP-->>GPT: ID 90210
    GPT->>MCP: Call lifetime_giving(90210)
    MCP->>RENXT: GET /constituent/v1/constituents/90210/givingsummary/lifetime
    RENXT-->>MCP: Giving Data
    MCP-->>GPT: $125k Total
    GPT->>MCP: Call list_all_actions(90210)
    MCP->>RENXT: GET /constituent/v1/actions?constituent_id=90210
    RENXT-->>MCP: Action List
    MCP-->>GPT: Recent Calls/Tasks
    GPT-->>User: Complete Meeting Briefing Generated
```

### Scenario 2: Processing a Verbal Pledge

**User Prompt:**
> "I just got off the phone with Michael Chang (email: m.chang@example.com). He verbally agreed to a $10,000 pledge. Log a phone call action summarizing this conversation, and then create the new pledge gift record for him."

**Tool Execution Sequence:**
1. `raisers_edge_nxt_constituents_search` — The agent searches by email to ensure an exact match and retrieves the `constituent_id`.
2. `create_a_raisers_edge_nxt_action` — The agent posts a new action categorized as a 'Phone Call' with the user's summary.
3. `create_a_raisers_edge_nxt_gift` — The agent constructs the complex JSON payload, setting the `type` to `Pledge` and the `amount` to $10,000.

**Result:** ChatGPT orchestrates a multi-object write operation across the CRM, ensuring the interaction is logged and the financial pipeline is updated simultaneously.

## Security and Access Control

Exposing an enterprise CRM to an LLM introduces obvious risks. Truto mitigates this by providing granular control over the MCP server at creation time:

*   **Method Filtering:** Constrain the server using `config.methods`. Pass `["read"]` to block all `create`, `update`, and `delete` operations, making the integration strictly read-only for reporting and intelligence gathering.
*   **Tag Filtering:** Restrict tool generation to specific API domains using `config.tags`. For example, pass `["constituents", "notes"]` to prevent the LLM from ever seeing or interacting with `gifts` or `financials`.
*   **Enforced TTL (Time-To-Live):** Use the `expires_at` field to create temporary access. If you are granting a contractor AI access for an audit, set the server to expire on a specific date. Cloudflare KV and Durable Objects automatically revoke the token when the time expires.
*   **Double Authentication Layer:** By default, possession of the cryptographic token URL grants access. For high-security deployments, enable `require_api_token_auth: true`. This forces the connecting client to also supply a valid Truto API bearer token to execute calls.

## Connect AI Agents to Raiser's Edge NXT Today

Building a custom integration layer between ChatGPT and Blackbaud's SKY API means writing thousands of lines of boilerplate schema validation, cursor handlers, and OAuth state logic. 

Truto eliminates this overhead. By dynamically generating documentation-driven MCP tools and routing them securely to underlying integrated accounts, you can give your AI agents safe, structured access to Raiser's Edge NXT in minutes.

> Ready to automate your donor workflows? Get started with Truto and deploy secure MCP servers for Raiser's Edge NXT today.
>
> [Talk to us](https://truto.one/book-a-demo/)