---
title: "Connect SoftSync to ChatGPT: Query Records, Groups, and Workflows"
slug: connect-softsync-to-chatgpt-query-records-groups-and-workflows
date: 2026-10-13
author: Uday Gajavalli
categories: ["AI & Agents"]
excerpt: "Learn how to securely connect SoftSync to ChatGPT using a managed MCP server. Execute queries, run complex workflows, and automate record management via natural language."
tldr: "Connect SoftSync to ChatGPT using Truto's managed MCP server. This step-by-step guide covers handling SoftSync's dynamic schemas, generating secure MCP tool endpoints, and running real-world automated workflows from the ChatGPT interface."
canonical: https://truto.one/blog/connect-softsync-to-chatgpt-query-records-groups-and-workflows/
---

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

**SoftSync in ChatGPT, in about a minute.** The best way to connect SoftSync to ChatGPT is Elaichi: connect SoftSync to Elaichi once, then add Elaichi to ChatGPT as a connector. Two steps, about a minute, with a 14-day free trial and no credit card required.

1. **Start your free trial.** Create your Elaichi account. 14 days free, no credit card required.
2. **Connect SoftSync.** Connect SoftSync once in Elaichi. ChatGPT never gets more access than you have.
3. **Add Elaichi to ChatGPT.** In ChatGPT, open Plugins, press +, and paste https://api.elaichi.ai/mcp into Server URL. Sign in and approve.

[Start free on Elaichi, 14 days, no credit card required](https://app.elaichi.ai/signup?utm_source=truto.one&utm_medium=referral&utm_campaign=launchpad&utm_content=post_markdown&utm_term=softsync) · [SoftSync on Elaichi](https://elaichi.ai/connectors/softsync/?utm_source=truto.one&utm_medium=referral&utm_campaign=launchpad&utm_content=post_markdown&utm_term=softsync)

*Building SoftSync into your own product? The guide below is for you.*

---

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](https://truto.one/what-is-mcp-and-mcp-servers-and-how-do-they-work/). 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](https://truto.one/connect-softsync-to-claude-run-email-campaigns-and-manage-messaging/) or explore our broader architectural overview on [connecting SoftSync to AI Agents](https://truto.one/connect-softsync-to-ai-agents-automate-data-tables-and-batch-tasks/).

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](https://truto.one/auto-generated-mcp-tools-for-ai-agents-a-2026-architecture-guide/) 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.

> Stop writing boilerplate API integration code. Let Truto generate secure, managed MCP servers for your AI agents in seconds.
>
> [Talk to us](https://truto.one/book-a-demo/)

## The Engineering Reality of the SoftSync API

[Building a custom MCP server](https://truto.one/the-hands-on-guide-to-building-mcp-servers-for-ai-agents-2026/) 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.

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

```json
{
  "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](https://truto.one/integrations/detail/softsync).

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

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

```mermaid
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](https://truto.one/auto-generated-mcp-tools-for-ai-agents-a-2026-architecture-guide/) 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.

> Stop writing integration code. Let Truto generate secure, managed MCP servers for your AI agents today.
>
> [Talk to us](https://truto.one/book-a-demo/)