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. 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 or explore our broader architectural overview on connecting Plastiq to AI Agents.

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 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.

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:

{
  "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):

{
  "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.

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.

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 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.