Connect Givebutter to Claude: Track Fundraising and Transactions

If you need to connect Givebutter to Claude to automate donor communications, track fundraising campaigns, issue event tickets, or reconcile financial transactions, you need a Model Context Protocol (MCP) server. This server acts as the translation layer between Claude's natural language tool calls and Givebutter's REST APIs. You can either build and maintain this translation 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-givebutter-to-chatgpt-manage-campaigns-and-donor-relations/ or explore our broader architectural overview on /connect-givebutter-to-ai-agents-automate-giving-and-webhooks/.

Giving a Large Language Model (LLM) read and write access to a donor management and fundraising ecosystem like Givebutter is an engineering challenge. You must handle token lifecycles, map nested JSON schemas to MCP tool definitions, and deal with Givebutter's specific API routing and tagging rules. Every time an endpoint changes, 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 Givebutter, connect it natively to Claude Desktop, and execute complex fundraising workflows using natural language.

The Engineering Reality of the Givebutter 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 Givebutter's API introduces domain-specific hurdles. You are not just building standard CRUD endpoints - you are managing campaigns, processing transaction data, and handling donor profiles with strict relationships.

If you decide to build a custom MCP server for Givebutter, here are the specific integration challenges you will face:

Fragmented Authentication Guards (V1 vs SSO) Givebutter's API surface is split between standard public integrations and Single Sign-On (SSO) contexts. Endpoints under /v1 accept standard API keys and handle generic data access. However, endpoints under /sso/v1 (such as list_all_givebutter_sso_accounts or get_single_givebutter_sso_campaign_by_id) sit behind a completely different auth guard. If your MCP server attempts to call these with a standard key without the correct SSO session context, the API will strictly reject it with an "Unauthenticated" error. Your LLM has no context on these routing differences, meaning your MCP server must handle the abstraction and token management perfectly.

Complex Tag Mutation Logic Most CRMs allow you to update a contact's tags by sending an array in a standard PATCH request. Givebutter treats tags differently to prevent accidental data loss. If you want to append a tag without destroying existing ones, you must call a specific endpoint (POST .../tags/add). If you want to forcefully replace all tags, you call a synchronization endpoint (POST .../tags/sync). If you want to remove specific tags, you use a removal endpoint (POST .../tags/remove). A custom MCP server must explicitly define these distinct operations as separate tools so the LLM understands the destructive nature of a sync operation versus a safe append operation.

Handling Rate Limits and Standardized Headers When querying massive transaction histories or updating thousands of donor records, you will hit Givebutter's API rate limits. It is critical to note that Truto does not automatically retry, throttle, or apply backoff on rate limit errors. When the upstream Givebutter API returns an HTTP 429, Truto passes that exact error back to the caller (your AI agent). However, Truto normalizes the upstream rate limit information into standardized HTTP headers (ratelimit-limit, ratelimit-remaining, ratelimit-reset) per the IETF specification. The caller or your agent framework is strictly responsible for interpreting these headers and executing the appropriate retry or backoff logic.

Generating the Givebutter MCP Server

Instead of building this infrastructure from scratch, you can use Truto to dynamically generate a secure MCP server URL for your Givebutter account. Truto handles the schema mapping, tool generation, and authentication tunneling. You can create this server via the Truto UI or programmatically via the API.

Method 1: Via the Truto UI

For IT admins or fast prototyping, the Truto dashboard provides a direct way to generate an MCP server.

1. Log into your Truto environment and navigate to the Integrated Accounts page.
2. Select your connected Givebutter account.
3. Click the MCP Servers tab.
4. Click Create MCP Server.
5. Select your desired configuration. You can restrict the server to only read methods or apply specific tags to limit the tool scope.
6. Click Generate and copy the resulting MCP server URL (e.g., https://api.truto.one/mcp/abc123xyz...).

Method 2: Via the Truto API

For engineering teams embedding AI into their own platforms, you can generate MCP servers programmatically. This is highly useful when provisioning isolated AI access for different tenants or internal service accounts.

Make a POST request to the /integrated-account/:id/mcp endpoint using your Truto API key:

curl -X POST https://api.truto.one/integrated-account/<givebutter_account_id>/mcp \
  -H "Authorization: Bearer <your_truto_api_key>" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Givebutter Financials MCP",
    "config": {
      "methods": ["read", "write"],
      "tags": ["transactions", "campaigns"]
    }
  }'

The API returns a secure, ready-to-use JSON-RPC endpoint containing the cryptographic token:

{
  "id": "mcp_xyz987",
  "name": "Givebutter Financials MCP",
  "url": "https://api.truto.one/mcp/token_abc123...",
  "expires_at": null
}

Connecting the MCP Server to Claude

Once you have your Truto MCP URL, you need to configure Claude to use it. You can do this through the Claude application UI or by manually updating the desktop configuration file.

Method A: Via the Claude UI

If your organization uses Claude Team or Enterprise plans, you can add the connector directly in the interface:

1. Open Claude and navigate to Settings.
2. Click on Integrations (or Connectors, depending on your tier).
3. Select Add MCP Server.
4. Name the connection (e.g., "Givebutter Ops").
5. Paste the Truto MCP URL provided in the previous step.
6. Click Add. Claude will instantly send an initialize request to the server, discover the Givebutter tools, and make them available in your chat context.

Method B: Via the Claude Desktop Config File

If you are a developer using Claude Desktop locally, you can map the server using the configuration file. This approach utilizes the Server-Sent Events (SSE) transport protocol.

Open your Claude Desktop config file (located at ~/Library/Application Support/Claude/claude_desktop_config.json on macOS or %APPDATA%\Claude\claude_desktop_config.json on Windows) and add the following JSON:

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

Restart Claude Desktop. The application will boot, read the configuration, and establish a connection to the Truto edge router, instantly loading the Givebutter tool schemas.

Hero Tools for Givebutter Automation

Givebutter exposes a massive API surface. Instead of overwhelming the LLM with dozens of generic CRUD operations, you should focus on the highest-leverage tools that drive fundraising and donor management workflows.

Here are the hero tools Truto generates for Givebutter.

list_all_givebutter_campaigns

This tool retrieves the list of active fundraising campaigns, ticketing events, and donation forms. It is essential for discovering the campaign_id needed for downstream operations like issuing tickets or discounting.

Usage note: Truto automatically handles pagination cursors (up to 100 records per page), but the LLM must iterate if you are searching across hundreds of historical campaigns.

"Fetch all active fundraising campaigns in Givebutter. Find the one titled 'Annual Winter Gala' and give me its ID."

list_all_givebutter_transactions

Retrieves financial transactions across your Givebutter instance. This tool is vital for reconciling donations, checking ticket purchases, or exporting data for accounting systems.

Usage note: Because transactions can be high-volume, instruct Claude to use specific timeframes or filters if your Givebutter setup supports query parameters for dates.

"List the 50 most recent transactions. Calculate the total revenue generated and identify any donations over $500."

create_a_givebutter_contact_tag

Appends specific tags to a donor's profile without overwriting their existing tags. This is the safe way to segment your audience.

Usage note: Requires the contact_id and an array of tags strings.

"Add the tag 'VIP_Donor_2025' to the contact with ID 998877."

givebutter_contact_tags_bulk_update

Completely replaces a contact's tag array. Use this tool when you need to audit and reset a donor's classification from scratch.

Usage note: This is a destructive action. Any tags not included in your request payload will be removed from the contact.

"Sync the tags for contact ID 554433. Remove whatever they currently have and set their tags exclusively to 'Alumni' and 'Monthly_Sponsor'."

create_a_givebutter_campaign_discount_code

Generates promotional codes for specific events or campaigns. Useful for managing sponsor access or early-bird ticket pricing.

Usage note: Requires campaign_id, type (e.g., percentage or flat amount), active boolean, amount, and the actual code string.

"Create a new discount code for the campaign ID 112233. The code should be 'EARLYBIRD20', give a 20% discount, and be marked as active."

create_a_givebutter_webhook

Allows the AI agent to programmatically set up webhooks, routing real-time Givebutter events (like new donations or ticket sales) to external infrastructure.

Usage note: Requires the destination url. Depending on Givebutter's payload, you may also need to specify the events you wish to subscribe to.

"Create a new Givebutter webhook pointing to 'https://api.mycompany.com/webhooks/donations' that listens for successful transactions."

To view the complete inventory of available Givebutter tools, schema structures, and required parameters, visit the Givebutter integration page.

Workflows in Action

Connecting Givebutter to Claude shifts your operations from manual data entry to natural language orchestration. Here are two real-world workflows demonstrating how an AI agent strings these tools together to execute complex tasks.

Workflow 1: VIP Donor Identification and Tagging

Development directors spend hours manually reviewing transaction logs to identify major donors and apply segmentation tags for targeted outreach. Claude can automate this entirely.

"Review the latest transactions. Find any individual who has donated more than $1,000 in a single transaction. Find their contact record and append the tag 'Major_Donor_Q1' to their profile."

Execution steps:

1. list_all_givebutter_transactions: Claude fetches the recent financial ledger.
2. Internal Logic: The LLM parses the payload, filtering for amount > 1000 and extracts the associated contact_id for each matching transaction.
3. create_a_givebutter_contact_tag: Claude loops through the identified VIPs, calling this tool to safely append 'Major_Donor_Q1' without destroying their existing tags (e.g., 'Newsletter_Subscriber').

Result: The user receives a confirmation message listing the names and IDs of the upgraded donors, while Givebutter is instantly updated, triggering any downstream marketing automations tied to that tag.

sequenceDiagram
    participant User as User
    participant Claude as Claude Desktop
    participant Truto as Truto MCP Server
    participant Givebutter as Givebutter API

    User->>Claude: "Find $1000+ donors and tag them as Major_Donor_Q1"
    Claude->>Truto: Call list_all_givebutter_transactions
    Truto->>Givebutter: GET /v1/transactions
    Givebutter-->>Truto: JSON Array of transactions
    Truto-->>Claude: Return transaction payload
    
    Note over Claude: Filter payload for<br>amount > 1000<br>Extract contact_ids
    
    Claude->>Truto: Call create_a_givebutter_contact_tag (Contact A)
    Truto->>Givebutter: POST /v1/contacts/{id}/tags/add
    Givebutter-->>Truto: 200 OK
    Truto-->>Claude: Tag appended
    
    Claude-->>User: "Successfully tagged 3 major donors."

Workflow 2: Event Promotion and Discount Provisioning

Event managers frequently need to spin up targeted promotions for specific campaigns based on ticket sales velocity.

"Check the active campaigns and find the ID for the 'Spring Charity Run'. Once you have it, create a new active discount code called 'RUNNER15' that takes $15 off the ticket price."

Execution steps:

1. list_all_givebutter_campaigns: Claude pulls the active campaigns to search for the requested string.
2. Internal Logic: The LLM isolates the "Spring Charity Run" object and stores its id.
3. create_a_givebutter_campaign_discount_code: Claude invokes the creation tool using the extracted campaign_id, passing code: "RUNNER15", type: "amount", amount: 15.00, and active: true.

Result: The discount code is immediately provisioned in Givebutter. The LLM reports back that the code is live and ready to be distributed in marketing materials.

Security and Access Control

Giving an AI model write access to financial systems requires strict governance. Truto's MCP implementation provides several layers of security to control exactly what Claude can do with your Givebutter data.

• Method Filtering: You can configure the MCP server to only allow specific HTTP methods. For example, setting methods: ["read"] ensures the LLM can query transactions and campaigns but cannot create discount codes or modify tags.
• Tag Filtering: If your Givebutter integration configuration uses config.tool_tags, you can restrict the MCP server to only expose tools relevant to specific domains (e.g., only exposing transactions tools to a finance bot).
• Secondary Authentication: By setting require_api_token_auth: true during server creation, Truto requires the MCP client to pass a valid Truto API token in the authorization header. This ensures that possession of the MCP URL alone is not enough to access the data.
• Automatic Expiration: You can pass an expires_at ISO datetime when creating the server. Truto will automatically destroy the token and its associated edge storage when the time expires, which is perfect for granting temporary access to external contractors or temporary agents.

Architecting for Scale

Connecting Givebutter to Claude via Truto's MCP implementation removes the heavy lifting of OAuth token refreshes, endpoint maintenance, and schema transformations. Instead of writing custom API wrappers to figure out whether to use POST /tags/add or POST /tags/sync, your engineering team can focus on designing the agentic workflows that actually generate revenue and improve donor relations.

By leveraging dynamic, documentation-driven tool generation, you ensure that your LLMs always have accurate, strictly typed schemas to work against, drastically reducing hallucinated parameters and failed API calls.