Connect Raiser's Edge NXT to AI Agents: Automate Giving & Workflows

You want to connect Raiser's Edge NXT to an AI agent so your system can autonomously research major donors, record giving history, log engagement actions, and orchestrate marketing campaigns. Here is exactly how to do it using Truto's /tools endpoint and SDK, bypassing the need to build and maintain a custom Blackbaud SKY API integration from scratch.

Giving a Large Language Model (LLM) read and write access to your nonprofit CRM is an engineering challenge. You either spend weeks building, hosting, and maintaining a custom connector dealing with legacy data models, or you use a managed infrastructure layer that handles the boilerplate for you. If your team uses ChatGPT, check out our guide on connecting Raiser's Edge NXT to ChatGPT, or if you are building on Anthropic's models, read our guide on connecting Raiser's Edge NXT to Claude. For developers building custom autonomous workflows, you need a programmatic way to fetch these tools and bind them to your agent framework.

This guide breaks down exactly how to fetch AI-ready tools for Raiser's Edge NXT, bind them natively to an LLM using frameworks like LangChain, LangGraph, CrewAI, or the Vercel AI SDK, and execute complex donor management workflows. For a deeper look at the architecture behind this approach, refer to our research on architecting AI agents and the SaaS integration bottleneck.

The Engineering Reality of the Raiser's Edge NXT API

Giving an LLM access to external CRM data sounds simple in a prototype. You write a Node.js function that makes a fetch request and wrap it in a tool decorator. In production against complex, legacy-backed systems like Raiser's Edge NXT, this approach collapses. If you hardcode these interactions into your agent, you will spend your sprints writing defensive integration code instead of improving your model's reasoning.

The Blackbaud SKY API introduces several specific integration challenges that break standard REST assumptions.

The Pagination Token Trap

Raiser's Edge NXT does not use standard limit/offset pagination across the board. Instead, it pages through records by following a next_link URL. What makes this difficult for AI agents is the variance in the token strategy. Standard action lists carry a continuation_token, but if you append a last_modified query parameter to the exact same endpoint, the API switches to using a sort_token.

If you build this manually, you must write branching logic to inspect the original query parameters and extract the correct token type from the next_link to feed back into the next request. Truto abstracts this away entirely, falling back to a standardized limit and offset implementation that LLMs natively understand.

Mutable "PREVIEW" Schemas

Many of the highest-value endpoints in Raiser's Edge NXT - specifically Gift V2, Advanced Lists, and Code Tables - are explicitly marked as "PREVIEW". Blackbaud reserves the right to change or remove these endpoints at any time. When an endpoint schema shifts, your hardcoded TypeScript definitions and JSON schemas break. If your LLM relies on a static schema, it will hallucinate payloads based on outdated documentation, resulting in failed gift entries or corrupted code table entries.

Truto dynamically generates schemas for every endpoint, ensuring that when Blackbaud modifies a PREVIEW payload requirement, the tool definition passed to your LLM updates automatically. Your agent always sees the current, valid schema.

Rate Limiting and IETF Normalization

Blackbaud enforces strict rate limits on the SKY API. Standard agents that execute loops quickly hit these limits, resulting in HTTP 429 Too Many Requests errors.

When dealing with rate limits, Truto does not silently absorb errors, retry, throttle, or apply arbitrary backoff. Doing so would sever the agent's execution context and cause timeouts in your application layer. Instead, when the upstream SKY 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) conforming to the IETF specification. It is your responsibility to implement backoff logic in your agent loop, using these standardized headers to pause execution deterministically.

Hero Tools for Raiser's Edge NXT

Instead of building individual API requests, your agent interacts with unified tools. The Truto /tools endpoint automatically maps Blackbaud SKY API endpoints into LLM-ready functions with strict JSON schemas.

Here are the highest-leverage tools available for Raiser's Edge NXT workflows.

Constituents Search (raisers_edge_nxt_constituents_search)

Before taking action on a donor, the agent must find their record. This tool searches individual and organization records, ranking results based on search filters. It supports searching by first name, last name, preferred name, email, phone, or lookup ID.

Contextual Usage: Agents should always use this tool to resolve a human-provided name into a definitive constituent_id before executing subsequent queries or mutations.

"Find the constituent record for 'Eleanor Vance' and verify her primary email address."

Lifetime Giving Summary (list_all_constituent_giving_summary_lifetime_giving)

Retrieves the comprehensive lifetime giving information for a specific constituent. This returns a single object containing aggregated data across all campaigns and funds.

Contextual Usage: Critical for prospect research and major gift workflows. Use this tool immediately after identifying a constituent to provide the LLM with the context needed to personalize outreach or classify the donor's tier.

"What is Eleanor Vance's lifetime giving total, and when was her most recent gift?"

Create an Action (create_a_raisers_edge_nxt_action)

Creates a constituent action (an interaction or task). This is how your agent logs phone calls, emails, or meetings back into the CRM.

Contextual Usage: Requires category, constituent_id, and date. Agents should use this tool at the end of an autonomous outreach workflow to ensure the CRM remains the source of truth.

"Log a phone call action for constituent ID 12345 taking place today, categorized under 'Cultivation'. Note that she expressed interest in the capital campaign."

Create a Gift (create_a_raisers_edge_nxt_gift_v_2_gift)

Adds a new gift to a constituent's record. This tool supports one-time gifts, pledges, pledge payments, recurring gifts, and stock.

Contextual Usage: This is a PREVIEW endpoint. It requires complex nested arrays for gift_splits depending on the gift type. The agent relies on Truto's strict schema enforcement to prevent payload validation errors.

"Record a new one-time gift of $500 for constituent ID 12345, applied to the 'Annual Fund' campaign."

Create an Opportunity (create_a_raisers_edge_nxt_opportunity)

Creates a major giving opportunity (proposal) for a constituent.

Contextual Usage: Used by agents acting as virtual gift officers. Requires constituent_id, name, and purpose. The status of the opportunity updates with a known latency of about 10 minutes, which the agent should be aware of if queried immediately after creation.

"Create a new major gift opportunity for constituent ID 12345 named '2026 Endowed Scholarship', with a purpose of 'Endowment'."

Append to List (create_a_raisers_edge_nxt_list_id)

Appends a set of identifiers to the filter of an existing Raiser's Edge NXT list.

Contextual Usage: Perfect for marketing operations. The agent can evaluate a group of constituents and bulk-add them to a campaign list (up to 100,000 IDs) without manual intervention.

"Add constituent IDs 12345, 12346, and 12347 to the 'Spring Gala Invites' list (List ID 890)."

To view the complete tool inventory, required arguments, and JSON schemas, visit the Raiser's Edge NXT integration page.

Workflows in Action

AI agents excel at orchestrating multi-step processes that previously required humans to manually click through multiple screens in the CRM. Here is how these tools chain together to execute concrete domain workflows.

Workflow 1: Major Gift Prospect Research

Persona: Development Director / Major Gifts Officer

"Review our recent interactions with Jonathan Crane. Summarize his lifetime giving, check if he has any open opportunities, and if he hasn't been contacted in the last 60 days, log an action for me to call him next Tuesday."

Agent Execution Steps:

1. raisers_edge_nxt_constituents_search: The agent searches for "Jonathan Crane" to retrieve his constituent_id.
2. list_all_constituent_giving_summary_lifetime_giving: Uses the retrieved ID to fetch his total giving history and greatest gift data.
3. list_all_raisers_edge_nxt_opportunities: Queries opportunities filtered by the constituent ID to check for open proposals.
4. list_all_raisers_edge_nxt_constituent_actions: Retrieves recent actions to determine the date of the last touchpoint.
5. create_a_raisers_edge_nxt_action: Evaluating that the last interaction was over 60 days ago, the agent creates a "Phone Call" task assigned to the user for next Tuesday.

Result: The user receives a concise briefing document containing Crane's giving capacity, active proposals, and confirmation that a follow-up task has been scheduled in the CRM.

Workflow 2: Automated Campaign Segmentation

Persona: Marketing & Annual Fund Manager

"Find all constituents who gave more than $1,000 to the '2024 Year End' appeal but have not yet contributed to the '2025 Spring Drive'. Add them to the list 'Target: Spring Upgrade'."

Agent Execution Steps:

1. list_all_raisers_edge_nxt_gifts: The agent retrieves gifts associated with the "2024 Year End" appeal ID, filtering for amounts > $1000.
2. list_all_raisers_edge_nxt_gifts: Executes a second query against the "2025 Spring Drive" appeal to identify overlap.
3. Local processing: The agent calculates the difference between the two datasets, isolating the specific constituent_ids who need outreach.
4. create_a_raisers_edge_nxt_list_id: The agent takes the resulting array of IDs and appends them to the target list ID.

Result: The marketing team's mailing list is automatically populated with the exact segment of donors primed for an upgrade ask, executed without running manual queries in the database view.

Building Multi-Step Workflows

Giving your agent access to Raiser's Edge NXT is a matter of fetching the tools and binding them to the LLM. Because Truto's proxy architecture serves standard JSON schemas, you are not locked into a specific agent framework or forced to maintain complex MCP boilerplate. This pattern works identically across LangChain, CrewAI, and the Vercel AI SDK.

1. The Architecture

The standard flow for tool execution looks like this:

sequenceDiagram
    participant App as Your Application
    participant Agent as Agent Framework (LangChain)
    participant Truto as Truto API
    participant Blackbaud as Blackbaud SKY API
    
    App->>Truto: GET /integrated-account/{id}/tools
    Truto-->>App: Return JSON array of CRM tools
    App->>Agent: bindTools(tools)
    App->>Agent: "Log a meeting with Eleanor Vance"
    
    Agent->>Agent: LLM decides to search constituent
    Agent->>Truto: Execute `constituents_search`
    Truto->>Blackbaud: Proxy formatted request
    Blackbaud-->>Truto: Return 200 OK (Constituent Data)
    Truto-->>Agent: Return normalized JSON
    
    Agent->>Agent: LLM decides to create action
    Agent->>Truto: Execute `create_a_raisers_edge_nxt_action`
    Truto->>Blackbaud: Proxy POST request
    Blackbaud-->>Truto: Return 201 Created
    Truto-->>Agent: Return success confirmation
    
    Agent-->>App: "Meeting logged successfully."

2. Fetching and Binding Tools

Using the truto-langchainjs-toolset, you can initialize the tools for a specific integrated account dynamically. This ensures that any custom fields or schema overrides configured in your Truto environment are immediately available to the agent.

import { ChatOpenAI } from "@langchain/openai";
import { TrutoToolManager } from "truto-langchainjs-toolset";
 
async function runAgent() {
  // 1. Initialize the LLM
  const llm = new ChatOpenAI({
    modelName: "gpt-4o",
    temperature: 0,
  });
 
  // 2. Fetch Raiser's Edge NXT tools for the specific account
  const toolManager = new TrutoToolManager({
    trutoApiKey: process.env.TRUTO_API_KEY,
    integratedAccountId: "renxt-account-123", // The connected Blackbaud account
  });
 
  const tools = await toolManager.getTools();
  
  // 3. Bind tools to the model
  const modelWithTools = llm.bindTools(tools);
 
  // 4. Execute a prompt
  const res = await modelWithTools.invoke([
    ["system", "You are a highly capable nonprofit CRM assistant."],
    ["human", "Find constituent Eleanor Vance and tell me her lifetime giving."]
  ]);
 
  console.log(res.tool_calls);
}

3. Handling Rate Limits Deterministically

When the LLM decides to execute a tool, your application executes the HTTP request against Truto. Because Truto acts as a pass-through layer, it will surface Blackbaud's API limits directly.

If the agent is processing a bulk list of donors and triggers a 429 Too Many Requests error, your application code must catch it, read the IETF standard headers, and instruct the framework to back off.

async function executeToolCall(toolCall) {
  try {
    // Execute the tool logic via Truto
    const result = await runTool(toolCall);
    return result;
  } catch (error) {
    if (error.status === 429) {
      const resetTime = error.headers.get('ratelimit-reset');
      const delayMs = (parseInt(resetTime) * 1000) - Date.now();
      
      console.warn(`Rate limit hit. Backing off for ${delayMs}ms`);
      await new Promise(resolve => setTimeout(resolve, delayMs));
      
      // Retry after backoff
      return executeToolCall(toolCall);
    }
    throw error;
  }
}

By handling the 429 gracefully, you prevent the agent from panicking or hallucinating a success response. The LLM remains unaware of the delay, maintaining its context window and completing the multi-step giving workflow securely.

Moving Beyond the Integration Bottleneck

Connecting Raiser's Edge NXT to an AI agent requires more than just API keys and basic fetch requests. It demands a robust layer capable of dynamically handling mutable schemas, complex pagination, and strict error transparency. By utilizing a unified tool layer, you remove the burden of integration maintenance from your engineering team, allowing them to focus entirely on improving the reasoning, memory, and UX of your agent.