How to Connect Anthropic to Real-Time SaaS Data with Unified.to MCP Server

August 28, 2025

Anthropic's Claude models can power sophisticated workflows — but most products still need access to live customer data from CRMs, ATSs, HRIS, or accounting systems. That usually means writing brittle glue code, normalizing APIs, and maintaining webhook jobs.

With Unified.to's MCP server, you can skip that complexity. Unified.to exposes 2154 SaaS integrations as real-time, callable tools that Claude can use directly — no custom integration logic required.

In this guide, we'll walk through how to connect Anthropic to Unified.to MCP so your application can give Claude real-time access to customer SaaS data and actions.

Authentication

Every tool call to the Unified.to MCP server needs a credential. Send it as a bearer token in the Authorization: Bearer {token} header (the x-api-key header also works). Passing the token as a URL parameter is deprecated.

Unified MCP documents five authentication options; this guide uses the two that fit a backend calling Anthropic:

• Private (workspace key + connection)
  Use your Unified.to workspace API key and add a connection parameter. This should never be exposed publicly.
• Connection-scoped token
  Generate a connection-scoped token with the Core MCP tool get_unified_connection_mcp_url and mode=user; use the returned recommended URL and send the token in the Authorization header. The token grants access to one connection only, never exposes your workspace API key and does not expire; delete the connection to revoke it. mode=api uses your workspace API key and must not be shared.

Integrating with Anthropic API

Model names change often; use a current model from your provider's model list.

Manual Tool Orchestration:

1. Call Unified's /tools?type=openai endpoint, rename each tool's parameters to input_schema, and pass the tool list to Claude:
   import os
   
   import anthropic
   import requests
   
   UNIFIED_API_KEY = os.environ["UNIFIED_API_KEY"]
   CONNECTION_ID = os.environ["CONNECTION_ID"]
   # Regional host without a path: US https://mcp-api.unified.to, EU https://mcp-api-eu.unified.to, AU https://api-au.unified.to
   UNIFIED_MCP_URL = os.environ.get("UNIFIED_MCP_URL", "https://mcp-api.unified.to")
   
   openai_tools = requests.get(
       f"{UNIFIED_MCP_URL}/tools",
       headers={"Authorization": f"Bearer {UNIFIED_API_KEY}"},
       params={"type": "openai", "connection": CONNECTION_ID},
   ).json()
   # Anthropic takes the same JSON Schema under input_schema
   tools = [
       {"name": t["name"], "description": t["description"], "input_schema": t["parameters"]}
       for t in openai_tools
   ]
   
   client = anthropic.Anthropic()  # reads ANTHROPIC_API_KEY
   messages = [{"role": "user", "content": "List the candidates and then analyse the resumes from their applications."}]
   
   while True:
       resp = client.messages.create(
           model="claude-sonnet-5-5",
           max_tokens=4096,
           tools=tools,
           messages=messages,
       )
       if resp.stop_reason != "tool_use":
           break
       messages.append({"role": "assistant", "content": resp.content})
       results = []
       for block in resp.content:
           if block.type == "tool_use":
               result = requests.post(
                   f"{UNIFIED_MCP_URL}/tools/{block.name}/call",
                   headers={
                       "Authorization": f"Bearer {UNIFIED_API_KEY}",
                       "Content-Type": "application/json",
                   },
                   params={"connection": CONNECTION_ID},
                   json=block.input,
               )
               results.append({"type": "tool_result", "tool_use_id": block.id, "content": result.text})
       messages.append({"role": "user", "content": results})
   
   print("".join(b.text for b in resp.content if b.type == "text"))
   

2. Claude will return a tool_use block:
   [
     {
       "type": "tool_use",
       "id": "toolu_...",
       "name": "list_candidates",
       "input": { "limit": "100" }
     }
   ]
   

3. Call Unified's /tools/{id}/call endpoint with the arguments.
4. Append Claude's response as an assistant message, then return the result as a tool_result block at the start of the next user message:
   [
     {
       "type": "tool_result",
       "tool_use_id": "toolu_...",
       "content": "..."
     }
   ]
   

Controlling Tool Access

Unified.to MCP gives you granular control over how tools are exposed to Anthropic:

• permissions → restrict available scopes.
• tools → allowlist specific tool IDs.
• aliases → adds extra descriptions to improve tool matching.
• hide_sensitive=true → strips sensitive (PII) fields such as names, emails, phone numbers, addresses, date of birth, SSN/SIN and compensation, plus credential fields, from results.
• include_external_tools=true → expose all vendor API endpoints, not just Unified.to's normalized models.

These options help you keep Anthropic outputs predictable and secure in production-grade workflows.

Sample Snippet

import Anthropic from '@anthropic-ai/sdk';
// Claude model
const model = 'claude-sonnet-5-5';
// Unified connection ID that the MCP server should use
const connection = process.env.CONNECTION_ID;
// Regional host without a path: US https://mcp-api.unified.to, EU https://mcp-api-eu.unified.to, AU https://api-au.unified.to
const UNIFIED_MCP_URL = process.env.UNIFIED_MCP_URL || 'https://mcp-api.unified.to';
// Set to true to expose the vendor's own API endpoints as tools
const includeExternal = false;
const message = 'List the candidates and then analyse the resumes from their applications.';
// Optional: list of specific tools that you want to use
const toolIds = ['get_messaging_message','list_messaging_message']

const params = new URLSearchParams({
    connection,
    include_external_tools: includeExternal ? 'true' : 'false',
});

if (toolIds.length > 0) {
    params.append('tools', toolIds.join(','));
}

const anthropic = new Anthropic({
    apiKey: process.env.ANTHROPIC_API_KEY,
});

const serverUrl = `${UNIFIED_MCP_URL}/mcp?${params.toString()}`;

const completion = await anthropic.beta.messages.create({
    model,
    max_tokens: 1024,
    messages: [
        {
            role: 'user',
            content: message,
        },
    ],
    stream: false,
    mcp_servers: [
        {
            type: 'url',
            url: serverUrl,
            name: 'unifiedMCP',
            // Anthropic calls the MCP server, so send a connection-scoped signed token
            // (one connection only); the workspace API key stays on your server
            authorization_token: process.env.UNIFIED_MCP_TOKEN,
        },
    ],
    tools: [{ type: 'mcp_toolset', mcp_server_name: 'unifiedMCP' }],
    betas: ['mcp-client-2025-11-20'],
});

console.log('response', JSON.stringify(completion, null, 2));

Coverage and Infrastructure

Unified.to MCP is built for real-world AI use cases:

• 204,184 real-time tools (growing weekly)
• 2154 integrations across 38 categories (ATS, CRM, HRIS, Accounting, Messaging, File Storage, and more)
• No stored customer records: Unified.to stores no customer records; logs hold operational metadata only
• Scoped security controls — permissions, aliases, and PII redaction
• Multi-region deployment — US, EU, and AU data centers for compliance

Unified.to MCP works with major LLM providers, including OpenAI, Anthropic, Google Gemini and Cohere. That means you can build once and connect to any agent client.

Explore the MCP docs or book a demo