Connect SoftSync to ChatGPT: Query Records, Groups, and Workflows

If you want to connect SoftSync to ChatGPT so your AI agents can query dynamic records, manage group permissions, and trigger automated workflows, you need a Model Context Protocol (MCP) server. This server acts as the translation layer, exposing SoftSync's highly relational API structure as simple JSON-RPC tools that ChatGPT can understand and execute.

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

Giving a Large Language Model (LLM) read and write access to a flexible workspace platform like SoftSync requires solving several engineering problems. SoftSync relies on dynamic schemas, asynchronous workflow polling, and strict rate limits. You can either spend weeks building and hosting a custom MCP server to map these endpoints, or you can use a managed infrastructure layer to dynamically generate a secure, authenticated MCP server URL.

This guide breaks down exactly how to use Truto to generate a secure MCP server for SoftSync, connect it natively to ChatGPT, and execute complex record and workflow management using natural language.

The Engineering Reality of the SoftSync API

Building a custom MCP server means you own the entire API lifecycle. While standard CRUD APIs are relatively straightforward to wrap in an MCP server, SoftSync's architecture presents specific integration challenges that break standard assumptions.

Here are the specific API realities you must handle when integrating SoftSync:

Dynamic Schemas and UUID Field Keys

SoftSync allows users to build highly customized data tables (Objects). Unlike standard REST APIs where you might POST a JSON payload with keys like first_name or status, SoftSync requires payload keys to be the system-generated UUIDs of those fields.

If an LLM wants to create a record, it cannot simply guess the field names. Your MCP server must first fetch the workspace schema (GET /table/describe), map the human-readable names to their underlying field IDs, and then construct the request body using those IDs. Truto handles this by exposing the schema description endpoint as a primary tool, allowing the LLM to inspect the workspace structure before attempting any writes.

Soft-Deletes and the 30-Day Bin

SoftSync does not immediately destroy deleted records. Instead, a DELETE request performs a soft-delete, moving the record to a "Bin" where it lives for 30 days. If your LLM needs to audit deleted data or recover a mistake, it must explicitly pass an includeDeleted flag when querying records, or call the specific restoration endpoints. Your MCP server tools must expose this nuance, or AI agents will assume deleted data is permanently gone and fail to perform recovery operations.

Asynchronous Workflow Polling

SoftSync features a powerful published workflow system. However, when you trigger a workflow via the API, the execution can be synchronous (waiting up to 60 seconds) or asynchronous. If a workflow runs asynchronously or times out, SoftSync returns a 202 Accepted with a runId and a pollUrl.

Your AI agent must know how to parse this 202 response, wait, and call the polling endpoint to get the final execution result. If you don't expose this polling mechanism clearly in your MCP tool descriptions, the LLM will hallucinate workflow completion immediately after receiving the 202 status.

Strict Pass-Through Rate Limiting

SoftSync enforces strict rate limits to protect workspace stability. It is critical to understand how Truto handles these limits. Truto does not automatically retry, throttle, or apply backoff on rate limit errors.

When the SoftSync upstream API returns an HTTP 429 (Too Many Requests), Truto passes that error directly back to the caller (your LLM client). Truto normalizes the upstream rate limit information into standardized IETF headers (ratelimit-limit, ratelimit-remaining, ratelimit-reset). The caller - whether it is ChatGPT or your custom agent framework - is entirely responsible for reading these headers and implementing its own retry or backoff logic.

Quickstart: Connect SoftSync to ChatGPT

To get ChatGPT querying your SoftSync workspace, you need to authenticate the account, generate an MCP server, and register that server with your OpenAI client. You can do this via the UI or programmatically.

Step 1: Connect SoftSync

First, you need to establish an authenticated connection to SoftSync.

In the Truto dashboard, navigate to Integrated Accounts, click New Integrated Account, select SoftSync, and complete the OAuth flow. Truto securely stores the credentials and handles the token refresh lifecycle automatically.

Take note of the resulting integrated_account_id.

Step 2: Generate the SoftSync MCP Server

Next, generate an MCP server URL scoped exclusively to this SoftSync account.

Method A: Via the Truto UI

1. Navigate to the integrated account page for your new SoftSync connection.
2. Click the MCP Servers tab.
3. Click Create MCP Server.
4. Select your desired configuration (e.g., filter to read methods only, or specific tags like records).
5. Copy the generated MCP server URL (it will look like https://api.truto.one/mcp/<token>).

Method B: Via the API You can generate the same server programmatically by sending a POST request to Truto. This is useful if you are provisioning AI capabilities for your own end-users.

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": "SoftSync Agent Server",
    "config": {
      "methods": ["read", "write"],
      "tags": ["records", "workflows", "emails"]
    }
  }'

The response contains the secure url field. Treat this URL as a secret - it contains embedded authentication routing directly to this specific SoftSync workspace.

Step 3: Register the MCP Server in ChatGPT

Finally, connect the server to your ChatGPT environment.

Method A: Via the ChatGPT UI If you are on a ChatGPT Plus, Pro, Team, or Enterprise plan with Developer mode enabled:

1. Open ChatGPT and go to Settings -> Connectors -> Add custom connector.
2. Enter a recognizable name (e.g., "SoftSync").
3. Paste the Truto MCP URL into the Server URL field.
4. Click Add.

ChatGPT will immediately perform an MCP handshake (initialize), discover the SoftSync tools, and make them available in your chat sessions.

Method B: Via Manual Config File (Local Dev/Desktop) If you are running a local desktop client or custom LangChain/Agent setup that uses standard MCP configuration files, you can use the official @modelcontextprotocol/server-sse wrapper to connect to the remote Truto server.

{
  "mcpServers": {
    "softsync": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-sse",
        "https://api.truto.one/mcp/<your_token_here>"
      ]
    }
  }
}

SoftSync Hero Tools for ChatGPT

When ChatGPT connects to the SoftSync MCP server, Truto dynamically derives the available tools from SoftSync's active API documentation. Here are the highest-leverage tools available for AI automation.

1. List Table Descriptions

Tool name: list_all_soft_sync_table_describes

This is the foundational tool. Because SoftSync requires field IDs instead of field names for creating or updating records, ChatGPT must call this tool first to map human-readable table layouts into the exact UUIDs required by the upstream API.

"Fetch the workspace schema for SoftSync. I need to map the field names for the 'Customers' table to their field IDs so I can create a new record."

2. Query Records

Tool name: create_a_soft_sync_records_query

This tool allows the LLM to execute complex searches against a specific view, applying filters and sorts. It is the primary way ChatGPT retrieves active workspace data for summarization or analytics.

"Query the records in the 'Active Leads' view of the Sales group. Return the data so I can summarize the top priorities for this week."

3. Create a Record

Tool name: create_a_soft_sync_record

Creates a new row in a SoftSync table. ChatGPT will construct a JSON object where the keys are the field IDs (obtained from the describe tool) and the values are the new data.

"Create a new record in the Customers table. The name should be 'Acme Corp' and the status should be set to 'Onboarding'."

4. Batch Update Fields

Tool name: update_a_soft_sync_batch_update_field_by_id

Ideal for bulk operations. Instead of editing records one by one, this tool applies a partial field patch to an array of record IDs simultaneously. This is highly efficient when ChatGPT needs to categorize or reassign dozens of items at once.

"Take these 15 record IDs and bulk update their 'Assigned To' field to the ID representing John Doe."

5. Send Email Campaign

Tool name: create_a_soft_sync_email_campaign

Allows the LLM to dispatch a reusable SoftSync email template to a list of records. SoftSync handles the personalization by filling {{field_api_name}} placeholders with data from each recipient's record.

"Send the 'Q3 Newsletter' email template to all the record IDs we just queried from the VIP Customers view."

6. Run a Published Workflow

Tool name: create_a_soft_sync_workflow_run

Triggers an automated workflow configured inside SoftSync using its specific slug. If the workflow takes longer than 60 seconds, this tool initiates the async polling process, allowing ChatGPT to check back later for the output.

"Trigger the 'generate_monthly_invoices' workflow. Let me know if it finishes synchronously or if we need to poll for the result."

To view the complete list of available operations, including group management, OAuth provisioning, and analytics, visit the SoftSync integration page.

Workflows in Action

Once connected, ChatGPT can orchestrate multi-step operations without human intervention. Here is how real-world SoftSync workflows operate via MCP.

Workflow 1: Bulk Record Triage and Campaign Dispatch

Marketing teams often need to segment users based on recent activity and instantly dispatch targeted comms. An AI agent can handle the querying, the data patching, and the email dispatch in one seamless conversation.

"Find all users in the 'Stalled Trials' view. Bulk update their status field to 'Re-engaged', and then trigger the 'Trial Extension' email campaign to those users."

1. ChatGPT calls list_all_soft_sync_table_describes to get the field ID for "status".
2. ChatGPT calls create_a_soft_sync_records_query to pull all record IDs from the "Stalled Trials" view.
3. ChatGPT calls update_a_soft_sync_batch_update_field_by_id to patch the status field on all those records to "Re-engaged".
4. ChatGPT calls create_a_soft_sync_email_campaign, passing the targeted record IDs and the relevant template ID.

sequenceDiagram
    participant User as User
    participant ChatGPT as ChatGPT
    participant MCP as Truto MCP Server
    participant SoftSync as SoftSync API

    User->>ChatGPT: "Re-engage stalled trials"
    ChatGPT->>MCP: Call create_a_soft_sync_records_query
    MCP->>SoftSync: POST /records/query
    SoftSync-->>MCP: Return 50 record IDs
    MCP-->>ChatGPT: Provide record list
    ChatGPT->>MCP: Call update_a_soft_sync_batch_update_field_by_id
    MCP->>SoftSync: PATCH /records/batch
    SoftSync-->>MCP: 200 OK
    MCP-->>ChatGPT: Update confirmed
    ChatGPT->>MCP: Call create_a_soft_sync_email_campaign
    MCP->>SoftSync: POST /email/campaigns
    SoftSync-->>MCP: 202 Accepted (campaignId)
    MCP-->>ChatGPT: Return campaign status
    ChatGPT-->>User: "Updated 50 records and launched email campaign."

Workflow 2: Asynchronous Data Processing

When dealing with heavy background tasks, AI agents must handle asynchronous API behaviors correctly.

"Run the 'compile_end_of_year_report' workflow. If it takes a while, just tell me the run ID so we can check it later."

1. ChatGPT calls create_a_soft_sync_workflow_run with the requested workflow slug.
2. SoftSync determines the job will take 5 minutes and returns a 202 status with a pollUrl and runId.
3. ChatGPT parses the MCP response, recognizing the async state.
4. ChatGPT informs the user that the job is processing in the background.

sequenceDiagram
    participant User as User
    participant ChatGPT as ChatGPT
    participant MCP as Truto MCP Server
    participant SoftSync as SoftSync API

    User->>ChatGPT: "Run the end of year report workflow"
    ChatGPT->>MCP: Call create_a_soft_sync_workflow_run
    MCP->>SoftSync: POST /workflows/compile_end_of_year_report/run
    SoftSync-->>MCP: 202 Accepted<br>runId: abc-123
    MCP-->>ChatGPT: Return async run status
    ChatGPT-->>User: "Workflow started. Run ID is abc-123. Ask me to check the status in a few minutes."

Security and Access Control

Exposing an enterprise database like SoftSync to an LLM requires strict governance. Truto provides multiple layers of access control at the MCP server level:

• Method Filtering: When generating the server URL, you can pass config.methods = ["read"]. Truto will aggressively filter the generated tools, silently dropping create, update, and delete operations. The LLM simply won't know those tools exist.
• Tag Filtering: Limit the server scope to specific functional areas. Passing config.tags = ["records", "views"] ensures the LLM cannot touch underlying configuration tools like API key generation or Webhook management.
• Require API Token Auth: By setting require_api_token_auth = true, possessing the MCP URL is no longer enough. The client (e.g., your custom LangChain backend) must also inject a valid Truto API token into the HTTP headers, ensuring only authenticated systems can invoke tools.
• Server Expiration: You can provision temporary access by setting an expires_at timestamp. Once the time passes, Truto automatically deletes the server configuration and terminates LLM access.

Moving Fast with Managed MCP Infrastructure

Building an AI agent that can reliably query, update, and manage SoftSync records requires dealing with dynamic UUID schemas, soft-deletes, and asynchronous polling.

Instead of writing and maintaining custom API wrapper code to handle these quirks, Truto derives these tools dynamically from SoftSync's own documentation. You connect the account, generate the URL, and let ChatGPT handle the execution.