Connect SoftSync to Claude: Run Email Campaigns & Messaging (MCP)

If your team needs to connect SoftSync to Claude to automate email campaigns, manage workspace messaging, or query custom record tables, you need a Model Context Protocol (MCP) server. This server acts as the translation layer between Claude's tool calls and SoftSync's REST APIs. You can either build and maintain this infrastructure 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 /connect-softsync-to-chatgpt-query-records-groups-and-workflows/ or explore our broader architectural overview on /connect-softsync-to-ai-agents-automate-data-tables-and-batch-tasks/.

Giving a Large Language Model (LLM) read and write access to a complex messaging and record-keeping system like SoftSync is an engineering challenge. You have to handle OAuth 2.1 token lifecycles, map dynamic custom object schemas to MCP tool definitions, and navigate strict rate limits on email sending. Every time SoftSync updates a table schema or introduces new template placeholders, you have to update your server code, redeploy, and test the integration.

This guide breaks down exactly how to use Truto to generate a secure, managed MCP server for SoftSync, connect it natively to Claude Desktop, and execute complex email and messaging workflows using natural language.

The Engineering Reality of the SoftSync 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, the reality of implementing it against specialized B2B APIs is painful. SoftSync is a deeply relational system where messaging campaigns are tightly coupled to custom data objects (Tables). Its API reflects that complexity.

If you decide to build a custom SoftSync MCP server, here are the specific integration challenges you will face:

The ID-Driven Data Dictionary SoftSync does not allow you to query or write records using human-readable field names. Every custom field in a SoftSync Workspace is assigned an internal hash ID. To create a record or query a table, an LLM cannot simply send {"email": "user@example.com"}. It must first call a schema description endpoint, parse the entire workspace dictionary, find the ID for the "email" field on that specific table, and construct a payload like {"data": {"fld_8a9b2c": "user@example.com"}}. A custom MCP server must seamlessly pass these schema description tools to Claude so the model can map the fields dynamically before executing write operations.

Template Placeholder Validation SoftSync email templates are bound to a specific tableId. When creating an email template, you can inject variables like {{first_name}}, but if that exact API name doesn't exist on the target table, the campaign will fail at dispatch time. Your MCP server must expose the template variable listing tools so Claude can cross-reference available placeholders against the table schema before attempting to write a template body.

Asynchronous Campaign Execution and Pacing Triggering a mass email campaign in SoftSync is not a synchronous operation. The create_a_soft_sync_email_campaign endpoint responds with a 202 Accepted and a campaignId. SoftSync then paces the delivery to respect workspace hourly mailbox limits. If Claude needs to know if a campaign actually succeeded (or if certain recipients failed due to bad addresses), it must poll the campaign status endpoint. An LLM needs explicit instructions on how to handle this async polling loop, otherwise it will hallucinate that the emails were sent the moment the 202 is returned.

Rate Limiting and State Handling Like any robust API, SoftSync enforces strict rate limits, particularly on search and messaging endpoints. It is critical to understand that Truto does not retry, throttle, or apply backoff on rate limit errors. When SoftSync returns an HTTP 429 Too Many Requests, Truto passes that error directly back to the caller (your MCP client/Claude). However, Truto normalizes the upstream rate limit information into standardized headers (ratelimit-limit, ratelimit-remaining, ratelimit-reset) per the IETF spec. Your agent is responsible for reading these headers, waiting the appropriate amount of time, and retrying the tool call.

Step 1: Generate the SoftSync MCP Server

Instead of building a bespoke Node.js or Python server to handle SoftSync's authentication, pagination, and schema quirks, you can use Truto to generate a secure MCP server URL.

Truto derives MCP tools dynamically from SoftSync's API documentation and endpoint definitions. Tools are never cached or pre-built. The generated URL contains a cryptographic token that authenticates the specific SoftSync account connection.

You can create this MCP server in two ways.

Method A: Via the Truto UI

For administrators and internal teams setting up Claude Desktop for their own use:

1. Log into your Truto dashboard and navigate to your connected SoftSync Integrated Account.
2. Click the MCP Servers tab.
3. Click Create MCP Server.
4. Give it a descriptive name (e.g., "SoftSync Marketing Agent").
5. (Optional) Filter the server to only expose specific tools using Method or Tag filters.
6. Click Create and copy the generated MCP Server URL (e.g., https://api.truto.one/mcp/a1b2c3d4...).

Method B: Via the API

If you are building an AI application and need to programmatically provision SoftSync MCP servers for your end-users, use the Truto API.

Send a POST request to the /integrated-account/:id/mcp endpoint:

curl -X POST https://api.truto.one/integrated-account/{integrated_account_id}/mcp \
  -H "Authorization: Bearer YOUR_TRUTO_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "SoftSync Email Campaign Agent",
    "config": {
      "methods": ["read", "write", "custom"],
      "tags": ["messaging", "records"]
    },
    "expires_at": "2026-12-31T23:59:59Z"
  }'

The API returns a fully configured MCP server URL ready for consumption:

{
  "id": "mcp_7x8y9z",
  "name": "SoftSync Email Campaign Agent",
  "config": {
    "methods": ["read", "write", "custom"],
    "tags": ["messaging", "records"]
  },
  "expires_at": "2026-12-31T23:59:59.000Z",
  "url": "https://api.truto.one/mcp/f7a9b2..."
}

Step 2: Connect the MCP Server to Claude

Once you have your Truto MCP URL, connecting it to Claude is a matter of configuration. The MCP server is fully self-contained - the URL alone authenticates the request to the specific SoftSync workspace.

Method A: Via the Claude UI

If you are using Claude Desktop or an enterprise workspace that supports visual connector management:

1. Open Claude and navigate to Settings -> Integrations (or Connectors -> Add custom connector depending on your tier).
2. Click Add MCP Server.
3. Provide a name, such as "SoftSync Production".
4. Paste the Truto MCP URL into the connection field.
5. Click Save or Add.

Claude will immediately execute the MCP initialize and tools/list handshake, making the SoftSync tools available in your next chat session.

Method B: Via manual config file (Claude Desktop)

For developers using the local Claude Desktop app, you can map the MCP server using Server-Sent Events (SSE) via the claude_desktop_config.json file. Truto's /mcp endpoints support standard JSON-RPC over HTTP.

Locate your Claude config file:

• Mac: ~/Library/Application Support/Claude/claude_desktop_config.json
• Windows: %APPDATA%\Claude\claude_desktop_config.json

Add the SoftSync server using the @modelcontextprotocol/server-sse runner:

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

Restart Claude Desktop. The agent now has direct access to your SoftSync workspace.

Essential SoftSync MCP Tools

Truto automatically generates descriptive, heavily-typed MCP tools based on SoftSync's documentation records. Here are 6 high-leverage tools your AI agent will use to automate campaigns and messaging.

list_all_soft_sync_table_describes

This is the most critical reconnaissance tool in the SoftSync arsenal. Because SoftSync uses internal hash IDs for custom fields rather than text names, the LLM must call this tool to map human concepts (like "Lead Score") to database keys (like fld_99x).

"Fetch the workspace schema from SoftSync. I need to know the table ID for our 'Customers' object, and the field IDs for 'Email Address', 'First Name', and 'Subscription Tier'. Keep these IDs in mind for our next steps."

create_a_soft_sync_email_template

Creates a reusable email template tied to a specific tableId. The LLM can draft highly personalized copy by injecting {{field_api_name}} placeholders.

"Create a new email template in SoftSync for the 'Customers' table. The subject should be 'Action Required: Update your billing info, {{first_name}}'. Write a brief, professional body explaining that their card is expiring soon."

list_all_soft_sync_templates_variables

Before writing an email template, the LLM should use this tool to verify exactly which {{placeholder}} variables are valid for the target table, preventing failed merges at dispatch time.

"Before we create the template, list the available template variables for the table ID 'tbl_4k2m9'. I want to make sure we can inject their current account balance into the email body."

create_a_soft_sync_email_campaign

Sends an email template to an array of specific recordIds. This triggers SoftSync's asynchronous delivery engine. The tool returns a campaignId which the LLM must monitor.

"Trigger an email campaign using template ID 'tpl_882x' to the 5 record IDs we just identified. Let me know the campaign ID once it's queued."

get_single_soft_sync_email_campaign_by_id

Checks the status of a dispatched campaign. Because SoftSync respects hourly mailbox sending limits, campaigns may sit in a running state for hours. The LLM uses this to report progress.

"Check the status of campaign 'cmp_331b'. If it's still running, let me know. If it's completed, summarize how many messages were successfully delivered."

list_all_soft_sync_search_messages

Performs a semantic or trigram search across the workspace's message history. This is incredibly powerful for support QA or analyzing past campaign performance based on conversational intent.

"Search our SoftSync messages for anyone complaining about 'login errors' or 'password reset loops' over the last 30 days. Summarize the affected users."

To see the full list of available tools, query parameters, and schema definitions, check out the SoftSync integration page.

Workflows in Action

By chaining these tools together, Claude can execute complex, multi-step messaging workflows that would normally require a human to click through dozens of SoftSync screens.

Workflow 1: Launching a Targeted Product Update Campaign

A Product Marketing Manager wants to email all "Enterprise" tier customers about a new feature, using a personalized template.

"Find all users in the 'Accounts' table who have 'Enterprise' as their subscription tier. Draft a new email template announcing our new SSO feature, inject their company name into the subject line, and send it to that list. Monitor the campaign until it completes."

How the agent executes this:

1. Calls list_all_soft_sync_table_describes to find the tableId for "Accounts" and the field IDs for "Subscription Tier" and "Company Name".
2. Calls create_a_soft_sync_records_query passing the table ID and a filter on the Subscription Tier field to get the list of target recordIds.
3. Calls list_all_soft_sync_templates_variables to confirm the exact {{company_name}} placeholder syntax.
4. Calls create_a_soft_sync_email_template with the drafted subject and HTML body.
5. Calls create_a_soft_sync_email_campaign with the new template ID and the array of recordIds.
6. Enters a loop, calling get_single_soft_sync_email_campaign_by_id periodically until the status changes from running to completed.

sequenceDiagram
    participant Claude as Claude Desktop
    participant Truto as Truto MCP Server
    participant SoftSync as SoftSync API

    Claude->>Truto: list_all_soft_sync_table_describes()
    Truto->>SoftSync: GET /table/describe
    SoftSync-->>Claude: Returns Table & Field IDs
    
    Claude->>Truto: create_a_soft_sync_records_query(filters)
    Truto->>SoftSync: POST /records/query
    SoftSync-->>Claude: Returns targeted recordIds
    
    Claude->>Truto: create_a_soft_sync_email_template(...)
    Truto->>SoftSync: POST /email/template
    SoftSync-->>Claude: Returns templateId
    
    Claude->>Truto: create_a_soft_sync_email_campaign(templateId, recordIds)
    Truto->>SoftSync: POST /email/campaign
    SoftSync-->>Claude: Returns 202 Accepted & campaignId

Workflow 2: Triaging Support Messages and Tagging Records

A Customer Success Lead wants to identify negative sentiment in recent messages and tag those user records for follow-up.

"Search our recent SoftSync messages for strong frustration or cancellation threats. For any users you find, locate their core CRM record and update their 'Account Health' field to 'At Risk'."

How the agent executes this:

1. Calls list_all_soft_sync_search_messages with a semantic query for cancellation intent.
2. Extracts the recordId associated with each flagged message.
3. Calls list_all_soft_sync_table_describes to find the field ID for "Account Health".
4. Calls update_a_soft_sync_record_by_id iteratively for each flagged user, passing the field ID and the value "At Risk".

Security and Access Control

Giving an LLM access to your email marketing engine requires strict governance. Truto MCP servers provide several layers of access control at the token level, ensuring agents only touch what they are authorized to touch.

• Method Filtering: Limit the server to safe operations. By setting methods: ["read"], the agent can query schemas and search messages, but cannot create templates, trigger campaigns, or update records.
• Tag Filtering: Restrict tools by domain. Setting tags: ["messaging"] ensures the agent can send emails but cannot modify underlying Workspace structures or Group hierarchies.
• Expiration Controls: Use the expires_at property to create ephemeral MCP servers. Ideal for granting an external contractor's AI agent access to SoftSync for a 48-hour audit window.
• API Token Auth (require_api_token_auth): By default, possessing the MCP URL grants access. Enable this flag to require the Claude client to pass a valid Truto API user token in the headers, adding a strict secondary identity layer.

Moving Fast Without Breaking Campaigns

Connecting Claude to SoftSync manually means fighting pagination, rate limits, schema resolution, and async polling logic in custom middleware. With a managed MCP server via Truto, you abstract away the API mechanics and immediately give your agents native, documented tools to drive your email marketing and workspace messaging.

By relying on Truto's dynamic, documentation-driven tool generation, your AI capabilities evolve automatically as SoftSync ships new endpoints, preventing integration rot and keeping your agents focused on orchestrating campaigns.