Connect DingConnect to ChatGPT: Automate Global Top-Ups & Bill Pay

If you need to connect DingConnect to ChatGPT to automate global mobile top-ups, process international bill payments, or audit agent balances, you need a Model Context Protocol (MCP) server. This server acts as the translation layer between ChatGPT's tool calls and DingConnect's telecom and fintech APIs. You can either spend weeks building, hosting, and maintaining this complex integration layer yourself, or use a managed infrastructure platform like Truto to dynamically generate a secure, authenticated MCP server URL.

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

Giving a Large Language Model (LLM) financial write access to a global telecom distribution network is an engineering challenge. You have to handle highly specific pricing estimation math, asynchronous transfer timeouts, strict rate limits, and dynamic product catalog lookups based on international dialing codes. Every time you need a new operation, a custom MCP server forces you to write and maintain boilerplate JSON-RPC handlers.

This guide breaks down exactly how to use Truto to generate a secure, managed MCP server for DingConnect, connect it natively to ChatGPT, and execute complex cross-border value transfers using natural language.

The Engineering Reality of the DingConnect API

Building a custom MCP server for a standard CRM is mostly mapping basic CRUD operations. Building one for DingConnect requires managing strict transactional logic and multi-step telecom workflows. If you build this integration in-house, your middleware has to handle several vendor-specific constraints.

The Product Discovery Triangle

Unlike APIs where endpoints are static, executing a successful transfer in DingConnect requires navigating a dependency triangle of Countries, Providers, and SKUs. Before an agent can issue a top-up, they must know if the provider supports the specific region, what the localized product description is, and whether the destination account number matches the provider's validation regex. If your custom MCP server exposes a generic 'transfer' tool without the preceding discovery tools, ChatGPT will hallucinate SKUs and the API will reject the request.

Pricing Estimation and Send vs. Receive Collisions

Financial transactions in DingConnect are highly variable due to fluctuating FX rates, distributor fees, and dynamic taxes. Before executing a transfer, clients must run estimations. The API enforces a strict mathematical rule: requests must specify either SendValue or ReceiveValue, but never both. If your LLM attempts to specify both based on a user prompt - e.g., 'Send 50 USD so they receive 1000 MXN' - the request will fail. Your tool definitions must explicitly guide the model's behavior around these mutually exclusive parameters.

The 90-Second Execution Timeout

Telecom API transactions are rarely instantaneous. DingConnect enforces a hard 90-second timeout window for SendTransfer operations. If the upstream provider does not respond within this window, the API returns a ProviderTimedOut state and the agent is not charged. Custom servers often block the thread waiting for a response, leading to LLM timeout errors.

Factual Note on Rate Limits

It is critical to understand that Truto does not retry, throttle, or apply backoff logic on rate limit errors. When DingConnect's upstream API returns an HTTP 429 Too Many Requests error, Truto passes that exact error directly to the caller. Truto normalizes the upstream rate limit data into standardized headers (ratelimit-limit, ratelimit-remaining, ratelimit-reset) following the IETF specification. Your AI agent framework or ChatGPT client is entirely responsible for reading these headers and implementing its own retry or backoff logic.

DingConnect to ChatGPT Quickstart Guide

If you want the fastest path from a fresh Truto account to ChatGPT calling the DingConnect API, follow these steps.

Prerequisites:

• A Truto account with API access.
• DingConnect API credentials (Client ID and Secret).
• A ChatGPT Pro, Plus, Business, Enterprise, or Education seat with Developer mode enabled.

Step 1: Connect DingConnect as an Integrated Account

First, you need to authenticate DingConnect within your environment.

1. Log into the Truto dashboard.
2. Navigate to Integrated Accounts -> New Integrated Account.
3. Select DingConnect from the catalog.
4. Input your API credentials. Truto securely vaults these and handles the necessary token exchanges.

Step 2: Grab your Integrated Account ID

You need the specific UUID representing this connected instance. You can copy it from the Truto dashboard URL or retrieve it via the API:

curl https://api.truto.one/integrated-account \
  -H "Authorization: Bearer $TRUTO_API_TOKEN"

Step 3: Generate the DingConnect MCP Server

Truto creates an isolated JSON-RPC endpoint specific to this integration. You can do this via the UI or the API.

Method 1: Via the Truto UI

1. Navigate to the integrated account page for your DingConnect connection.
2. Click the MCP Servers tab.
3. Click Create MCP Server.
4. Select your desired configuration (e.g., name the server, filter by tags like 'transfers' or 'products').
5. Copy the generated MCP server URL.

Method 2: Via the API Make a POST request to Truto, specifying the integration ID. This example restricts the server strictly to read operations for safety:

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": "DingConnect ChatGPT Server",
    "config": {
      "methods": ["read", "list"]
    }
  }'

The API returns a JSON object containing a url field structured as https://api.truto.one/mcp/<token>. This URL contains a cryptographic hash handling routing and authentication. Treat it like a secret.

Step 4: Connect the MCP Server to ChatGPT

Now, tell ChatGPT where to find its new telecom tools.

Method A: Via the ChatGPT UI

1. Open ChatGPT and navigate to Settings -> Apps -> Advanced settings.
2. Ensure Developer mode is enabled.
3. Under MCP servers / Custom connectors, click to add a new server.
4. Set the Name to 'DingConnect'.
5. Paste your Truto MCP URL into the Server URL field and click Add.

Method B: Via Manual Config File (for local agents or desktop clients) If you are running an agent framework or the Claude Desktop client, you configure the server using SSE (Server-Sent Events):

{
  "mcpServers": {
    "dingconnect": {
      "command": "npx",
      "args": [
        "@modelcontextprotocol/server-sse",
        "https://api.truto.one/mcp/<your-secure-token>"
      ]
    }
  }
}

Once connected, the LLM will automatically run an initialize handshake and request tools/list from Truto, generating its context-aware arsenal.

Core MCP Tools for DingConnect Automation

When ChatGPT requests available tools from the Truto MCP server, Truto dynamically derives them from DingConnect's underlying API definitions. Here are the hero tools that enable high-leverage transaction automation.

list_all_ding_connect_get_products

Before executing a transfer, an agent must know what to buy. This tool lists DingConnect products filterable by country ISO, provider code, and even destination account numbers. It returns vital rules like maximum prices, processing modes, and SKU codes needed for subsequent steps.

"Find all available mobile top-up products for the provider 'Claro' in Colombia (CO) and list their SKU codes and maximum send values."

create_a_ding_connect_estimate_price

Since FX rates and distributor fees fluctuate, this tool estimates send or receive prices before committing funds. The LLM must submit an estimation request mapping a SKU code to either a desired SendValue or ReceiveValue to see the final, tax-inclusive calculations.

"Run a price estimate for SKU 'CLARO-CO-1000'. I want the customer to receive exactly 50000 COP. Tell me what my total SendValue in USD will be."

list_all_ding_connect_get_balances

Executing transfers requires sufficient distributor capital. This tool returns the current DingConnect agent balance, including commission increments but excluding processing transfers. It is the mandatory pre-flight check for bulk workflows.

"Check my current DingConnect agent balance. If I have more than $500 USD, let me know so we can proceed with the employee incentive top-ups."

create_a_ding_connect_send_transfer

The core operational tool. It initiates a transfer to an account using a valid SKU. It requires the SkuCode, SendValue, and target AccountNumber. It returns the processing state and commission applied.

"Execute a transfer of 20 USD to account number +573001234567 using SKU 'CLARO-CO-20'. Give me the Transfer ID so I can track it."

list_all_ding_connect_list_transfer_records

Transfers are rarely instantly finalized. This tool queries historical transfer records submitted by the agent, allowing the LLM to poll the ProcessingState (e.g., assessing if a transfer is still pending or successfully delivered) using the Transfer ID.

"Look up the transfer record for Transfer ID 'TRN-987654321'. Is the processing state completed, or did it fail?"

create_a_ding_connect_cancel_transfer

If an error occurs or fraud is suspected on a delayed transaction, this tool submits a batch cancellation request. If the returned state is 'Cancelled', balance compensations have been applied. If any other state returns, the provider has already settled the funds and the cancellation failed.

"I need to cancel Transfer ID 'TRN-987654321'. Issue a cancellation request and confirm if the funds have been successfully returned to our balance."

To view the complete JSON schemas, endpoint mappings, and parameter requirements for all operations, visit the DingConnect integration page.

Workflows in Action

Agentic AI thrives when chaining these discrete operations together to solve complex business logic. Here is how specific personas use these tools natively in ChatGPT.

Scenario 1: Cross-Border Employee Incentives (Operations Manager)

An operations manager needs to send end-of-month digital bonuses (mobile credit) to remote contractors in Mexico and the Philippines.

"Check our agent balance. If we have at least $300, find the correct SKUs for Telcel in Mexico and Globe in the Philippines. Run a price estimate to ensure $50 USD exactly is sent to both. If the estimates look correct, execute the transfers to +525512345678 and +639171234567."

Tool execution sequence:

1. list_all_ding_connect_get_balances: Checks available distributor funds.
2. list_all_ding_connect_get_products: Searches for Telcel (MX) and Globe (PH) to extract their respective SkuCodes.
3. create_a_ding_connect_estimate_price: Calculates exact conversion for a 50 USD SendValue for both SKUs.
4. create_a_ding_connect_send_transfer: Fires two separate transfer requests to the provided international account numbers.

Result: ChatGPT reports the final execution states, the applied commissions, and the internal Transfer IDs for future auditing.

Scenario 2: Automated Support Resolution (Customer Success Lead)

A user reports they haven't received their telecom top-up after 10 minutes. The CS Lead uses ChatGPT to investigate the anomaly and resolve the ticket.

"A customer says their top-up to +573001234567 failed. Find the transfer record from the last hour for that number. If the state is 'ProviderTimedOut' or stuck in processing, cancel the transfer immediately and tell me the result."

sequenceDiagram
    participant User as CS Lead
    participant LLM as ChatGPT
    participant Truto as Truto MCP
    participant Upstream as DingConnect API
    
    User->>LLM: "Investigate transfer for +573001234567"
    LLM->>Truto: Call list_transfer_records(AccountNumber)
    Truto->>Upstream: GET /api/V1/TransferRecord
    Upstream-->>Truto: { TransferId: "123", State: "Processing" }
    Truto-->>LLM: Return Transfer Record
    LLM->>Truto: Call cancel_transfer(TransferId: "123")
    Truto->>Upstream: POST /api/V1/CancelTransfer
    Upstream-->>Truto: { State: "Cancelled" }
    Truto-->>LLM: Return Cancellation Status
    LLM-->>User: "Transfer was stuck. Cancelled successfully. Funds returned."

Tool execution sequence:

1. list_all_ding_connect_list_transfer_records: Searches recent history using the account number to retrieve the specific Transfer ID and its ProcessingState.
2. create_a_ding_connect_cancel_transfer: Submits the ID to reverse the stalled transaction and reclaim the balance.

Result: The LLM confirms the cancellation state directly from DingConnect's upstream servers, allowing the CS rep to instantly update the customer.

Security and Access Control

Exposing financial movement APIs to language models requires strict guardrails. Truto's MCP architecture enforces security at the URL configuration level before the LLM ever sees the tools.

• Method Filtering: When generating the server via the POST endpoint, pass config: { methods: ["read"] } to completely exclude create, update, or delete operations. This ensures ChatGPT can only look up products and estimate prices, completely neutralizing the risk of hallucinated transfers.
• Tag Filtering: Group tools by functional area. Passing config: { tags: ["products"] } ensures the LLM is entirely blind to the balance and transfer endpoints.
• API Token Authentication: For internal team use, setting require_api_token_auth: true means possession of the MCP URL is not enough. The client must also attach a valid Truto session or Bearer token to execute calls.
• Ephemeral Servers: Set an expires_at ISO datetime when creating the server. Once the timestamp is reached, Truto automatically purges the server's cryptographic keys from memory, permanently severing ChatGPT's access to the DingConnect instance.

Automate Global Telecom with Confidence

Building AI workflows against global telecom and fintech APIs usually demands months of custom middleware development to handle state polling, strict discovery rules, and complex pricing math. By utilizing Truto's SuperAI MCP Server, you skip the boilerplate entirely.

Your engineers do not have to write a single JSON-RPC handler, build pagination loops, or maintain token refresh lifecycles. Instead, you supply ChatGPT with a single, secure URL, granting your AI agents native capability to discover products, run financial estimates, and execute DingConnect top-ups instantly.