Connect GoFundMe Pro to Claude: Sync Donation & Financial Records

If you need to connect GoFundMe Pro to Claude to automate peer-to-peer fundraising operations, generate annual summary reports, manage donor records, or reconcile offline transactions, you need a Model Context Protocol (MCP) server. This server acts as the critical translation layer between Claude's JSON-RPC tool calls and GoFundMe Pro's deeply hierarchical REST API. You can either build, host, 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-gofundme-pro-to-chatgpt-manage-campaigns-donor-insights/ or explore our broader architectural overview on /connect-gofundme-pro-to-ai-agents-automate-peer-to-peer-growth/.

Giving a Large Language Model (LLM) read and write access to a sprawling, financially sensitive ecosystem like GoFundMe Pro is a significant engineering challenge. You have to handle dual authentication contexts, map massive, nested JSON schemas to MCP tool definitions, and deal with complex asynchronous reporting batches. Every time GoFundMe Pro updates an endpoint or alters a schema, you have to update your server code, redeploy, and rigorously test the integration to ensure financial data integrity.

This guide breaks down exactly how to use Truto to generate a secure, managed MCP server for GoFundMe Pro, connect it natively to Claude Desktop, and execute complex peer-to-peer fundraising workflows using natural language.

The Engineering Reality of the GoFundMe Pro 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 GoFundMe Pro's specific APIs is painful. GoFundMe Pro is designed to handle enterprise-grade peer-to-peer (P2P) fundraising, which means its data models and operational rules are strictly enforced.

If you decide to build a custom MCP server for GoFundMe Pro, you own the entire API lifecycle. Here are the specific challenges you will face:

Dual Authentication Models (Classy Login vs App Credentials)

GoFundMe Pro enforces a strict, bifurcated authentication model. Basic read operations or general data querying can often be accomplished using standard client credentials (an "app" connection). However, critical write operations - such as publishing campaigns, creating offline transactions, or updating a fundraising page - strictly require a "Member" connection (often referred to internally as Classy Login).

An LLM has no concept of auth context. If you build a custom MCP server, your middleware must intelligently handle token lifecycles for both connection types and ensure that tools requiring Member context are only exposed or executed when a valid user session exists. Truto abstracts this away at the infrastructure level, binding the MCP server to a fully managed Integrated Account that handles credential refresh automatically.

Deep Hierarchical Data Structures

GoFundMe Pro does not use a flat data structure. The domain logic is deeply nested: an Organization contains Campaigns; Campaigns contain Fundraising Teams; Teams contain Fundraising Pages; and Pages contain Donors, Transactions, and Activity Feeds.

When an LLM attempts to fetch a list of donors, it cannot simply call a global GET /donors endpoint. It must traverse the hierarchy. Your MCP server must generate explicit, strictly typed schemas that force Claude to provide the required organization_id, campaign_id, or fundraising_page_id before invoking the API. Without this rigid schema enforcement, the LLM will hallucinate invalid API paths and fail constantly.

Asynchronous Batch Reporting

Not all endpoints in GoFundMe Pro behave like standard synchronous CRUD operations. Financial and tax operations, such as generating Annual Summary Reports (ASRs) for supporters, are asynchronous batch jobs. You must initiate the job, receive an accepted status, and then separately poll a different endpoint to retrieve the presigned S3 URLs containing the generated PDFs.

Teaching Claude to handle this multi-step asynchronous dance requires explicitly defining multiple tools and providing schema descriptions that act as "system prompts" guiding the agent on how to poll the batch status.

Generating the MCP Server

Truto dynamically generates MCP tools from the GoFundMe Pro integration's resource definitions and documentation. There is no hard-coded routing logic to maintain.

Truto scopes each MCP server to a single integrated account (a specific connected GoFundMe Pro tenant). The resulting server URL contains a cryptographically hashed token that authenticates the client, identifies the tenant, and applies any configured security filters.

You can generate this server via the Truto UI or programmatically via the REST API.

Method 1: Via the Truto UI

For administrators and product managers, the easiest way to provision access is through the dashboard:

1. Navigate to the Integrated Accounts page for your GoFundMe Pro connection.
2. Click the MCP Servers tab.
3. Click Create MCP Server.
4. Select your desired configuration. You can assign a human-readable name, select allowed HTTP methods (e.g., limit the server to read operations only), and set an optional expiration date (e.g., expire the server in 7 days for a temporary audit agent).
5. Click Create and copy the generated MCP server URL.

Method 2: Via the Truto API

For engineering teams embedding AI into their applications, MCP servers can be provisioned programmatically on demand. This allows your backend to spin up an agent, hand it a scoped MCP URL, and tear it down when the task is complete.

Make an authenticated POST request to the Truto API:

curl -X POST https://api.truto.one/integrated-account/{integrated_account_id}/mcp \
  -H "Authorization: Bearer YOUR_TRUTO_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "GoFundMe Pro Year-End Audit Agent",
    "config": {
      "methods": ["read", "write"],
      "tags": ["financials", "reporting"]
    },
    "expires_at": "2026-12-31T23:59:59Z"
  }'

The API returns a secure, ready-to-use URL:

{
  "id": "mcp_abc123",
  "name": "GoFundMe Pro Year-End Audit Agent",
  "config": { "methods": ["read", "write"], "tags": ["financials", "reporting"] },
  "expires_at": "2026-12-31T23:59:59.000Z",
  "url": "https://api.truto.one/mcp/a1b2c3d4e5f6..."
}

This URL handles the JSON-RPC 2.0 handshake and exposes the generated tools dynamically.

Connecting GoFundMe Pro to Claude

Once you have your Truto MCP URL, you can plug it directly into Claude. The URL acts as a self-contained Server-Sent Events (SSE) transport layer.

Method 1: Via the Claude UI (Claude Desktop or ChatGPT)

If you are using the Claude Desktop application or ChatGPT Developer Mode, you can add the server visually:

1. Open Claude Desktop.
2. Navigate to Settings -> Integrations -> Add MCP Server (In ChatGPT, this is under Settings -> Apps -> Advanced Settings -> Developer Mode).
3. Enter a recognizable name, such as "GoFundMe Pro Operations".
4. Paste your Truto MCP Server URL.
5. Click Add.

Claude will immediately ping the /initialize endpoint, discover the GoFundMe Pro tools, and confirm the connection.

Method 2: Via the Configuration File

For advanced users, automation pipelines, or headless agent setups, you can configure the MCP connection directly in the claude_desktop_config.json file. Truto provides an NPM package (@modelcontextprotocol/server-sse) that acts as a proxy bridge between Claude's standard stdio transport and Truto's remote SSE endpoint.

Add the following block to your configuration file:

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

Restart Claude Desktop. The application will execute the npx command in the background, establish the connection, and ingest the tool schemas.

GoFundMe Pro MCP Tools

When Claude connects to the Truto MCP server, it receives a filtered list of tools generated from the GoFundMe Pro API documentation. Each tool includes strict JSON schemas dictating exactly which query parameters and body payloads are required.

Here are some of the highest-leverage "hero tools" available for GoFundMe Pro automation.

Get Single Campaign by ID

Before executing deep operational workflows, an AI agent often needs to orient itself by fetching the core metadata of a campaign. This tool retrieves a campaign by its ID, revealing its status, target goal, and hierarchical structure.

"Fetch the details for campaign ID 99384. I need to know the current funds raised versus the overall goal, and whether the campaign is currently published or in draft mode."

List All Fundraising Page Donors

This tool retrieves all successful donations directed to a specific fundraising page. It is essential for auditing efforts, as it lists each individual donation (including anonymous and offline records) so that an agent can calculate metrics or draft personalized thank-you lists.

"Get the list of all donors for fundraising page ID 48291. Extract their email addresses and the amounts donated, then organize them into a table sorted by highest donation amount."

Create Campaign Transaction (Offline)

Non-profits and enterprise fundraisers frequently collect checks, cash, or wire transfers outside the GoFundMe Pro digital checkout. This tool allows the agent to log an "offline" transaction against a campaign so that it reflects in the overall progress bars and financial reports. Note: This requires a Member connection (Classy Login).

"Log a new offline transaction for campaign ID 99384. The amount is $5,000 USD, donated by 'Acme Corp Foundation' via a physical check received today. Mark the transaction status as completed."

Create Organization Annual Summary Report

Tax season and end-of-year reconciliations require bulk documentation. This tool initiates the asynchronous batch process that generates Annual Summary Report (ASR) PDFs for all supporters within an organization who made transactions in a specified year.

"Initiate the batch generation of Annual Summary Reports for organization ID 1029 for the year 2025. Once initiated, track the batch ID and let me know when we can poll for the finalized PDFs."

List All Organization Payouts

Reconciling the organization's bank accounts against GoFundMe Pro requires exact payout data. This tool fetches all payouts initiated by GoFundMe Pro on a given date for a specific organization, allowing agents to automate bank reconciliation tasks.

"Retrieve all payouts processed for organization ID 1029 on October 1st, 2025. Cross-reference the payout totals against our internal ledger expectations."

Create Fundraising Page Update

Keeping supporters engaged is critical for P2P campaign success. This tool allows the agent to post a progress update directly to a specific fundraising page. Note: This requires a Member connection (Classy Login).

"Draft and post a new update to fundraising page ID 48291. The update should thank supporters for helping us reach 50% of our goal and include a brief note about the impact their funds are already having."

For a complete list of available operations, detailed schema requirements, and field definitions, visit the GoFundMe Pro integration page.

Workflows in Action

By providing Claude with access to these tools, you transform the LLM from a passive chat interface into an active, autonomous financial and operational agent.

Here are two concrete examples of how an AI agent uses these tools in the real world.

Workflow 1: End-of-Year Donor Reconciliation

Persona: Finance Operations Manager

At the end of the fiscal year, finance teams must reconcile offline checks and generate tax documents for major donors. Doing this manually across hundreds of campaigns is grueling.

"Please log the attached list of 5 offline checks against the 'Winter Gala' campaign (ID 5543). Once logged, initiate the 2025 Annual Summary Report batch generation for our organization (ID 1029) and inform me when the job is accepted."

Agent Execution Steps:

1. The agent calls get_single_go_fund_me_pro_campaign_by_id (ID: 5543) to verify the campaign is active and accepts offline funds.
2. The agent loops through the provided list and calls create_a_go_fund_me_pro_campaign_transaction five times, carefully formatting the JSON body for offline cash/check payloads.
3. The agent calls create_a_go_fund_me_pro_organization_annual_summary_report passing organization_id: 1029 and year: 2025.
4. The agent returns the 202 Accepted response to the user, providing the Batch ID for later polling.

flowchart TD
    A["Claude Agent"] -->|"1. Verify Campaign"| B["Truto MCP Server"]
    B -->|"GET /campaigns/5543"| C["GoFundMe Pro API"]
    A -->|"2. Loop Offline Txs"| B
    B -->|"POST /campaigns/5543/transactions"| C
    A -->|"3. Initiate ASR Batch"| B
    B -->|"POST /organizations/1029/asr"| C
    C -->|"202 Accepted (Batch ID)"| B
    B -->|"Return to User"| A

Workflow 2: Peer-to-Peer Campaign Oversight

Persona: Campaign Manager

Managing a massive P2P event involves tracking hundreds of individual fundraising pages, identifying top performers, and posting encouraging updates to keep momentum high.

"Look up the top 3 fundraising pages for the 'City Marathon' campaign (ID 8821). Identify the page with the highest number of unique donors. Draft a congratulatory update and post it to that specific page."

Agent Execution Steps:

1. The agent calls list_all_go_fund_me_pro_campaign_fundraising_pages for campaign ID 8821.
2. The agent evaluates the returned pages and identifies the page with the highest donor count (e.g., Page ID 9912).
3. The agent calls list_all_go_fund_me_pro_fundraising_page_donors for Page ID 9912 to extract context for a personalized message (e.g., noting a recent large donation).
4. The agent formulates a localized, context-rich update message.
5. The agent calls create_a_go_fund_me_pro_fundraising_page_update to publish the message live to the page.

Security and Access Control

Exposing financial and donor APIs to an autonomous LLM demands strict security guardrails. Truto's MCP architecture provides multiple layers of control baked directly into the token URL, ensuring the agent can never exceed its authorized scope.

• Method Filtering: You can restrict a server to specific operation categories by setting config.methods (e.g., ["read"]). If an agent attempts to execute a create tool on a read-only server, Truto intercepts and rejects the JSON-RPC call before it ever touches GoFundMe Pro.
• Tag Filtering: Limit the available tools to specific functional areas using config.tags (e.g., only exposing tools tagged with financials or reporting).
• Require API Token Auth: By default, possessing the MCP URL grants access to the exposed tools. For highly sensitive environments, you can set require_api_token_auth: true. This adds a second middleware layer requiring the MCP client to also pass a valid Truto API token in the Authorization header.
• Time-to-Live (TTL): Set an expires_at timestamp when generating the server. Truto uses Cloudflare KV expiration and Durable Object alarms to physically destroy the token and its metadata the moment the TTL is reached, ensuring no ghost access remains.

Handling GoFundMe Pro Rate Limits

Large-scale data extraction - such as iterating through hundreds of donor pages - will eventually trigger GoFundMe Pro's API rate limits.

It is important to understand that Truto does not silently absorb, retry, or apply backoff to rate limit errors. When GoFundMe Pro returns an HTTP 429 Too Many Requests response, Truto immediately passes that error back to the MCP client.

To ensure compatibility across different LLM frameworks, Truto intercepts the vendor-specific rate limit headers and normalizes them into standard IETF headers:

• ratelimit-limit: The total requests allowed in the current window.
• ratelimit-remaining: The number of requests remaining.
• ratelimit-reset: The Unix timestamp when the window resets.

When building custom MCP clients or instructing Claude, you must account for these headers. The caller (the LLM or your agent orchestrator) is strictly responsible for reading the ratelimit-reset header, sleeping the thread, and executing the retry.

Connect Your SaaS Stack Today

Building a reliable, secure connection between Claude and GoFundMe Pro shouldn't require months of custom middleware development, dual-auth lifecycle management, and constant schema monitoring. By leveraging Truto's dynamically generated MCP servers, your engineering team can skip the infrastructure boilerplate and focus entirely on designing high-value financial and fundraising workflows.

With built-in rate limit normalization, dynamic schema derivation, and rigid token security, you get a production-ready translation layer that turns Claude into a fully capable GoFundMe Pro operator in minutes.