Connect Fiserv to ChatGPT: Manage Payments, Disputes, and Tokens

If you need to connect Fiserv to ChatGPT to automate payment reconciliations, manage chargeback disputes, or orchestrate financial adjustments, you need a Model Context Protocol (MCP) server. This infrastructure layer acts as a strict, schema-driven translator between ChatGPT's reasoning engine and Fiserv's highly specialized financial APIs.

If your team uses Claude, check out our guide on connecting Fiserv to Claude or explore our broader architectural overview on connecting Fiserv to AI Agents.

Giving a Large Language Model (LLM) read and write access to a core banking and payments platform is a massive engineering undertaking. You either spend months building, testing, and securing a custom MCP server to handle Fiserv's complex dispute state machines and OmniPay schemas, or you use a managed integration layer to generate it instantly.

This guide breaks down exactly how to use Truto to generate a secure, authenticated MCP server for Fiserv, connect it to ChatGPT via both UI and code, and execute complex FinOps workflows using natural language.

The Engineering Reality of the Fiserv API

A custom MCP server is essentially a self-hosted integration layer. While the open MCP standard provides a predictable way for models to discover tools, implementing it against Fiserv's vast and legacy-heavy API surface is exceptionally painful.

If you decide to build a custom MCP server for Fiserv, you own the entire API lifecycle. Here are the specific integration challenges that break standard REST assumptions when working with Fiserv:

The OmniPay Environment and Institution Routing

Fiserv's OmniPay Financial Adjustments API does not operate like a standard SaaS endpoint. It requires specific credential routing based on the target environment. If your API key covers more than one institution, every single dispute and adjustment API call must explicitly pass an Institution number. Furthermore, testing requires routing to specific CAT hosts. If you build a custom MCP server, you must write interceptors to dynamically inject these headers based on the current tenant context. If you miss this, your LLM will continuously fail with obscure routing errors.

State Machine Rigidity in Disputes and Adjustments

When an LLM attempts to undo an action (e.g., via create_a_fiserv_action_undo), Fiserv's API enforces strict timing windows. An undo is only allowed while the action has not yet been processed in the daily cycle. Similarly, adjustments can only be modified before "processing pickup" and only while their status is neither 'Released' nor 'Cancelled'. Your custom MCP server must implement pre-flight validation checks to prevent the LLM from attempting invalid state transitions, or you risk returning unhelpful stack traces back to the model.

Batch Thresholds and Payload Density

The OmniPay Financial Adjustments API allows submitting up to 1,000 adjustments in a single call. Large Language Models struggle to output 1,000 perfectly formatted nested JSON objects in a single response due to context window limits and token generation constraints. To make this work, your MCP server must handle chunking and aggregation on behalf of the LLM, breaking down conversational intents into manageable API requests.

Rate Limits and Headers

Fiserv enforces strict rate limits on payment queries and batch adjustments. It is important to note: Truto does not retry, throttle, or apply backoff on rate limit errors. When the upstream Fiserv API returns an HTTP 429 (Too Many Requests), Truto passes that exact error to the caller. Truto normalizes the upstream rate limit info into standardized headers (ratelimit-limit, ratelimit-remaining, ratelimit-reset) per the IETF specification. The caller (your MCP client or agent framework) is entirely responsible for implementing the retry and backoff logic. Do not build an MCP client expecting the server to absorb these errors.

Step 1: Generating the Fiserv MCP Server

Before ChatGPT can talk to Fiserv, we need to spin up an MCP server scoped to your specific Fiserv account. Truto allows you to generate this server dynamically. You can do this via the Dashboard UI or programmatically via the API.

Method 1: Via the Truto UI

If you are a FinOps manager or IT admin who prefers visual tools, generating the server takes about 30 seconds:

1. Log into your Truto dashboard and navigate to the Integrated Accounts page.
2. Click on your connected Fiserv account.
3. Click the MCP Servers tab.
4. Click Create MCP Server.
5. Select your desired configuration. For example, if you are building an agent strictly for investigating chargebacks, select the read method filter and tag filters for disputes.
6. Click Save and copy the generated MCP server URL (it will look like https://api.truto.one/mcp/<token>). Treat this URL as a sensitive credential.

Method 2: Via the Truto API

If you are an engineer provisioning agent infrastructure programmatically, you can generate the MCP server via a single POST request. You will need your Truto API key and the integrated_account_id for the Fiserv connection.

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": "Fiserv Dispute Agent Server",
    "config": {
      "methods": ["read", "write", "custom"],
      "tags": ["payments", "disputes", "tokens"]
    },
    "expires_at": "2026-12-31T23:59:59Z"
  }'

The Response: The API returns a payload containing the url. This URL encodes the integrated account, the tool filters, and the cryptographic signature.

{
  "id": "mcp_abc123",
  "name": "Fiserv Dispute Agent Server",
  "url": "https://api.truto.one/mcp/a1b2c3d4e5f6g7h8...",
  "expires_at": "2026-12-31T23:59:59Z"
}

Step 2: Connecting the MCP Server to ChatGPT

Now that you have your secure MCP endpoint, you need to register it with your ChatGPT environment. You can do this using ChatGPT's UI for custom connectors, or manually via a configuration file if you are running a local agentic setup.

Method A: Via the ChatGPT UI

If you are using ChatGPT Pro, Plus, Business, Enterprise, or Education, you can add custom connectors directly in the browser.

1. Open ChatGPT and click your profile picture in the bottom left.
2. Navigate to Settings -> Apps -> Advanced settings.
3. Ensure Developer mode is enabled.
4. Under the MCP servers or Custom Connectors section, click Add new server.
5. Give it a name (e.g., "Fiserv Truto Connector").
6. Paste the https://api.truto.one/mcp/<token> URL you generated in Step 1.
7. Click Save. ChatGPT will immediately handshake with the server and discover the Fiserv tools you authorized.

Method B: Via Manual Config File (SSE Transport)

If you are integrating this into a local developer environment, an orchestration framework, or a custom desktop client that relies on JSON configuration files (similar to Claude Desktop), you can connect to Truto's MCP server using Server-Sent Events (SSE).

Since Truto hosts the endpoint securely, you use the official @modelcontextprotocol/server-sse package as the transport wrapper.

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

Once the framework boots, it uses this configuration to negotiate the JSON-RPC 2.0 handshake, pulling down the schemas for the Fiserv endpoints.

Hero Tools for Fiserv

Truto exposes a comprehensive suite of proxy APIs for Fiserv. However, when building an agent, you want to focus on high-leverage operations. Here are the hero tools that turn a basic chatbot into a functional FinOps assistant.

Get Single Fiserv Payment by ID

Retrieves the current state of an existing payment transaction. This is the foundational tool for any payment investigation. It returns granular details including ipgTransactionId, transactionStatus, approvalCode, and paymentMethodDetails.

Contextual usage: LLMs should use this tool first when a user provides an order ID or payment ID to establish the current state before attempting any voids, refunds, or adjustments.

"Check the status of payment ID PAY-8849. Is it fully captured, and what was the approval code?"

Fiserv Payments Void

Performs a secondary transaction, specifically a void or reversal, against an existing payment. This immediately halts funds movement if the daily clearing cycle hasn't occurred.

Contextual usage: This tool requires the payment_id and the specific requestType for the void. The agent must ensure the transaction state is eligible for a void (e.g., not yet settled) before executing.

"The customer for payment PAY-8849 reported suspected fraud. Please void this transaction immediately to prevent settlement."

Create a Fiserv Payment Token

Tokenizes a payment card, payment device, or referenced order to securely store sensitive card details for future billing, returning a paymentToken without exposing the raw PAN to the LLM.

Contextual usage: Use this when setting up recurring billing profiles or migrating card-on-file data. The LLM handles the orchestration, while Fiserv securely vaults the data and returns the alias.

"Take the raw card details provided in the secure intake form and create a Fiserv payment token. Return the token ID so I can link it to the customer profile."

Get Single Fiserv Dispute by ID

Retrieves the full, comprehensive record of a chargeback or dispute. This includes the stageCode, reasonCode, financial amounts, related transactions, and associated documents.

Contextual usage: Essential for chargeback analysts. If the API key covers multiple institutions, the agent must ensure it passes the correct Institution number in the request body or parameters.

"Pull the complete file for dispute DSP-9921. What is the current stage code, and what is the acquirer reference number?"

Create a Fiserv Post Adjustment

Submits financial adjustments to merchant accounts via the OmniPay system, applied as part of the merchant payment or collection cycle.

Contextual usage: Highly complex operation. It requires the Institution number and OmniPay environment credential fields. Test keys automatically route to the CAT host. The agent can submit up to 1,000 adjustments in a single array.

"Create a financial post adjustment of -$50.00 for merchant ID MCH-441 to refund the late fee applied yesterday. Route this through the CAT host environment for testing."

Create a Fiserv Dispute Note

Appends a structured text note to an active dispute case. Notes are immutable once added. It returns the tcn, createdBy, and timestamp.

Contextual usage: Used to log investigation steps. The agent should summarize its findings and attach the summary to the dispute record so human analysts have a clear audit trail of the AI's actions.

"Add a note to dispute DSP-9921 stating: 'Reviewed tracking information; delivery was confirmed on Tuesday. Compiling evidence for representation.'"

To view the complete inventory of available endpoints, JSON schema definitions, and required parameters, visit the Fiserv integration page.

Workflows in Action

Connecting tools is only half the battle. Here is how specialized AI agents use these tools sequentially to solve real-world FinOps problems.

1. The Autonomous Chargeback Investigator

Managing disputes manually requires jumping between payment gateways, CRM records, and dispute dashboards. An AI agent can handle the data gathering autonomously.

"Investigate dispute DSP-5542. Tell me the reason code, verify the original payment status, and leave a note on the dispute indicating the investigation has started."

1. The agent calls get_single_fiserv_dispute_by_id using the ID DSP-5542 to retrieve the reasonCode, amount, and originalPayment reference.
2. The agent takes the original payment reference and calls get_single_fiserv_payment_by_id to confirm the transaction was successfully processed and identify the AVS/CVV match results.
3. The agent calls create_a_fiserv_dispute_note with the ID DSP-5542 to append an internal note summarizing the AVS match, signaling to the human team that compelling evidence likely exists.

sequenceDiagram
    participant User
    participant Agent as ChatGPT
    participant Truto as Truto MCP Server
    participant Fiserv as Fiserv API

    User->>Agent: "Investigate dispute DSP-5542..."
    Agent->>Truto: Call get_single_fiserv_dispute_by_id
    Truto->>Fiserv: GET /disputes/DSP-5542
    Fiserv-->>Truto: Returns reasonCode & transaction ID
    Truto-->>Agent: Dispute data
    Agent->>Truto: Call get_single_fiserv_payment_by_id
    Truto->>Fiserv: GET /payments/PAY-112
    Fiserv-->>Truto: Returns AVS match status
    Truto-->>Agent: Payment data
    Agent->>Truto: Call create_a_fiserv_dispute_note
    Truto->>Fiserv: POST /disputes/DSP-5542/notes
    Fiserv-->>Truto: Note created (HTTP 204)
    Truto-->>Agent: Success confirmation
    Agent-->>User: "Investigation complete. Note added regarding positive AVS match."

2. The OmniPay Adjustments Orchestrator

Treasury and accounting teams frequently need to adjust merchant payouts due to fee changes or contract renegotiations.

"We need to process a fee rebate for merchant MCH-883. Pull their staged adjustments, and if there are no pending holds, create a new post adjustment of $120.00."

1. The agent calls list_all_fiserv_get_adjustments_stageds filtering for merchantId: MCH-883.
2. It reviews the JSON response. Seeing no holds, it structures a payload for the new adjustment.
3. The agent calls create_a_fiserv_post_adjustment, explicitly passing the Institution number and OmniPay environment variables, generating the $120.00 rebate. It returns the adjustmentSlipNumber to the user.

3. Payment Tokenization and Void Ops

Payment operations teams often deal with customers who want to cancel a transaction immediately after placing an order and vault their card for a different purchase later.

"Void the recent payment PAY-7721, and tokenize the card on file for that order so we can use it for their subscription tomorrow."

1. The agent calls get_single_fiserv_payment_by_id for PAY-7721 to verify it is still in a pre-settlement state.
2. The agent calls fiserv_payments_void passing the payment_id and the requestType for a void.
3. Upon successful void, the agent extracts the order reference and calls create_a_fiserv_payment_token referencing the order. It returns the secure paymentToken to the user.

Security and Access Control

Giving an LLM access to your core payment infrastructure requires strict boundaries. Truto's MCP architecture enforces security at the protocol level before the request ever reaches Fiserv:

• Method Filtering: When generating the server, configure config.methods: ["read"]. This hard-codes the server to only allow GET and LIST requests. Even if ChatGPT hallucinates a request to create_a_fiserv_post_adjustment, the MCP server will reject it immediately.
• Tag Filtering: Restrict the agent's domain by specifying config.tags: ["disputes"]. The server will dynamically prune all tools related to payments, tokens, or adjustments, ensuring the agent only "knows" about chargeback endpoints.
• API Token Enforcement: By enabling require_api_token_auth: true, possession of the MCP URL is no longer enough. The client must also pass a valid Truto API token in the Authorization header, preventing lateral movement if the URL leaks in logs.
• Time-to-Live (TTL): Set expires_at for contractor access. Truto relies on cloud infrastructure primitives to automatically purge the token from edge memory and database records the second the timestamp passes.

Moving Past Boilerplate Integrations

Integrating Fiserv into an AI agent shouldn't require your engineering team to spend weeks studying the OmniPay specification, managing OAuth lifecycles, or building rate-limit handling architectures.

By leveraging Truto's dynamic MCP server generation, you abstract away the API layer entirely. Your developers can focus on writing complex agentic workflows in LangChain or directly in ChatGPT, while the managed infrastructure handles authentication, schema parsing, and protocol negotiation.