---
title: "Connect Plastiq to Claude: Streamline Recipient and Payment Setup via MCP"
slug: connect-plastiq-to-claude-streamline-recipient-and-payment-setup
date: 2026-06-19
author: Uday Gajavalli
categories: ["AI & Agents"]
excerpt: Learn how to build a secure Plastiq MCP server to connect your payment infrastructure natively to Claude. Automate vendor onboarding and payment intents.
tldr: "Connect Plastiq to Claude using Truto's dynamically generated MCP servers. This guide covers API quirks, rate limits, schema derivation, and hands-on tool execution for B2B payment workflows."
canonical: https://truto.one/blog/connect-plastiq-to-claude-streamline-recipient-and-payment-setup/
---

# Connect Plastiq to Claude: Streamline Recipient and Payment Setup via MCP


If you need to connect Plastiq to Claude to automate vendor onboarding, Accounts Payable (AP) workflows, or bulk payment distribution, you need a [Model Context Protocol (MCP) server](https://truto.one/what-is-mcp-model-context-protocol-the-2026-guide-for-saas-pms/). This infrastructure layer translates Claude's natural language tool calls into exactly formatted REST API requests against Plastiq's highly structured endpoints. You can either spend weeks building and maintaining this middleware 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 Plastiq to ChatGPT](https://truto.one/connect-plastiq-to-chatgpt-manage-payers-billers-and-payments/) or explore our broader architectural overview on [connecting Plastiq to AI Agents](https://truto.one/connect-plastiq-to-ai-agents-orchestrate-end-to-end-b2b-payments/).

Giving a Large Language Model (LLM) read and write access to a sensitive B2B payments API is an engineering challenge. You have to handle token lifecycles, inject explicit schema definitions to prevent hallucinated financial payloads, and enforce strict state machines. Every time an endpoint shifts or a schema updates, your integration code must adapt. This guide breaks down exactly how to use Truto to generate a [managed MCP server](https://truto.one/managed-mcp-for-claude-full-saas-api-access-without-security-headaches/) for Plastiq, connect it natively to Claude, and execute complex AP workflows using natural language.

## The Engineering Reality of the Plastiq 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 over JSON-RPC 2.0, the reality of implementing it against a payments provider like Plastiq is highly complex. 

If you decide to build a custom MCP server for Plastiq from scratch, you own the entire API lifecycle. Here are the specific challenges you will face when translating Plastiq's architecture for LLM consumption:

**The Payer-Scoped Entity Model**
In Plastiq, almost everything - recipients, payment methods, payment intents, and actual executions - is tightly scoped to a specific Payer ID. If you expose the raw Plastiq endpoints to Claude without strict schema guidance, the LLM will frequently attempt to create recipients or stage payments without defining the payer context, resulting in instant HTTP 400 validation errors. A managed MCP server enforces this mapping, strictly requiring `payerId` in the schema constraints so Claude knows exactly what context is missing before it fires the request.

**Polymorphic Receiving Methods**
Vendor onboarding is notoriously difficult for LLMs to format. Plastiq's Recipient object requires a `receivingMethod` payload that changes entirely based on the type. An ACH transfer requires routing and account numbers, while a Wire transfer requires SWIFT codes, and physical checks require structured mailing addresses. Truto's MCP generation derives tools directly from documentation records, exposing these polymorphic structures as heavily typed JSON Schemas so the model understands exactly what shape the `receivingMethod` should take for a given payout type.

**Strict Rate Limits and Normalization**
Plastiq enforces strict rate limits to prevent abuse on payment endpoints. If your AI agent gets stuck in a loop attempting to bulk-onboard recipients, it will hit quotas. **Factual note on rate limits:** Truto does not retry, throttle, or apply backoff on rate limit errors. When the upstream Plastiq API 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 framework) is fully responsible for reading these standardized headers and implementing the appropriate retry or backoff strategy.

**Two-Phase Payment State Machines**
Plastiq separates the staging of a payment (`payment_intent`) from the actual execution (`payment`). LLMs struggle with implicit state machines. By exposing explicit tools for `create_a_plastiq_payment_intent` and `create_a_plastiq_payment` with clear descriptions, the MCP server guides the model to stage the transaction, validate the fees and delivery dates, and then execute it in a deterministic sequence.

## How to Generate a Plastiq MCP Server with Truto

Truto dynamically generates MCP tools based on Plastiq's resource definitions and schema documentation. Rather than hand-coding tool logic, the server derives the required parameters, flattens the input namespace (merging query parameters and body payloads), and injects standard pagination instructions automatically.

Each server is bound to a single connected Plastiq account and secured via a cryptographic token. You can generate this server via the Truto UI or programmatically via the API.

### Method 1: Via the Truto UI

If you are setting up an internal tool or testing a quick Claude deployment, the UI is the fastest path.

1. Navigate to the **Integrated Accounts** page in your Truto dashboard and select your connected Plastiq account.
2. Click the **MCP Servers** tab.
3. Click **Create MCP Server**.
4. Configure the server parameters. You can name it (e.g., "Plastiq AP Operations"), apply method filters (e.g., allow `read` and `write` but restrict custom methods), or set an explicit expiration date.
5. Click Save, and immediately copy the generated MCP server URL. The token is hashed upon creation, so the raw URL will not be visible again.

### Method 2: Via the Truto API

For production workflows, you should generate MCP servers programmatically. This allows you to dynamically spin up short-lived servers tailored to specific automation tasks.

Send a POST request to `/integrated-account/:id/mcp` with your desired configuration. The API validates that the Plastiq integration is documented and AI-ready, hashes the token into edge storage, and returns the endpoint.

```bash
curl -X POST https://api.truto.one/integrated-account/YOUR_PLASTIQ_ACCOUNT_ID/mcp \
  -H "Authorization: Bearer YOUR_TRUTO_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Plastiq Vendor Onboarding Automation",
    "config": {
      "methods": ["read", "write"],
      "require_api_token_auth": false
    },
    "expires_at": "2026-12-31T23:59:59Z"
  }'
```

The response returns a secure URL containing the token:

```json
{
  "id": "mcp_abc123",
  "name": "Plastiq Vendor Onboarding Automation",
  "config": { "methods": ["read", "write"] },
  "expires_at": "2026-12-31T23:59:59.000Z",
  "url": "https://api.truto.one/mcp/tkn_987654321abcdef"
}
```

## Connecting the Plastiq MCP Server to Claude

Once you have the `url` from the steps above, you connect it to your Claude environment. Since the Truto MCP server is a fully self-contained JSON-RPC 2.0 endpoint, the client only needs the URL to negotiate the handshake and discover the Plastiq tools.

### Method A: Via the Claude UI

If you are using Claude Desktop or an enterprise workspace that supports UI configuration:

1. Open Claude and navigate to **Settings**.
2. Go to **Integrations** (or Connectors/Custom Connectors depending on your tier).
3. Click **Add MCP Server**.
4. Paste the Truto MCP URL (`https://api.truto.one/mcp/tkn_...`).
5. Click **Add**.

Claude will instantly send an `initialize` request to the server, parse the returned capabilities, and load the Plastiq tools into its context window.

### Method B: Via Manual Config File

If you are orchestrating Claude Desktop locally or configuring a custom agent framework, you will update the `claude_desktop_config.json` file. Because the Truto MCP endpoint is an HTTP endpoint, you use a Server-Sent Events (SSE) transport adapter to bridge the local client to the remote server.

Edit your configuration file (typically located at `~/Library/Application Support/Claude/claude_desktop_config.json` on macOS):

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

Restart Claude Desktop. The model now has direct access to the Plastiq API via your mapped integration.

## Hero Tools for Plastiq Workflows

Truto automatically generates descriptive, snake_case tools from the underlying Plastiq endpoints. The flat input namespace design means Claude can pass both query parameters (like `payerId`) and request body fields (like `receivingMethod`) in a single intuitive JSON payload, which the server automatically splits and routes.

Here are the highest-leverage tools for automating Plastiq workflows:

### 1. `create_a_plastiq_payer`

This tool establishes the root entity in Plastiq. Almost all subsequent operations require a Payer ID. It requires basic business details and contact information (email or phone).

> "We need to set up a new payer account for Acme Corp. Use contact email billing@acmecorp.com and save the resulting payer ID so we can use it for vendor onboarding."

### 2. `create_a_plastiq_recipient`

Automates vendor onboarding for ACH, Check, or Wire disbursements. Claude must supply the `contact` object and a `receivingMethod` object tailored to the payout type. Providing the `payer.id` explicitly scopes this recipient to your organization.

> "Onboard Global Suppliers LLC as a new recipient for Payer ID 12345. They requested ACH payments, so use routing number 123456789 and account 987654321. Return their new recipient ID."

### 3. `create_a_plastiq_payment_intent`

Stages a transaction without executing it. This returns the projected fees, delivery dates, and potential warnings. It requires a `paymentMethod`, a `recipient`, and the `payer` context.

> "Stage a payment intent for $15,000 to recipient ID 999 using payment method card_123 for Payer ID 12345. Tell me what the total fees will be and the expected delivery date before we proceed."

### 4. `create_a_plastiq_payment`

Executes a staged transaction or processes an inline payment. If executing a staged transaction, Claude simply passes the `paymentIntent.id`. 

> "The fees on the payment intent look good. Execute the payment using intent ID int_555 and confirm the final status."

### 5. `list_all_plastiq_payments`

Retrieves payment history for a specific payer. Truto automatically injects `limit` and `next_cursor` schema properties, instructing Claude to pass cursor values back unchanged to navigate large paginated lists.

> "Pull the last 50 payments for Payer ID 12345. Cross-reference them to find any payments currently marked as FAILED or PENDING, and summarize the failure reasons."

### 6. `list_all_plastiq_webhooks`

Audits system events and notifications. This is critical for investigating missed callbacks or tracing exact state changes on payment deliveries over a specific date range.

> "Fetch the webhook notifications from the past 7 days and look for any 'payment.failed' events. Extract the payment IDs involved."

To view the complete inventory of available Plastiq tools, schemas, and resource definitions, visit the [Plastiq Integration Page](https://truto.one/integrations/detail/plastiq).

## Workflows in Action

When you combine Claude's reasoning capabilities with the deterministic execution of the Truto MCP server, you can orchestrate complex AP pipelines that historically required dedicated UI dashboards or heavy internal tooling.

### Scenario 1: Autonomous Vendor Onboarding and Payment Staging

An AP manager needs to onboard a new software vendor and immediately queue up their annual invoice. Instead of clicking through a portal, they prompt their AI assistant.

> "Set up CloudTech Infrastructure as a new recipient for our primary Payer ID 8888. They require US Wire transfers - their routing number is 021000021 and account is 555555. Once they are set up, stage a $24,000 payment intent to them using our default corporate card. Do not execute it, just give me the intent ID and fee breakdown for approval."

**Execution Steps:**
1. Claude calls `create_a_plastiq_recipient`, correctly structuring the `receivingMethod` for a Wire transfer based on the schema, and binding it to Payer ID 8888.
2. The MCP server returns the new `recipient.id`.
3. Claude calls `create_a_plastiq_payment_intent`, combining the new recipient ID, the predefined Payer ID, and the card ID.
4. The server returns the intent object. Claude parses the `fees` and `deliveryDate` arrays, presenting a clean summary to the user for final sign-off.

```mermaid
sequenceDiagram
    participant User
    participant Claude as Claude Desktop
    participant MCP as Truto MCP Server
    participant Plastiq as Plastiq API
    
    User->>Claude: "Onboard CloudTech & stage $24k payment..."
    Claude->>MCP: Call tool: create_a_plastiq_recipient<br>{"payer": {"id": "8888"}, "contact": {...}}
    MCP->>Plastiq: POST /recipients
    Plastiq-->>MCP: Returns { id: "rec_123", status: "ACTIVE" }
    MCP-->>Claude: JSON Tool Response
    Claude->>MCP: Call tool: create_a_plastiq_payment_intent<br>{"targetAmount": 24000, "recipient": {"id": "rec_123"}}
    MCP->>Plastiq: POST /payment-intents
    Plastiq-->>MCP: Returns { id: "int_999", fees: [...] }
    MCP-->>Claude: JSON Tool Response
    Claude-->>User: "Recipient created. Intent int_999 staged. Fees are $600."
```

### Scenario 2: End-of-Month AP Reconciliation

A finance controller needs to quickly audit the month's disbursements to ensure no payments are stuck in transit.

> "List all payments for Payer ID 8888. Paginate through the results until you find any payments where the status is not 'DELIVERED'. Give me a markdown table of the exceptions, their target amounts, and the expected delivery date."

**Execution Steps:**
1. Claude calls `list_all_plastiq_payments` with `payerId: 8888` and `limit: 50`.
2. The MCP server delegates the request to Truto's proxy API, handling the authentication natively.
3. Claude inspects the returned JSON. If `next_cursor` is present and it hasn't found enough exceptions, it calls the tool again, passing the cursor exactly as instructed by the auto-generated schema description.
4. Claude filters the returned arrays in memory, looking for `status: PENDING` or `status: CANCELLED`, and formats the final markdown table for the controller.

## Security and Access Control

Exposing financial operations to an LLM requires strict governance. Truto's [security-first MCP architecture](https://truto.one/zero-data-retention-mcp-servers-building-soc-2-gdpr-compliant-ai-agents/) provides several layers of access control, configured when the server is created:

*   **Method Filtering:** You can strictly limit the MCP server to read-only operations. Setting `config.methods: ["read"]` ensures the server will only generate tools like `list_all_plastiq_payments` and `get_single_plastiq_recipient_by_id`, physically preventing Claude from ever executing a payment or writing data.
*   **Tag Filtering:** Limit the server to specific functional areas. By filtering on tags, you can expose only webhook monitoring tools without exposing core payment execution endpoints.
*   **Double Authentication (`require_api_token_auth`):** By default, possessing the MCP URL grants access to the tools. Setting `require_api_token_auth: true` forces the connecting client to also supply a valid Truto API token via an Authorization header. This guarantees that even if the URL leaks, it remains useless without developer credentials.
*   **Ephemeral Environments (`expires_at`):** Truto stores token metadata in distributed edge key-value storage. If you assign an `expires_at` datetime, the system schedules a durable cleanup alarm. Once the TTL hits, the token is automatically wiped from edge storage and the database, instantly revoking Claude's access.

## Wrap-Up

Connecting Plastiq to Claude via a managed MCP server removes the heavy lifting of API maintenance. You don't have to write custom parsers for polymorphic routing numbers, maintain OAuth credentials, or manually translate Plastiq's pagination cursors for an LLM. By relying on dynamically generated, schema-driven tools, you give your AI agents the precise context they need to orchestrate complex vendor payments safely and deterministically. Learn more about the [ROI of managed MCP here](https://truto.one/truto-mcp-pricing-roi-guide-the-true-cost-of-agent-workloads/).

> Stop maintaining custom API layers. Generate secure MCP servers for Plastiq and 100+ other B2B platforms in seconds.
>
> [Talk to us](https://cal.com/truto/partner-with-truto)