Connect Outreach to Claude: Track Sales Tasks and Opportunities

If you need to connect Outreach to Claude to track sales sequences, manage prospect data, update opportunities, or automate daily tasks, you need a Model Context Protocol (MCP) server. This server acts as the critical translation layer between Claude's natural language tool calls and the Outreach REST API. You can either build and maintain this translation 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 connecting Outreach to ChatGPT or explore our broader architectural overview on connecting Outreach to AI Agents.

Giving a Large Language Model (LLM) read and write access to an enterprise sales execution platform like Outreach presents a steep engineering challenge. You must handle complex OAuth 2.0 token lifecycles, map deeply nested JSON payloads to MCP tool definitions, and manage the platform's specific API quotas. Every time Outreach updates an endpoint or changes a relationship requirement, 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 Outreach, connect it natively to Claude, and execute complex sales workflows using natural language.

The Engineering Reality of the Outreach API

A custom MCP server is essentially a self-hosted integration layer. While the open MCP standard provides a predictable way for models like Claude to discover and invoke tools, the reality of implementing it against the Outreach API is unusually demanding. You are not just building a standard REST wrapper - you are interacting with a strict, hyper-relational data model.

If you decide to build a custom MCP server for Outreach, you own the entire API lifecycle. Here are the specific, distinct challenges you will face:

The JSON:API Specification Nightmare for LLMs

The Outreach API strictly adheres to the JSON:API specification. For human developers building tightly coupled systems, this is highly predictable. For an LLM generating payloads on the fly, it is a constant source of hallucinations.

To create a prospect, you cannot simply send {"firstName": "Jane", "lastName": "Doe"}. You must construct a highly specific wrapper:

{
  "data": {
    "type": "prospect",
    "attributes": {
      "firstName": "Jane",
      "lastName": "Doe"
    }
  }
}

When relationships are involved - for example, associating a task with a specific opportunity - the payload complexity scales exponentially. An LLM attempting to write this from scratch will frequently omit the data wrapper, misplace the type declaration, or try to flatten the payload. A managed MCP server abstracts this away by deriving precise JSON schemas from the underlying integration documentation, forcing Claude to populate the exact required structure before the request is even proxied to Outreach.

Highly Granular Relational Models

Outreach separates concepts that other CRMs combine. For example, linking a prospect to an opportunity requires creating an entirely separate entity called an opportunityProspectRole. The LLM must first fetch the Prospect ID, then fetch the Opportunity ID, and finally construct a payload that references both correctly. Your MCP implementation must present these individual endpoints as distinct, clearly defined tools, otherwise Claude will attempt to attach the prospect directly to the opportunity object (which Outreach will reject).

Strict Rate Limits and Concurrency Rules

Outreach enforces hard limits on API requests per second and per hour, governed by the account tier.

A critical factual note on rate limits: Truto does not retry, throttle, or apply backoff on rate limit errors. When the upstream Outreach API returns an HTTP 429 Too Many Requests, Truto passes that error directly to the caller. Truto normalizes the upstream rate limit information into standardized headers (ratelimit-limit, ratelimit-remaining, ratelimit-reset) per the IETF specification.

If Claude executes a loop that triggers a 429, it will receive the error in the tool call response. The caller - whether that is a human interacting with Claude Desktop or an autonomous agent framework - is entirely responsible for observing these headers and implementing retry/backoff logic.

flowchart TD
    Claude["Claude Desktop<br>(MCP Client)"]
    Truto["Truto MCP Router<br>(Managed Server)"]
    Outreach["Outreach API<br>(JSON:API)"]

    Claude -->|"JSON-RPC 2.0<br>Call Tool"| Truto
    Truto -->|"Standardized REST<br>Auth Injected"| Outreach
    Outreach -->|"HTTP 429<br>Rate Limit Hit"| Truto
    Truto -->|"Normalized IETF Headers<br>Passed to Caller"| Claude

Creating the Truto MCP Server for Outreach

Truto dynamically generates MCP tools based on the existing documentation and resource definitions of the connected Outreach instance. Each MCP server is scoped to a single integrated account, meaning the generated URL contains a cryptographic token that handles all authentication routing.

You can generate this server via the Truto UI or programmatically via the API.

Method 1: Via the Truto UI

This is the fastest method for internal teams and administrators looking to connect their own tools.

1. Log into your Truto dashboard and navigate to the Integrated Accounts page.
2. Select your connected Outreach account.
3. Click the MCP Servers tab.
4. Click Create MCP Server.
5. Select your desired configuration (e.g., restrict to read operations only, or filter by specific tool tags).
6. Copy the generated secure MCP server URL. You will need this for Claude.

Method 2: Via the Truto API

If you are building an application and want to programmatically provision MCP servers for your end-users, you can POST to the Truto API.

Request:

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": "Outreach Sales Agent",
    "config": {
      "methods": ["read", "write"]
    }
  }'

Response:

{
  "id": "mcp_abc123",
  "name": "Outreach Sales Agent",
  "config": {
    "methods": ["read", "write"]
  },
  "expires_at": null,
  "url": "https://api.truto.one/mcp/sec_7x8y9z0..."
}

Store the url value securely. This endpoint URL handles the entire JSON-RPC handshake and execution pipeline.

Connecting the MCP Server to Claude

Once you have your Truto MCP URL, you need to register it with your Claude client. You can do this through the Claude application UI or by manually editing the configuration file.

Method A: Via the Claude UI

If you are using Claude's web interface or newer desktop builds that support UI-based connector management:

1. Open Claude and navigate to Settings -> Integrations (or Connectors depending on your plan tier).
2. Click Add MCP Server or Add custom connector.
3. Name the connection (e.g., "Outreach CRM").
4. Paste the Truto MCP URL (https://api.truto.one/mcp/...).
5. Click Add. Claude will immediately perform the initialization handshake and ingest the available Outreach tools.

Method B: Via the Manual Config File

For developers orchestrating Claude Desktop manually or running custom setups, you can define the server in the claude_desktop_config.json file. Because Truto provides a remote HTTP endpoint, you use the standard Server-Sent Events (SSE) adapter.

Open your configuration file (typically located at ~/Library/Application Support/Claude/claude_desktop_config.json on macOS) and append the server definition:

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

Restart Claude Desktop. The application will initialize the server and display the available Outreach tools via the attachment menu.

Hero Tools for Outreach Workflows

Truto exposes dozens of endpoints across the Outreach API, but a few high-leverage tools form the backbone of most AI agent workflows. Here are 6 crucial tools, what they do, and how to prompt Claude to use them.

1. list_all_outreach_prospects

Lists prospects based on search queries. This is typically the first tool Claude will call to locate a target before performing updates. It returns paginated prospect records containing attributes (name, company, emails) and relationships.

Usage Note: Ensure you instruct Claude to filter down lists using query parameters if searching for a specific email to avoid pulling excessive records.

"Find the prospect record for 'jane.doe@example.com' in Outreach so we can review her current engagement status."

2. create_a_outreach_prospect

Creates a new prospect in the Outreach system. Because of the JSON:API requirements, Claude must supply the payload properly wrapped in a data object with a type declaration.

Usage Note: Truto's generated schema automatically guides Claude to format the data.attributes.emails array correctly.

"Create a new prospect in Outreach for John Smith. He works at Acme Corp as a VP of Engineering. His email is john.smith@acmecorp.com."

3. create_a_outreach_call

Logs a new external call. In Outreach, calls must define a direction (inbound or outbound) and an outcome (like completed or no_answer).

Usage Note: You must provide the relationships linking the call to the prospect and the user who made the call.

"Log a completed outbound call in Outreach to Jane Doe. Add a note that we discussed the Q3 pipeline and she wants a follow-up email next week."

4. list_all_outreach_tasks

Retrieves a collection of pending tasks. Tasks represent the actual daily work for a sales rep, including sequence steps (emails to send, calls to make) and manual action items.

Usage Note: Claude can use this tool to prioritize a rep's daily workflow or summarize outstanding obligations.

"Pull my pending tasks for today in Outreach. Summarize the high-priority calls I need to make before noon."

5. outreach_tasks_mark_complete

Marks a specific task as complete. This is critical for advancing sequences and clearing out workflows.

Usage Note: You must provide the exact Task ID. You can also append a completion note documenting what occurred.

"Mark task #48291 as complete. Add a completion note stating that the prospect requested a pricing sheet."

6. list_all_outreach_opportunities

Fetches active opportunities. This is essential for agents performing pipeline reviews or cross-referencing prospect engagement against actual revenue potential.

Usage Note: The response includes relationships to the primary account and specific stages.

"List all open opportunities in Outreach closing this month. Build a quick summary of their current stages and potential values."

To view the complete inventory of available operations, schemas, and required parameters, consult the Outreach integration page.

Workflows in Action

Once connected, Claude can string these tools together to execute multi-step logic. Here are two concrete examples of how Claude navigates the Outreach data model.

Workflow 1: The Daily Sales Briefing

Agents can act as a copilot, summarizing the day's priorities by checking tasks and cross-referencing the associated prospects.

"Look up my pending Outreach tasks for today. For every task involving a call, find the associated prospect and give me a brief summary of their title, company, and any previous notes."

Execution Steps:

1. Claude calls list_all_outreach_tasks using query parameters to filter by today's date and the current user's owner ID.
2. Claude parses the returned JSON:API array, identifying tasks where the taskType is call.
3. Claude extracts the Prospect IDs from the relationships.prospect.data.id field of those tasks.
4. Claude calls get_single_outreach_prospect_by_id for each identified ID to retrieve the prospect's company, title, and recent activity.
5. Claude formats the combined data into a readable daily brief for the user.

sequenceDiagram
    participant User
    participant Claude as Claude Desktop
    participant MCP as Truto MCP
    participant Outreach

    User->>Claude: "Pull my pending call tasks and prospect info."
    Claude->>MCP: Call tool: list_all_outreach_tasks(filters)
    MCP->>Outreach: GET /tasks
    Outreach-->>MCP: [Task #1, Task #2]
    MCP-->>Claude: JSON result
    Claude->>MCP: Call tool: get_single_outreach_prospect_by_id(id: P_123)
    MCP->>Outreach: GET /prospects/P_123
    Outreach-->>MCP: {Prospect Data}
    MCP-->>Claude: JSON result
    Claude-->>User: Formatted daily brief presented.

Workflow 2: Call Logging and Sequence Advancement

A common administrative burden is updating the CRM after an interaction. Claude can handle the logging and the state changes simultaneously.

"I just got off the phone with Sarah Connor from Cyberdyne. We connected, and she wants to move forward. Log the call as completed, and mark her current sequence task as complete."

Execution Steps:

1. Claude calls list_all_outreach_prospects searching for "Sarah Connor" at "Cyberdyne" to obtain her Prospect ID.
2. Claude calls list_all_outreach_tasks filtering for pending tasks associated with her Prospect ID.
3. Claude calls create_a_outreach_call with direction: outbound and outcome: completed, linking the call to Sarah's ID.
4. Claude extracts the Task ID from step 2 and calls outreach_tasks_mark_complete to clear the action item and advance her sequence state.
5. Claude replies to the user confirming the call is logged and the sequence has progressed.

Security and Access Control

Exposing an enterprise sales execution platform to an LLM requires strict boundary controls. Truto's MCP architecture enforces security at the token level, ensuring Claude can only perform approved actions.

• Method Filtering: When generating the MCP server, you can restrict it to specific HTTP verbs. Setting methods: ["read"] ensures Claude can list and fetch records but physically cannot call create, update, or delete tools.
• Tag Filtering: Integrations in Truto group resources by tags. You can configure the MCP server to only expose tools tagged with prospects or tasks, hiding sensitive configuration or billing endpoints from the model.
• Require API Token Auth: By default, the cryptographically secure MCP URL acts as the authentication vector. For strict enterprise environments, enabling require_api_token_auth forces the client connecting to the MCP server to also provide a valid Truto API session token in the headers.
• Time-to-Live (Expires At): You can assign an expires_at ISO datetime when creating the MCP server. Once the timestamp passes, the token is automatically wiped from edge KV storage and database records, instantly cutting off Claude's access.

The Strategic Shift: From Code to Context

Building an integration with Outreach normally requires an engineering team to maintain OAuth flows, handle strictly typed JSON:API serializers, and build custom abstraction layers to make the data digestible.

By routing Claude through a managed MCP server, you eliminate the integration codebase. The API documentation becomes the tool definition, and the LLM handles the orchestration. You provide the context and the prompts, and the managed MCP layer ensures the requests execute securely against the live system. It is a fundamental shift in how teams automate sales execution workflows - moving away from hardcoded scripts and toward dynamic, agent-driven operations.