Connect Raiser's Edge NXT to Claude: Sync Records, Appeals & Funds

If your team needs to connect Raiser's Edge NXT to Claude to automate donor prospecting, gift processing, or appeal analytics, you need a Model Context Protocol (MCP) server. This server acts as the translation layer between Claude's JSON-RPC tool calls and Blackbaud's SKY REST 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 ChatGPT, check out our guide on /connect-raiser-s-edge-nxt-to-chatgpt-manage-donors-gifts-actions/ or explore our broader architectural overview on /connect-raiser-s-edge-nxt-to-ai-agents-automate-giving-workflows/.

Giving a Large Language Model (LLM) read and write access to a complex nonprofit CRM like Raiser's Edge NXT is a serious engineering challenge. You must handle OAuth 2.0 token lifecycles, map massive JSON schemas to MCP tool definitions, and deal with Blackbaud's strict API quotas. Every time Blackbaud updates an endpoint, deprecates a field, or modifies pagination logic, you have to update your server code, redeploy, and test the integration.

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 Claude Desktop or custom agents, and execute complex fundraising workflows using natural language.

The Engineering Reality of the Raiser's Edge NXT API

A custom MCP server is a self-hosted integration layer. While the open MCP standard provides a predictable way for models to discover tools, the reality of implementing it against Blackbaud's SKY API is painful. Raiser's Edge NXT is built to handle incredibly nuanced nonprofit accounting, relationship mapping, and constituent tracking. Its API directly reflects that domain complexity.

If you decide to build a custom MCP server for Raiser's Edge NXT, here are the specific integration challenges you will face:

Complex Pagination and Cursor Management Raiser's Edge NXT uses a highly variable pagination scheme depending on the endpoint and the query parameters provided. For standard lists, it might use basic limit/offset mechanics. But if you query a list like actions or constituents and apply a last_modified filter, the API suddenly switches to using a sort_token instead of standard offsets. Other newer list endpoints rely entirely on a continuation_token carried inside a next_link URL. Building an MCP server means writing custom middleware that abstracts these three different pagination paradigms so the LLM only ever sees a standard next_cursor parameter.

Unconditional Update Constraints (If-Match Headers) When updating specific records like Gifts, Blackbaud requires strict concurrency control headers. Specifically, the API often mandates an If-Match header to ensure you are updating the correct version of a record. If your MCP server does not inject If-Match: * (an unconditional update) into the proxy request, the LLM's edit attempts will fail with HTTP 412 Precondition Failed errors. The LLM has no concept of HTTP headers, so your server must handle this mapping natively based on the specific REST method being called.

Strict Rate Limits and 429 Handling Blackbaud enforces strict rate limits to protect its multi-tenant environment. When an AI agent executes a bulk operation (like fetching all gifts for an appeal and cross-referencing them against constituent records), it will hit these limits quickly. Note on rate limits: Truto does not retry, throttle, or apply backoff on rate limit errors. When the upstream Raiser's Edge NXT 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. The AI agent or calling framework is strictly responsible for reading these headers and implementing its own retry and backoff logic.

Creating the MCP Server for Raiser's Edge NXT

Instead of writing custom JSON-RPC routers and OAuth management code, you can use Truto to generate a secure MCP server URL. Truto dynamically builds tool definitions directly from the Raiser's Edge NXT API schemas, ensuring the LLM always has the correct parameters for complex objects like gift_splits and constituent_codes.

You can create this server in two ways: via the Truto UI for rapid testing, or programmatically via the Truto REST API for dynamic user provisioning.

Method 1: Via the Truto UI

If you are setting up an internal tool or testing workflows locally with Claude Desktop, the UI is the fastest path.

1. Log in to your Truto dashboard and navigate to the Integrated Accounts page for your Raiser's Edge NXT connection.
2. Click the MCP Servers tab.
3. Click Create MCP Server.
4. Select your desired configuration. You can restrict the server to only read methods to prevent accidental data modification, or filter tools by tags.
5. Copy the generated MCP server URL (e.g., https://api.truto.one/mcp/a1b2c3d4e5f6...).

Method 2: Via the Truto API

If you are building an AI product and need to generate MCP servers on the fly for your users, use the Truto API. This endpoint validates the configuration, generates a cryptographically secure token, stores it in a distributed key-value store, and returns the ready-to-use URL.

POST /integrated-account/:id/mcp

{
  "name": "Major Gifts Agent Server",
  "config": {
    "methods": ["read", "write"],
    "require_api_token_auth": false
  },
  "expires_at": "2026-12-31T23:59:59Z"
}

The response contains the secure URL that your LLM framework will use to connect:

{
  "id": "mcp-7f8a9b2c",
  "name": "Major Gifts Agent Server",
  "config": {
    "methods": ["read", "write"]
  },
  "expires_at": "2026-12-31T23:59:59Z",
  "url": "https://api.truto.one/mcp/a1b2c3d4e5f6..."
}

Connecting the MCP Server to Claude

Once you have the MCP server URL, connecting it to Claude requires zero additional coding. The URL encodes the integration context, the tenant identity, and the tool definitions.

Method A: Via the Claude UI

If you are using Claude's web interface (or ChatGPT):

1. In Claude, navigate to Settings - Integrations - Add MCP Server. (If using ChatGPT, go to Settings - Connectors - Add custom connector or Settings - Apps - Advanced settings - Developer mode).
2. Name the integration (e.g., "Raiser's Edge NXT").
3. Paste the Truto MCP URL into the Server URL field.
4. Click Add. Claude will instantly execute the initialize handshake and load all available Blackbaud tools.

Method B: Via Manual Config (Claude Desktop)

If you are running Claude Desktop locally, you configure the server via the claude_desktop_config.json file. Because Truto MCP servers operate over standard HTTP SSE (Server-Sent Events), you use the official MCP SSE transport module.

Add the following configuration to your file:

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

Restart Claude Desktop. The agent will now have a "Raiser's Edge NXT" toolset available with full read/write access to the CRM.

Hero Tools for Raiser's Edge NXT

Truto exposes dozens of Raiser's Edge NXT resources as granular tools. Here are the highest-leverage operations your AI agent will use to automate fundraising and development workflows.

raisers_edge_nxt_constituents_search

Performs a constituent search based on provided text. This is critical for agents trying to find a donor without knowing their exact internal ID. It searches first names, last names, aliases, emails, and phone numbers.

"Claude, search our database for a donor named 'Jane Sterling' who lives in Chicago. I need to know if she already exists in Raiser's Edge before I create a new record."

get_single_raisers_edge_nxt_constituent_by_id

Returns detailed information about a specific constituent, including their type (individual vs organization), lookup ID, and core demographics. This is usually chained after a search operation to get the canonical profile.

"Pull the complete constituent profile for ID 4892. I need to check their formal addressee format and marital status for an upcoming event invitation."

list_all_raisers_edge_nxt_actions

Returns a paginated list of actions (tasks, meetings, calls) across constituents. Agents use this to generate prep briefs before major donor meetings by analyzing recent touchpoints.

"Fetch the last 5 actions logged for constituent 4892. Summarize what the development team discussed with them over the last six months, and note any pending tasks."

create_a_raisers_edge_nxt_gift

Creates a new gift record. This requires complex nested payloads, including amount, constituent_id, type, and gift_splits. The MCP schema explicitly guides the LLM on how to structure these required arrays to satisfy Blackbaud's validation rules.

"Log a new $5,000 one-time gift for constituent 4892. Split the gift equally between the 'Annual Fund' and the 'Building Campaign'. Add a note that this was processed via wire transfer."

list_all_raisers_edge_nxt_appeals

Returns a paginated list of appeals (marketing campaigns, mailers, phone-a-thons). Agents use this to map appeal IDs for reporting or to link new gifts to the correct marketing effort.

"List all active appeals created in 2026. I need to find the ID for the 'Spring Gala 2026' appeal so we can tie upcoming ticket purchases to it."

list_all_raisers_edge_nxt_funds

Retrieves the fund records that define where money is allocated. Since gifts must be split into specific funds, the agent relies on this tool to discover valid fund IDs before attempting to log a donation.

"Pull the list of active funds. I need the exact fund ID for the 'Endowed Scholarship Fund' to process this stock transfer."

To view the complete inventory of available endpoints, schemas, and parameters, visit the Truto Raiser's Edge NXT integration page.

Workflows in Action

With the MCP server connected and tools exposed, Claude can autonomously execute complex, multi-step fundraising workflows.

Use Case 1: Automated Major Gift Processing

Major Gift Officers frequently receive checks or wire notifications with vague instructions. Instead of manually searching the CRM, mapping funds, and filling out complex gift entry forms, they can ask Claude to handle the entire operation.

"We just received a $25,000 wire transfer from Robert California. Please find his record, check what fund he normally gives to, log the gift, and create a follow-up action for me to call him next Tuesday to say thank you."

sequenceDiagram
    participant User as User
    participant Claude as Claude Desktop
    participant Truto as Truto MCP
    participant RE as Raiser's Edge API

    User->>Claude: "Log $25k wire from Robert California..."
    Claude->>Truto: Call raisers_edge_nxt_constituents_search(search_text="Robert California")
    Truto->>RE: GET /constituent/v1/constituents/search
    RE-->>Truto: Returns Constituent ID: 9941
    Truto-->>Claude: JSON result
    
    Claude->>Truto: Call list_all_raisers_edge_nxt_funds()
    Truto->>RE: GET /gift/v1/funds
    RE-->>Truto: Returns Fund List
    Truto-->>Claude: JSON result (Finds General Operating Fund)
    
    Claude->>Truto: Call create_a_raisers_edge_nxt_gift(amount=25000, constituent_id=9941...)
    Truto->>RE: POST /gift/v1/gifts
    RE-->>Truto: Returns New Gift ID
    Truto-->>Claude: JSON result
    
    Claude->>Truto: Call create_a_raisers_edge_nxt_action(constituent_id=9941, category="Phone Call")
    Truto->>RE: POST /constituent/v1/actions
    RE-->>Truto: Returns New Action ID
    Truto-->>Claude: JSON result
    
    Claude->>User: "I found Robert California (ID 9941), logged the $25,000 gift to the General Fund, and scheduled a follow-up call action for next Tuesday."

1. Search: Claude calls raisers_edge_nxt_constituents_search to find the constituent ID for "Robert California".
2. Fund Mapping: Claude calls list_all_raisers_edge_nxt_funds to verify the correct internal ID for the fund he usually supports.
3. Gift Creation: Claude calls create_a_raisers_edge_nxt_gift, formatting the complex gift_splits array correctly based on the MCP schema.
4. Task Assignment: Claude calls create_a_raisers_edge_nxt_action to log a pending phone call task for the assigned fundraiser.

Use Case 2: Appeal Performance Briefing

Development Directors need real-time data on campaign performance without waiting for database administrators to build custom dashboards. Claude can aggregate and analyze this data dynamically.

"Analyze our 'End of Year Mailer 2026' appeal. Find the appeal, list all the gifts tied to it, calculate the total amount raised, and identify our top three donors for this campaign."

flowchart TD
    A["User Prompt:<br>Analyze 'End of Year Mailer 2026'"] --> B["Call list_all_raisers_edge_nxt_appeals<br>Filter for matching appeal name"]
    B --> C["Call list_all_raisers_edge_nxt_gifts<br>Filter by appeal_id"]
    C --> D["Extract amounts and constituent IDs from gifts array"]
    D --> E["Loop: Call get_single_raisers_edge_nxt_constituent_by_id<br>For the top 3 largest gifts"]
    E --> F["Aggregate data and return written analysis to user"]

1. Discover Appeal: Claude uses list_all_raisers_edge_nxt_appeals to find the exact system ID for the requested campaign.
2. Fetch Revenue: Claude calls list_all_raisers_edge_nxt_gifts, passing the discovered appeal ID to filter the results.
3. Identify Top Donors: Claude parses the returned JSON, sorts the gifts by amount, and extracts the constituent IDs of the top three.
4. Enrich Data: Claude calls get_single_raisers_edge_nxt_constituent_by_id for those three IDs to get their full names.
5. Report: Claude returns a natural language summary of the total revenue, average gift size, and the top three contributors.

Security and Access Control

Giving AI agents direct access to donor databases and financial records requires rigid security controls. Truto enforces boundaries at the MCP server level before requests ever reach Blackbaud:

• Method Filtering: Configure the server to only allow specific operations. Use config.methods: ["read"] to strictly prohibit the AI from creating or modifying records, regardless of its prompt.
• Tag Filtering: Scope the server to specific resource tags. Using config.tags: ["gifts"] ensures the server only exposes gift-related tools, completely hiding constituent notes or custom fields from the agent.
• API Token Authentication: For high-security internal tools, set require_api_token_auth: true. This forces the MCP client to pass a valid Truto API token in the Authorization header, meaning possession of the server URL alone is not enough to access the data.
• Expiration (TTL): Use the expires_at field to create temporary, short-lived MCP servers (e.g., for a specific automated reporting run), ensuring access is automatically revoked when the time expires without requiring manual cleanup.

Architecting for Agentic Automation

Connecting Raiser's Edge NXT to Claude via a managed MCP server removes the friction of API maintenance, pagination handling, and token management. Instead of writing custom integration scripts for every new fundraising report or data entry workflow, your engineers can treat Blackbaud as a semantic database that AI agents query naturally.

By leveraging Truto's dynamic tool generation, you ensure that as Blackbaud evolves its API, your agents' capabilities evolve with it - zero code deployment required. This allows development teams to focus on building high-value, domain-specific AI workflows instead of constantly wrestling with CRM infrastructure.