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. 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, 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 Raiser's Edge NXT to Claude or explore our broader architectural overview on connecting Raiser's Edge NXT to AI Agents.

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, and execute complex donor workflows using natural language.

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.

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:

{
  "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):

{
  "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.

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.

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.