Connect GoFundMe Pro to ChatGPT: Manage Campaigns & Donor Insights

If you need to connect GoFundMe Pro to ChatGPT to automate campaign orchestration, extract donor insights, or trigger asynchronous financial reports, you need a Model Context Protocol (MCP) server. This server acts as the translation layer between ChatGPT's function-calling engine and GoFundMe Pro's REST API. You can either build and maintain this translation layer from scratch, 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 GoFundMe Pro to Claude or explore our broader architectural overview on connecting GoFundMe Pro to AI Agents.

Giving a Large Language Model (LLM) read and write access to a non-profit and peer-to-peer fundraising platform is a significant engineering challenge. You must handle complex relational entities, asynchronous batch processing for reporting, and strict dual-authentication contexts. Writing static JSON-RPC schemas for these endpoints means writing hundreds of lines of boilerplate that will instantly break when the vendor updates their schema.

This guide breaks down exactly how to use Truto to generate a secure, managed MCP server for GoFundMe Pro, connect it natively to ChatGPT, and execute complex donor 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, implementing it against GoFundMe Pro's specific architecture requires navigating severe edge cases. If you choose to build a custom MCP server, you own the lifecycle of the following API quirks:

Dual Authentication Contexts (App vs. Member)

GoFundMe Pro enforces strict boundaries between application-level context and user-level context. The API supports two distinct authentication paradigms: Client Credentials (App context) and OAuth2 Authorization Code (Member context, often referred to internally as Classy Login).

Many high-leverage write operations - such as update_a_go_fund_me_pro_campaign_by_id, creating appeal sets, or publishing domain slugs - explicitly require a Member connection. If an LLM attempts to execute these tools under an App connection, the API will throw a hard authentication error. Your integration layer must manage these distinct token lifecycles and ensure the AI agent is fully aware of its authorization scope before attempting mutations.

Asynchronous Batch Processing for Reports

Non-profit administrators rely heavily on Annual Summary Reports (ASR) for tax and compliance purposes. In the GoFundMe Pro API, generating these reports is not a synchronous CRUD operation. Calling endpoints like create_a_go_fund_me_pro_organization_annual_summary_report triggers an asynchronous batch job.

The API returns a 202 Accepted status indicating the job is queued. Your AI agent cannot simply wait for the PDF in the immediate response. It must be provided with the appropriate polling tools (get_organization_annual_summary_report_by_id) and download endpoints to retrieve the pre-signed S3 URLs once the batch resolves. Translating this async pattern into atomic LLM tool calls requires careful schema design.

Strict Rate Limiting and Backoff Delegation

GoFundMe Pro enforces rate limits to ensure platform stability. When integrating via Truto, it is critical to understand how these limits propagate. Truto does not retry, throttle, or apply backoff on rate limit errors. When the GoFundMe Pro API returns an HTTP 429 Too Many Requests, Truto passes that error directly to the caller.

However, Truto normalizes the upstream rate limit information into standardized headers (ratelimit-limit, ratelimit-remaining, ratelimit-reset) per the IETF specification. The caller - your application or the LLM's execution loop - is entirely responsible for reading these headers and implementing retry or backoff logic. Do not expect the MCP server to magically absorb rate limit errors.

How to Generate a GoFundMe Pro MCP Server

Truto's MCP server generation is dynamic and documentation-driven. It reads the connected GoFundMe Pro integration's resource definitions and automatically derives JSON-RPC 2.0 tool schemas.

You can generate an MCP server for a specific GoFundMe Pro account using either the Truto UI or the API.

Method 1: Via the Truto UI

This is the fastest method for internal testing or administrative setup.

1. Log into your Truto dashboard and navigate to Integrated Accounts.
2. Select your connected GoFundMe Pro instance (ensure you used a Member connection if you need write access to campaigns).
3. Click the MCP Servers tab.
4. Click Create MCP Server.
5. Configure your server: set a name, restrict allowed methods (e.g., read only), or filter by tags (e.g., campaigns, donors).
6. Click Save and copy the generated MCP server URL (it will look like https://api.truto.one/mcp/<token>).

Method 2: Via the Truto API

For production applications, you should programmatically provision MCP servers scoped to your users' connected accounts.

Make a POST request to /integrated-account/:id/mcp using your Truto API token. You can pass a configuration object to strictly limit what the AI agent can 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": "GoFundMe Pro Donor Insights Agent",
    "config": {
      "methods": ["read", "write"],
      "tags": ["campaigns", "organizations", "reports"]
    },
    "expires_at": "2026-12-31T23:59:59Z"
  }'

The API validates that the integration has documented tools available for the requested filters, provisions the secure token in a globally distributed key-value store, and returns the endpoint:

{
  "id": "mcp-uuid-string",
  "name": "GoFundMe Pro Donor Insights Agent",
  "config": { "methods": ["read", "write"] },
  "expires_at": "2026-12-31T23:59:59Z",
  "url": "https://api.truto.one/mcp/a1b2c3d4e5f6..."
}

Treat this url as a highly sensitive credential. It contains cryptographic routing information that authenticates requests directly to that specific GoFundMe Pro account.

Connecting the MCP Server to ChatGPT

Once you have your Truto MCP URL, connecting it to your LLM framework takes seconds. You do not need to deploy any additional backend code.

Option A: Via the ChatGPT UI

If you are using ChatGPT Pro, Plus, Business, Enterprise, or Education accounts, you can add the server directly as a Custom Connector.

1. Open ChatGPT and navigate to Settings -> Apps -> Advanced settings.
2. Ensure Developer mode is enabled.
3. Under Custom connectors (or MCP servers), click Add a new server.
4. Name: Enter a recognizable label (e.g., "GoFundMe Pro API").
5. Server URL: Paste the https://api.truto.one/mcp/<token> URL you copied from Truto.
6. Click Save.

ChatGPT will immediately perform an MCP handshake, calling the initialize and tools/list endpoints to discover the GoFundMe Pro schemas.

Option B: Via Manual Config File (Local Agents)

If you are building custom agents or using desktop frameworks that read an mcp.json config file, you can pipe the Truto HTTP endpoint through an SSE (Server-Sent Events) adapter.

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

Hero Tools for GoFundMe Pro

When ChatGPT lists tools from the Truto MCP server, it parses the query and body schemas dynamically. Here are the highest-leverage tools available for GoFundMe Pro automation.

get_single_go_fund_me_pro_campaign_by_id

Retrieves a complete snapshot of a specific campaign, including its status, financial goals, and configuration. This is typically the first tool an agent uses to establish context.

"Fetch the details for the 'Save The Local Library' campaign using ID 98234. I need to know the current amount raised versus the goal."

update_a_go_fund_me_pro_campaign_by_id

Mutates an existing campaign. Because this alters live fundraising data, the underlying GoFundMe Pro integration must be authenticated via a Member connection (Classy Login). App connections cannot call this.

"Update the campaign description for ID 98234 to include our new matching donor announcement, and increase the total goal to $50,000."

list_all_go_fund_me_pro_organization_supporters

Extracts a paginated list of all supporters across an organization. Truto normalizes the pagination schemas here, instructing the LLM to pass the next_cursor back exactly as received if it needs to traverse multiple pages.

"Pull the first 100 supporters for our organization. Give me a breakdown of their geographic locations based on the data."

list_all_go_fund_me_pro_campaign_recurring_donation_plans

Recurring donations are the lifeblood of non-profits. This tool fetches all active recurring plans tied to a specific campaign, allowing the AI to analyze retention and predictable MRR.

"List all recurring donation plans for campaign 98234. Calculate the total expected monthly revenue from these active plans."

create_a_go_fund_me_pro_organization_annual_summary_report

Triggers the asynchronous generation of Annual Summary Report (ASR) PDFs for all supporters who transacted in a specified year. This initiates a batch job on GoFundMe Pro's servers.

"Trigger the generation of Annual Summary Reports for the year 2023 for organization ID 4455."

create_a_go_fund_me_pro_campaign_fundraising_page

Allows the AI to programmatically spin up new individual fundraising pages tied to a parent campaign, which is critical for scaling peer-to-peer mobilization efforts.

"Create a new fundraising page under campaign 98234 for 'Team Alpha'. Set their specific target to $5,000."

To view the complete inventory of available GoFundMe Pro tools, schemas, and relational requirements, visit the GoFundMe Pro integration page.

Workflows in Action

Exposing atomic REST endpoints to an LLM is only useful if the agent can chain them together to solve actual business problems. Here are two real-world GoFundMe Pro scenarios executed via ChatGPT.

Scenario 1: End-of-Year Donor Reconciliation

Non-profit administrators spend weeks at the end of the year reconciling donor lists and issuing tax reports. An AI agent can handle this end-to-end.

"Find our top 50 supporters for the organization this year. Once you have them, trigger the generation of the 2023 Annual Summary Reports for the organization so we can mail their tax receipts."

How the agent executes this:

1. Calls list_all_go_fund_me_pro_organization_supporters, passing the organization ID and limit parameters.
2. Analyzes the returned JSON array to identify the top supporters based on transaction history or lifetime value.
3. Calls create_a_go_fund_me_pro_organization_annual_summary_report passing the organization_id and year: 2023 to kick off the async batch job.
4. Returns a message to the user confirming the batch has started and listing the identified top donors.

sequenceDiagram
  participant User as User
  participant ChatGPT as ChatGPT
  participant MCP as Truto MCP Server
  participant GFM as GoFundMe Pro API

  User->>ChatGPT: "Find top supporters & trigger ASR..."
  ChatGPT->>MCP: Call list_all_go_fund_me_pro_organization_supporters
  MCP->>GFM: GET /organizations/{id}/supporters
  GFM-->>MCP: Return supporter list
  MCP-->>ChatGPT: JSON Response
  ChatGPT->>MCP: Call create_a_go_fund_me_pro_organization_annual_summary_report
  MCP->>GFM: POST /organizations/{id}/annual-summary-reports
  GFM-->>MCP: 202 Accepted (Batch started)
  MCP-->>ChatGPT: Success confirmation
  ChatGPT-->>User: "Top donors identified. Batch ASR initiated."

Scenario 2: Peer-to-Peer Campaign Expansion

A campaign manager wants to quickly spin up a new peer-to-peer branch based on an existing campaign's metrics.

"Check the current status of the 'Winter Drive' campaign. If it has raised more than $10,000, create a new fundraising page under it for 'The Corporate Sponsors Team' and update the main campaign's description to thank our new sponsors."

How the agent executes this:

1. Calls get_single_go_fund_me_pro_campaign_by_id to inspect the Winter Drive campaign's current financial metrics.
2. Evaluates the response. If the raised amount exceeds $10,000, it proceeds.
3. Calls create_a_go_fund_me_pro_campaign_fundraising_page to spin up the new peer-to-peer page for the corporate team.
4. Calls update_a_go_fund_me_pro_campaign_by_id (utilizing the required Member Connection) to patch the description field with the updated copy.
5. Summarizes the changes and provides the user with the ID of the newly created fundraising page.

Security and Access Control

Giving an LLM access to a live fundraising database requires stringent security. Truto's MCP servers provide several layers of defense to ensure agents only access what they should.

• Method Filtering: By defining config.methods: ["read"] during server creation, you completely remove all create, update, and delete tools from the MCP server. The LLM cannot hallucinate a write operation because the tools literally do not exist in the JSON-RPC schema.
• Tag Filtering: You can restrict the server to specific GoFundMe Pro resources by setting config.tags: ["campaigns"]. This prevents the agent from discovering tools related to sensitive billing or user management endpoints.
• Require API Token Auth: By setting require_api_token_auth: true, possession of the MCP URL is no longer enough to invoke tools. The client (e.g., your custom agent backend) must also pass a valid Truto API Bearer token, adding a second layer of authentication.
• Auto-Expiration: You can set an expires_at timestamp. Once reached, scheduled workers completely destroy the token from the edge KV store and database, instantly severing the AI's access to the GoFundMe Pro account.

Strategizing AI Integration for Non-Profits

The true power of the Model Context Protocol is turning static API documentation into dynamic, LLM-executable logic. By using a managed MCP server, you abstract away GoFundMe Pro's dual-authentication quirks, asynchronous batch requirements, and deeply nested routing structures.

Instead of burning engineering cycles writing schema parsers and managing OAuth tokens, your team can focus on building intelligent agents that help non-profits analyze donor behavior, scale peer-to-peer fundraising, and automate compliance reporting.