--- title: "Connect Peach to Claude: Sync Donor Data and Monitor Fundraising" slug: connect-peach-to-claude-sync-donor-data-and-monitor-fundraising date: 2026-07-17 author: Uday Gajavalli categories: ["AI & Agents"] excerpt: "Learn how to build a managed MCP server for Peach. Give Claude secure read and write access to campaigns, donors, and payments without managing API infrastructure." tldr: "Connect Claude to Peach using a managed MCP server. This guide covers bypassing complex payment payload validations, handling Peach's specific rate limit headers, and executing multi-step fundraising workflows." canonical: https://truto.one/blog/connect-peach-to-claude-sync-donor-data-and-monitor-fundraising/ --- # Connect Peach to Claude: Sync Donor Data and Monitor Fundraising If you need to connect Peach to Claude to automate donor management, track campaign statistics, or modify recurring payments, you need a [Model Context Protocol (MCP) server](https://truto.one/what-is-mcp-and-mcp-servers-and-how-do-they-work/). This server acts as the translation layer between Claude's natural language tool calls and Peach's underlying REST endpoints. You can either build, host, and maintain this stateful infrastructure yourself, or use a [managed integration platform like Truto](https://truto.one/managed-mcp-for-claude-full-saas-api-access-without-security-headaches/) to dynamically generate a secure, authenticated MCP server URL. If your team prefers OpenAI's ecosystem, check out our guide on [connecting Peach to ChatGPT](https://truto.one/connect-peach-to-chatgpt-manage-campaigns-and-process-payments/) or explore our architectural deep dive on [connecting Peach to AI Agents](https://truto.one/connect-peach-to-ai-agents-automate-contacts-and-payment-flows/). Giving a Large Language Model (LLM) read and write access to a specialized fundraising platform like Peach requires strict constraints. You must handle authentication boundaries, normalize pagination, and ensure the LLM strictly adheres to the vendor's required payload schemas. Every time the API changes, your integration code has to adapt. This guide breaks down exactly how to use Truto to generate a secure, [managed MCP server for Peach](https://truto.one/managed-mcp-for-claude-full-saas-api-access-without-security-headaches/), connect it natively to Claude, and execute multi-step fundraising workflows using natural language. ## The Engineering Reality of the Peach API A custom MCP server is a self-hosted proxy layer. While the [MCP standard](https://truto.one/what-is-mcp-and-mcp-servers-and-how-do-they-work/) provides a predictable framework for models to discover tools via JSON-RPC 2.0, the reality of implementing it against a specific vendor's API is difficult. If you decide to build a custom MCP server for Peach, you take on the entire API lifecycle. Here are the specific engineering challenges you will face: **Strict Conditional Payload Rules** LLMs are notoriously bad at adhering to conditional API rules. When creating a payment in Peach, the currency defaults to `ILS`. However, if you are creating a recurring donation and set `isSubscription` to `true`, the API strictly requires the `billingCycles` field to be populated. If the LLM generates a payload without it, the request fails. Truto handles this by extracting query and body schemas from documentation and injecting explicit, machine-readable instructions directly into the JSON Schema presented to Claude, ensuring the model constructs valid requests on the first try. **Polymorphic Contact Lookups** When fetching a single Peach contact, the API does not just accept a standard UUID in the URL path. The endpoint requires exactly one of several identifiers: `contactId`, `email`, `phoneNumber`, or `tz`. Writing a custom server means writing custom routing logic to parse the LLM's arguments and map them to the correct query parameter format. Truto's proxy architecture standardizes this input namespace automatically. **[Rate Limits and Backoff](https://truto.one/how-to-handle-third-party-api-rate-limits-when-an-ai-agent-is-scraping-data/)** Peach enforces strict rate limits on API consumption. A critical architectural detail to understand: **Truto does not retry, throttle, or apply backoff on rate limit errors.** When the upstream Peach API returns an HTTP `429 Too Many Requests`, Truto passes that error directly to the caller. What Truto *does* do is normalize the upstream rate limit information into standardized headers (`ratelimit-limit`, `ratelimit-remaining`, `ratelimit-reset`) per the IETF specification. This means your client framework (or custom agent loop) must detect the `429` status code and implement its own retry logic with exponential backoff. Do not assume the integration layer will absorb traffic spikes for you. ## Generating the Peach MCP Server Truto's MCP architecture turns any connected integration into an MCP-compatible tool server dynamically. Tools are not hardcoded; they are generated on the fly from the integration's resource definitions and documentation records. If an endpoint is documented in Truto, it becomes an available tool for Claude. Each MCP server is scoped to a single integrated account (a specific tenant's connected instance of Peach) and secured by a hashed cryptographic token. You can generate the MCP server URL in two ways: via the Truto UI for rapid prototyping, or via the API for programmatic deployments. ### Method 1: Via the Truto UI For administrators setting up an internal tool, the UI is the fastest path: 1. Navigate to the **Integrated Accounts** page in your Truto dashboard. 2. Select your connected Peach instance. 3. Click the **MCP Servers** tab. 4. Click **Create MCP Server**. 5. Select your desired configuration (e.g., restrict to read-only methods, filter by specific tags). 6. Copy the generated MCP server URL (it will look like `https://api.truto.one/mcp/`). ### Method 2: Via the API For engineers building multi-tenant AI products, you can generate MCP servers programmatically. This endpoint provisions the server, securely hashes the token into key-value storage, and returns the URL. **Endpoint:** `POST /integrated-account/:id/mcp` ```typescript // Example Request const response = await fetch('https://api.truto.one/integrated-account/YOUR_ACCOUNT_ID/mcp', { method: 'POST', headers: { 'Authorization': 'Bearer YOUR_TRUTO_API_TOKEN', 'Content-Type': 'application/json' }, body: JSON.stringify({ name: "Peach Campaign Auditor", config: { methods: ["read", "write"], tags: ["crm", "payments"] }, expires_at: "2026-12-31T23:59:59Z" }) }); const data = await response.json(); console.log(data.url); // The MCP server URL ``` ## Connecting the MCP Server to Claude Once you have your Truto MCP URL, you need to register it with your Claude client. Because Truto manages the state, routing, and JSON-RPC protocol handling, the URL is the only piece of configuration required. ### Method A: Via the Claude UI (Enterprise / Web) If you are using Claude's web interface (on compatible Pro or Enterprise plans): 1. Copy the MCP server URL you generated above. 2. In Claude, navigate to **Settings → Integrations → Add MCP Server**. 3. Paste the URL and click **Add**. Claude will immediately execute an `initialize` handshake and request the list of available tools. No additional environment variables or OAuth flows are needed on the client side. ### Method B: Via Manual Config File (Claude Desktop) If you are running Claude Desktop locally for development, you will configure it using the `claude_desktop_config.json` file. Because Truto provides an SSE (Server-Sent Events) endpoint, you will use the official MCP CLI tool to bridge the connection. Open your configuration file (usually located at `~/Library/Application Support/Claude/claude_desktop_config.json` on macOS) and append your new server: ```json { "mcpServers": { "peach-truto": { "command": "npx", "args": [ "-y", "@modelcontextprotocol/server-sse", "https://api.truto.one/mcp/YOUR_SECURE_TOKEN" ] } } } ``` Save the file and restart Claude Desktop. You will see a new hammer icon in your input bar indicating the tools are loaded and ready. ## Security and Access Control Giving an LLM access to your production fundraising data is risky. Truto provides four distinct security levers to constrain what the model can do at the protocol level: * **Method Filtering:** Configure `config.methods` with values like `["read"]` (allows only GET/LIST), `["write"]` (allows CREATE/UPDATE/DELETE), or exact strings like `["get", "custom"]`. The model cannot hallucinate a write operation if the server physically refuses to expose the tool. * **Tag Filtering:** Group tools by business logic. Set `config.tags` to `["campaigns"]` to expose analytics tools while hiding payment processing endpoints. * **Require API Token Auth:** By setting `require_api_token_auth: true`, possession of the MCP URL is no longer sufficient. The client must also inject a valid Truto API token in the Authorization header. This adds a secondary layer of identity verification. * **Ephemeral Servers:** Set an `expires_at` ISO datetime. Truto will automatically schedule a durable alarm to destroy the key-value entries when time is up, ensuring temporary access (e.g., for a contractor or a specific automated job) never becomes a stale security vulnerability. ## Peach Hero Tools for Claude Truto derives tools dynamically from the integration's resource schema. Here are the core hero tools you can expose to Claude for Peach automation. ### 1. Retrieve Campaign Statistics **Tool:** `peach_campaigns_get_stats` This tool retrieves detailed public statistics for a specific campaign, including total amounts raised, donation counts, and breakdowns per group. It is essential for daily reporting and performance audits. > "Claude, pull the stats for Peach campaign ID 84920 and summarize our progress toward the $50k goal. Highlight which donor group contributed the most volume." ### 2. Process a New Payment **Tool:** `create_a_peach_payment` Creates a new payment entry in Peach. It returns the created payment object, including `paymentId`, `status`, and `donationSum`. Note that if `isSubscription` is true, the LLM must provide `billingCycles`. > "A new donor, Sarah Jenkins (sarah.j@example.com), just agreed to a 12-month subscription of 500 ILS for the Annual Drive. Execute the payment creation in Peach and give me the new payment ID." ### 3. Modify an Existing Subscription **Tool:** `update_a_peach_payment_by_id` Allows the model to perform actions on existing payments, such as canceling a subscription, changing the charge day, or freezing an account. Requires the payment ID and the specific action string. > "Our donor with payment ID 'pay_90210' emailed support asking to pause their recurring donation for three months. Please update their payment record to freeze the subscription." ### 4. Provision a New Contact **Tool:** `create_a_peach_contact` Creates a new CRM contact record in Peach. Requires standard fields like `firstName`, `lastName`, and `email`. > "We just collected a lead form from a major networking event. Create a Peach contact for Michael Chang, email m.chang@enterprise.com, and confirm the generated contactId." ### 5. Search for a Donor **Tool:** `get_single_peach_contact_by_id` Retrieves a single contact using one of the accepted identifiers (ID, email, phone number, or timezone string). Useful for enriching data before executing a payment modification. > "Find the Peach contact record associated with the email 'j.doe@example.com' and tell me their internal contact ID so we can associate a new note to their profile." ### 6. Log a Contact Interaction **Tool:** `peach_interactions_create_note` Appends an interaction note to a contact's profile. Requires the `contactId` and the `noteBody`. Excellent for logging summaries of phone calls or emails directly into the donor CRM. > "Take the transcript from my last call with donor ID 5092, summarize the key takeaways regarding their estate planning, and log it as a new interaction note on their Peach profile." *Note: This is just a curated list of high-leverage operations. For the complete tool inventory, including detailed JSON Schemas and required properties, visit the [Peach integration page](https://truto.one/integrations/detail/peach).* ## Workflows in Action Exposing individual tools is useful, but the true power of Claude via MCP is chaining tools together to solve complex, multi-step problems autonomously. ### Scenario 1: Campaign Performance Audit and Outreach Prep Imagine an end-of-month workflow where a campaign manager needs to analyze a specific drive, identify a key donor, and prepare outreach. > "Claude, check the stats for Campaign ID 'camp_1029'. Then, find the donor with email 'v.smith@example.com', check their details, and draft an interaction note thanking them for their contribution to this specific campaign. Go ahead and post the note to their profile." **Execution Steps:** 1. Claude calls `peach_campaigns_get_stats` using the provided Campaign ID to grasp the current funding levels. 2. Claude calls `get_single_peach_contact_by_id` passing `email: v.smith@example.com` to resolve the internal `contactId`. 3. Claude generates a contextual thank-you note based on the campaign stats. 4. Claude calls `peach_interactions_create_note` using the resolved `contactId` to commit the record to Peach. ```mermaid sequenceDiagram participant User as User participant Claude as Claude participant MCP as Truto MCP Server User->>Claude: "Check stats for camp_1029..." Claude->>MCP: Call peach_campaigns_get_stats (camp_1029) MCP-->>Claude: Returns stats JSON Claude->>MCP: Call get_single_peach_contact_by_id (v.smith@example.com) MCP-->>Claude: Returns contactId: 8821 Claude->>MCP: Call peach_interactions_create_note (8821, "Thank you...") MCP-->>Claude: Returns success message Claude-->>User: "Note successfully added to V. Smith's profile." ``` ### Scenario 2: Processing Subscription Cancellations via Support Queue Customer support workflows often require parsing intent from an email and mapping it to a database action. > "Claude, I have a support ticket from donor ID 4410 asking to terminate their current active pledge due to financial hardship. Look up their recent transactions, identify their active recurring payment, and cancel it." **Execution Steps:** 1. Claude calls `list_all_peach_search_transactions` filtering for the specific donor to identify recent activity and extract the `paymentId` associated with the recurring pledge. 2. Claude calls `update_a_peach_payment_by_id` passing the identified `paymentId` and the `cancel` action string. 3. Claude reads the success response and formulates a human-readable confirmation for the support agent to send back to the donor. ```mermaid flowchart TD A["User Prompt:
Cancel active pledge for Donor 4410"] --> B["Claude evaluates request"] B --> C["Call list_all_peach_search_transactions"] C --> D["Identify active paymentId"] D --> E["Call update_a_peach_payment_by_id
Action: cancel"] E --> F["Truto MCP proxies request to Peach API"] F --> G["Return Success Status"] G --> H["Claude drafts confirmation email"] ``` ## Strategic Wrap-Up Connecting Claude to Peach requires more than just parsing JSON. You are navigating strict schema validations, polymorphic identifiers, and rate limit architectures. You can either spend engineering cycles building, securing, and maintaining custom REST wrappers for these endpoints, or you can leverage a managed infrastructure layer. By using Truto to generate a secure MCP server, you instantly expose documented Peach endpoints as high-quality AI tools. You retain total control over authentication and data scope via method and tag filtering, without writing integration code or managing stateful infrastructure. Stop writing custom tool wrappers for your LLMs. Let your integrations team focus on core product value, and let Truto handle the API translation layer. :::cta{buttonText="Talk to us" buttonUrl="https://cal.com/truto/partner-with-truto"} Ready to connect your AI agents to 100+ B2B APIs without the security and maintenance headaches? Book a technical deep dive with our engineering team today. :::