Connect Dwolla to Claude: Automate Mass Payments & Funding Sources

If you need to connect Dwolla to Claude to automate mass payouts, audit business verification statuses, or manage customer funding sources, you need a Model Context Protocol (MCP) server. This server acts as the translation layer between Claude's tool calls and Dwolla's REST API. You can either build 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 connecting Dwolla to ChatGPT or explore our broader architectural overview on connecting Dwolla to AI Agents.

Giving a Large Language Model (LLM) read and write access to a sensitive payment infrastructure like Dwolla is a massive engineering challenge. You have to handle API authentication lifecycles, map strictly nested JSON schemas to MCP tool definitions, and deal with Dwolla's specific rate limits and correlation IDs. Every time your workflow 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 Dwolla, connect it natively to Claude, and execute complex financial workflows using natural language.

The Engineering Reality of the Dwolla 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 Dwolla's API is painful. Dwolla is a highly opinionated API, designed for precision over developer ergonomics.

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

HAL+JSON and Strict Link Mapping Dwolla relies heavily on Hypertext Application Language (HAL). Resources rarely accept raw strings for relationships. Instead, they require strictly formatted _links objects. When initiating a transfer, you do not just pass source_id and destination_id. You must pass _links.source.href and _links.destination.href pointing to the exact funding source URIs. Exposing this raw requirement to Claude often results in the model hallucinating link structures or stripping the base URL. A managed MCP server flattens and translates these requirements so the model can pass standard arguments.

Complex Verification State Machines Creating a customer in Dwolla is not a single CRUD operation if they need to send funds. You have "unverified", "personal verified", "business verified", and "receive-only" customers. Business verification requires stepping through beneficial ownership creation, certifying that ownership, and potentially uploading identity documents via multipart form-data. Getting an LLM to navigate these distinct validation paths from scratch requires massive schema context.

Rate Limits and 429 Errors Dwolla enforces strict rate limits on its endpoints. It is important to note: Truto does not retry, throttle, or apply backoff on rate limit errors automatically. When Dwolla returns an HTTP 429, 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 spec. The caller (your agent or Claude) is responsible for reading these headers and executing the retry or exponential backoff.

Instead of building this routing and translation layer from scratch, you can use Truto. Truto normalizes authentication and schema translation, exposing Dwolla's endpoints as ready-to-use MCP tools.

How to Generate a Dwolla MCP Server with Truto

Truto dynamically generates MCP tools from an integration's underlying resources and documentation. When you connect a Dwolla instance to Truto, you can spawn an MCP server scoped specifically to that tenant.

You can create the MCP server in two ways: via the Truto UI or programmatically via the API.

Method 1: Via the Truto UI

If you are setting this up manually for an internal Claude instance:

1. Log into your Truto dashboard and navigate to the Integrated Accounts page for your Dwolla connection.
2. Click the MCP Servers tab.
3. Click Create MCP Server.
4. Configure the server (give it a name, select allowed methods like read or write, and set an optional expiration date).
5. Copy the generated MCP server URL. It will look like https://api.truto.one/mcp/a1b2c3d4...

Method 2: Via the Truto API

If you are dynamically provisioning workspaces for your users, you should generate the MCP server programmatically. Make a POST request to the /integrated-account/:id/mcp endpoint.

curl -X POST https://api.truto.one/api/integrated-account/YOUR_ACCOUNT_ID/mcp \
  -H "Authorization: Bearer YOUR_TRUTO_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Dwolla Payouts MCP",
    "config": {
      "methods": ["read", "write", "custom"]
    }
  }'

The API returns a secure, hashed token URL. This URL contains all the context needed to authenticate requests against that specific Dwolla account.

{
  "id": "mcp-789",
  "name": "Dwolla Payouts MCP",
  "url": "https://api.truto.one/mcp/f8e9d0c1b2a3...",
  "expires_at": null
}

Connecting the MCP Server to Claude

Once you have the Truto MCP URL, connecting it to Claude is straightforward. You can connect it via the desktop application UI or by modifying Claude's configuration file.

Method A: Via the Claude UI

Anthropic and OpenAI both support adding MCP connectors directly from their settings panels.

• For Claude Desktop/Web: Go to Settings -> Integrations (or Connectors) -> Add MCP Server. Paste your Truto MCP URL and click Add.
• For ChatGPT: Go to Settings -> Connectors -> Add. Paste the URL and click Add.

Method B: Via the Configuration File

If you are running Claude Desktop and prefer to configure tools locally, you can edit the claude_desktop_config.json file. Because Truto provides a Server-Sent Events (SSE) endpoint, you use the standard @modelcontextprotocol/server-sse transport.

Open your config file (typically located at ~/Library/Application Support/Claude/claude_desktop_config.json on macOS) and add the following:

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

Restart Claude Desktop. The application will handshake with the Truto endpoint, pull the available Dwolla schemas, and register them as native tools.

Dwolla Hero Tools for AI Agents

Truto exposes Dwolla's complete REST API, but a few high-leverage tools drive the majority of automated financial workflows. Here are the core tools your agent will use.

Create a Mass Payment

create_a_dwolla_mass_payment

Dwolla's mass payment endpoint allows you to send up to 5,000 individual payments in a single API call. This tool is critical for contractor payouts, marketplace vendor settlements, and gig worker disbursements. Claude can structure the massive items array automatically.

"I have a CSV of 120 contractor payments. Use the master Dwolla balance funding source and create a mass payment batch for these transfers. Flag any failed validations immediately."

Create a Transfer

create_a_dwolla_transfer

The standard transfer endpoint. Initiates a transfer between two funding sources. Supports standard ACH, Instant Payments (RTP/FedNow), Push-to-Debit Card, and wire transfers. Claude can pass optional metadata like tracking IDs or expedited clearing flags.

"Transfer $450.00 from our main operational bank account to the customer funding source associated with user ID 8f7e6d. Add a metadata tag of 'Invoice-992' to the transaction."

List All Customers

list_all_dwolla_customers

Retrieves and searches Dwolla customers. This tool supports fuzzy search across customer names, business names, and email addresses. It is usually the first step Claude takes to find a user's internal Dwolla ID before retrieving their funding sources.

"Search our Dwolla directory for a customer with the email 'alex@example.com'. If they exist, check if their verification status is fully approved."

Create a Customer Funding Source

create_a_dwolla_customer_funding_source

Attaches a bank account or debit card to a specific Dwolla customer. This tool supports manual routing/account entry as well as open banking tokens (via Plaid or MX). Claude can map user-provided banking info into the required schema.

"Add this new checking account (Routing: 123456789, Account: 987654321) as a funding source for customer ID 4a5b6c. Name the funding source 'Primary Chase Checking'."

Create a Beneficial Owner

create_a_dwolla_beneficial_owner

For B2B workflows, businesses must certify beneficial owners (individuals owning 25% or more of the equity). This tool allows Claude to input personal information, addresses, and SSNs to satisfy KYC requirements on the fly.

"We just onboarded Acme Corp. Create a beneficial owner record for their CEO, Jane Doe, using the address and SSN details I just provided in the chat."

Create a Webhook Subscription

create_a_dwolla_webhook_subscription

Creates a subscription to Dwolla's event system. This allows your broader system to listen for customer_verified or transfer_completed events. Claude can configure endpoints dynamically for new staging environments.

"Set up a new webhook subscription pointing to 'https://api.ourdomain.com/webhooks/dwolla'."

To view the complete schema definitions and the full list of available operations, refer to the Dwolla integration page.

Workflows in Action

When Claude is equipped with Dwolla MCP tools, you can string together multi-step financial operations using simple prompts.

Scenario 1: Executing a Friday Mass Payout Run

Gig economy platforms often process hundreds of payments at the end of the week. Instead of building a custom dashboard for your finance team, they can orchestrate the payout run via Claude.

"I need to run Friday payouts for our 5 regional managers. Their emails are on this list, and each should receive $1,250.00. Find their Dwolla IDs, locate their primary funding source, and create a single mass payment batch from our master account."

How the agent executes this:

1. Calls list_all_dwolla_customers with the provided emails to extract the Dwolla id for each manager.
2. Calls list_all_dwolla_customer_funding_sources for each manager, filtering for the source marked as primary or verified.
3. Calls list_all_dwolla_accounts to fetch the platform's master account ID and master funding source ID.
4. Calls create_a_dwolla_mass_payment, passing the master funding source in the _links.source block and constructing an items array with the 5 destination funding sources and amounts.

Result: Claude returns a confirmation containing the Mass Payment URL and ID. The finance team executed a complex batch transfer without writing a script or navigating the Dwolla dashboard.

Scenario 2: Auditing Business Verification Status

B2B onboarding requires strict KYC compliance. If an enterprise customer complains they cannot send funds, your support team can use Claude to instantly diagnose the compliance bottleneck.

"Check the verification status for 'Globex Corporation'. If they are not fully verified, tell me what is missing - check their beneficial owners and any failed identity documents."

How the agent executes this:

1. Calls list_all_dwolla_customers using the fuzzy search for "Globex Corporation" and checks the status field.
2. If the status is document, calls list_all_dwolla_customer_documents to see if a passport or license upload was rejected (and reads the failure reason).
3. Calls list_all_dwolla_beneficial_ownership to check if ownership has been certified.
4. Calls list_all_dwolla_customer_beneficial_owners to verify if individual owners are stuck in an incomplete state.

Result: Claude synthesizes the nested API calls and replies: "Globex Corporation is currently stuck in the 'document' status. Their beneficial owner, John Smith, had his driver's license upload rejected because the image was too blurry. They need to re-upload a clear ID via the portal."

Security and Access Control

Giving an LLM access to your payment infrastructure requires extreme caution. Truto MCP servers include built-in security primitives to restrict what an agent can do.

• Method Filtering: Use config.methods: ["read"] when creating the MCP server to ensure Claude can only query customer data and transfer statuses, actively preventing it from initiating transfers or altering KYC data.
• Tag Filtering: Restrict access to specific functional areas using tags. You can limit a server to only expose tools related to webhooks or funding_sources.
• Additional Authentication: Enable require_api_token_auth: true to force the 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 Dwolla - the user must also be authenticated in your system.
• Ephemeral Servers: Set an expires_at timestamp to create short-lived MCP servers. This is perfect for giving an external auditor or contractor 24-hour read access to your Dwolla logs.

Architecting AI Payments with Truto

Building an AI agent that can reliably automate Dwolla mass payments and navigate complex KYC state machines requires more than just API access. It requires pristine, LLM-optimized schemas, pagination normalization, and standardized rate limit handling.

Instead of wasting engineering cycles manually translating Dwolla's HAL+JSON payloads into Claude tool definitions, Truto handles the heavy lifting. You get a production-ready, secure MCP server that your AI agents can consume immediately.