---
title: "Connect Actionstep to Claude: Automate Tasks, Time, and Contacts"
slug: connect-actionstep-to-claude-automate-tasks-time-and-contacts
date: 2026-11-16
author: Yuvraj Muley
categories: ["AI & Agents"]
excerpt: "Learn how to build a managed MCP server to connect Actionstep to Claude. Automate legal matters, time tracking, and contact management using AI."
tldr: "Connect Actionstep to Claude using Truto's managed MCP server. This guide covers bypassing Actionstep's relational API quirks, handling rate limits, securing agent access, and executing legal workflows via natural language."
canonical: https://truto.one/blog/connect-actionstep-to-claude-automate-tasks-time-and-contacts/
---

# Connect Actionstep to Claude: Automate Tasks, Time, and Contacts


If you need to connect Actionstep to Claude to automate legal matter creation, log billable time, or manage client contacts, 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 between Claude's tool calls and Actionstep'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](https://truto.one/managed-mcp-for-claude-full-saas-api-access-without-security-headaches/). 

If your team uses ChatGPT, check out our guide on [connecting Actionstep to ChatGPT](https://truto.one/connect-actionstep-to-chatgpt-manage-matters-billing-and-files/) or explore our broader architectural overview on [connecting Actionstep to AI Agents](https://truto.one/connect-actionstep-to-ai-agents-sync-legal-case-data-and-workflows/).

Giving a Large Language Model (LLM) read and write access to a sprawling legal practice management system like Actionstep is a massive engineering challenge. You have to handle OAuth 2.0 token lifecycles, map massively nested JSON schemas to MCP tool definitions, and deal with Actionstep's specific data relationship quirks. Every time Actionstep updates an endpoint, deprecates a field, or changes its authentication requirements, you have to update your custom server code, redeploy, and test the integration to ensure your AI agents do not break in production.

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

> Want to give your AI agents secure, authenticated access to Actionstep and 100+ other SaaS APIs? Let's talk about managed MCP architecture.
>
> [Talk to us](https://truto.one/book-a-demo/)

## The Engineering Reality of the Actionstep 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. Actionstep is a highly customizable legal operating system. Because it is designed to support custom workflows, complex data collections, and distinct matter types across different legal jurisdictions, its API structure is exceptionally relational and strict. Exposing this directly to an LLM without a robust abstraction layer results in consistent hallucination and failed tool calls.

If you decide to [build a custom Actionstep MCP server](https://truto.one/the-hands-on-guide-to-building-mcp-servers-for-ai-agents-2026/), here are the specific integration challenges you will face:

**The JSON:API Envelope and Relationship Links**
Actionstep does not use flat JSON payloads for mutations. When you create or update a record, the payload must be wrapped in a specific root key (e.g., `{"actions": {...}}` for matters, `{"timeentries": {...}}` for time records). More importantly, relationships are managed through a strict `links` object hierarchy. If you want to assign a task to a user or link a time entry to a matter, the LLM cannot simply pass a `matter_id = 123` field. It must construct a deeply nested payload that places those relational IDs inside the `links` schema. Truto's proxy layer normalizes this complexity, presenting a flat, predictable schema to Claude and handling the envelope wrapping automatically before the request hits Actionstep.

**Strict Pagination Constraints**
Actionstep enforces a specific `page` and `pageSize` pagination scheme, with a default limit of 50 and a strict hard cap of 200 records per request. When an AI agent asks to "list all open matters for the firm", returning a massive unpaginated array will blow out Claude's context window and crash the session. The MCP server must explicitly guide the model to paginate using cursor or page state, preventing the LLM from attempting to ingest thousands of legal records at once.

**Handling Rate Limits and HTTP 429s**
Actionstep enforces strict concurrency and rate limits on API requests to protect their infrastructure. Truto normalizes upstream rate limit information into standardized headers (`ratelimit-limit`, `ratelimit-remaining`, `ratelimit-reset`) per the IETF specification. However, it is critical to note that Truto does not automatically retry, throttle, or apply backoff on rate limit errors. When Actionstep returns an HTTP 429 Too Many Requests, Truto passes that error directly back to the caller. The LLM or the orchestrating client is entirely responsible for reading these standardized headers and executing the appropriate retry and backoff logic. Do not build your application expecting the integration layer to absorb rate limits for you.

## Generating the Actionstep MCP Server

Truto maps Actionstep's endpoints into dynamic MCP tools based on active documentation records. To expose these tools to Claude, you need to generate an MCP server URL. You can do this via the Truto UI or programmatically via the API.

### Method 1: Via the Truto UI
If you are configuring this for an internal team or a proof of concept, using the UI is the fastest path to deployment.

1. Log in to your Truto dashboard and navigate to the **Integrated Account** page for your active Actionstep connection.
2. Click the **MCP Servers** tab.
3. Click the **Create MCP Server** button.
4. Select your desired configuration. You can specify a custom name, restrict allowed methods (e.g., read-only), apply specific tags to group tools, and set an expiration date for the server.
5. Click Save and copy the generated MCP server URL. This URL contains a hashed cryptographic token mapping directly to this specific Actionstep tenant.

### Method 2: Via the Truto API
If you are provisioning MCP servers dynamically for your own SaaS users at scale, you should generate them programmatically via the API. This requires your Truto API token.

```bash
curl -X POST https://api.truto.one/integrated-account/{integrated_account_id}/mcp \
  -H "Authorization: Bearer YOUR_TRUTO_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Actionstep Billing Agent",
    "config": {
      "methods": ["read", "write"],
      "require_api_token_auth": false
    },
    "expires_at": "2025-12-31T23:59:59Z"
  }'
```

The API will validate the configuration, generate the secure token, and return a response containing the `url` (e.g., `https://api.truto.one/mcp/a1b2c3d4e5f6...`). This URL is fully self-contained and ready to be loaded into your AI client.

## Connecting the MCP Server to Claude

Once you have the Truto MCP URL, you must register it with your AI client. Truto exposes standard JSON-RPC 2.0 over HTTP Server-Sent Events (SSE), making it compatible with any modern MCP client.

### Option A: Via the Claude UI
For enterprise users on Claude for Work (Team or Enterprise) or ChatGPT Plus/Enterprise, organization owners can add custom connectors directly through the application settings.

1. Open Claude and navigate to **Settings -> Integrations -> Add MCP Server** (or if you are using ChatGPT: **Settings -> Connectors -> Add custom connector**).
2. Provide a descriptive name for the integration, like "Actionstep Legal Server".
3. Paste the Truto MCP URL you generated in the previous step.
4. Click **Add**. The AI client will immediately execute an `initialize` handshake, request the tool definitions, and make them available in the prompt interface.

### Option B: Via the Claude Desktop Config File
For engineers running Claude Desktop locally, you configure the server using your local JSON configuration file. Because Truto uses an SSE transport layer, you will use the `@modelcontextprotocol/server-sse` wrapper to establish the connection.

Open your configuration file (located at `~/Library/Application Support/Claude/claude_desktop_config.json` on macOS or `%APPDATA%\Claude\claude_desktop_config.json` on Windows) and add the following block:

```json
{
  "mcpServers": {
    "actionstep": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-sse",
        "https://api.truto.one/mcp/YOUR_TRUTO_TOKEN"
      ]
    }
  }
}
```

Save the file and restart Claude Desktop. The Actionstep tools will now be visible as a plug icon in the prompt input bar, ready for invocation.

## Security and Access Control

Giving an AI agent access to sensitive law firm data requires strict boundary management. Truto enforces security at the MCP token layer before the request ever reaches Actionstep's servers.

*   **Method Filtering:** You can restrict a server to read-only operations by passing `methods: ["read"]` during creation. This prevents the LLM from accidentally mutating matter records, deleting files, or altering billing rates during a hallucination.
*   **Tag Filtering:** Limit the agent to specific operational domains. Passing `tags: ["billing", "time"]` ensures the server only exposes endpoints related to invoices and time tracking, completely hiding raw contact or case document endpoints from the model's context.
*   **Time-to-Live (TTL):** Use the `expires_at` field to create ephemeral MCP servers. The token will automatically self-destruct via a scheduled alarm when the time expires, immediately cutting off agent access without requiring manual cleanup.
*   **Secondary Authentication:** By default, the MCP URL acts as a bearer token. For highly sensitive enterprise deployments, enable `require_api_token_auth: true`. The client must then pass a valid Truto API token in the `Authorization` header to successfully invoke tools, adding a strict secondary identity check.

## Actionstep Hero Tools for Claude

Truto dynamically derives MCP tools from Actionstep's API documentation. Here are the core high-leverage tools your agent will use to automate practice management tasks.

### list_all_actionstep_actions
Returns a collection of Matters (referred to internally as Actions). This is the primary discovery tool for finding specific cases before logging time or adding participants. The tool explicitly handles the `page` and `pageSize` pagination parameters.

> "List all active matters related to the Smith settlement. Limit the results to 5 records."

### create_a_actionstep_task
Creates a new task assigned to a user or linked to a specific matter. The LLM must supply a `name`, `status`, and `dueTimestamp`. Truto handles wrapping the payload into the required `{"tasks": {...}}` schema structure and mapping the relationship links automatically.

> "Create a new high-priority task for matter ID 140 to review the finalized lease agreement by tomorrow at 5 PM."

### create_a_actionstep_time_entry
Logs a new time entry against a matter. Requires `timestampDate` and `actualHours`. This is highly effective when paired with email summaries or meeting transcript analyses to autonomously generate billing logs.

> "Log 1.5 hours of time for today on matter ID 205. The description should be 'Client consultation and initial document review'."

### list_all_actionstep_participants
Retrieves the collection of participants (contacts, attorneys, judges, plaintiffs) linked to matters. This tool allows the agent to extract contact details before drafting correspondence or reviewing conflict checks.

> "Get the list of all participants assigned to the Johnson merger matter. I need the email address of the primary opposing counsel."

### create_a_actionstep_file_note
Appends a text note directly to a matter's file. This is crucial for autonomous agents that need to log summaries of phone calls or output from other analytical tasks directly into the firm's source of truth.

> "Add a file note to matter ID 88 summarizing the key risks we found in the liability clause of the attached document."

### update_a_actionstep_action_by_id
Updates the properties of a specific matter. Used for progressing a case through workflow stages or updating core metadata. Requires the Actionstep matter `id`.

> "Update matter ID 312 to change its status to closed and append '- Finalized' to the matter title."

For the complete inventory of Actionstep tools and their precise JSON schema definitions, visit the [Actionstep integration page](https://truto.one/integrations/detail/actionstep).

## Workflows in Action

With the MCP server connected and authenticated, Claude can now execute multi-step legal workflows autonomously. Here are two practical examples of domain-specific operations.

### Scenario 1: Legal Triage and Task Delegation
When a senior attorney receives an influx of case updates via email, they can ask Claude to orchestrate the downstream tasks in Actionstep without opening the application.

> "I just received the executed contracts for the Miller case. Find the matter, update the status, create a file note that the contracts are signed, and assign a task to the paralegal to prepare the closing binders."

**Execution flow:**
1. Claude calls `list_all_actionstep_actions` querying for "Miller" to retrieve the exact matter ID.
2. Claude calls `update_a_actionstep_action_by_id` to adjust the matter status reflecting the execution.
3. Claude calls `create_a_actionstep_file_note` to log the contract execution permanently in the file.
4. Claude calls `create_a_actionstep_task` to assign the closing binder prep to the paralegal.

```mermaid
sequenceDiagram
    participant User as User
    participant Claude as Claude Desktop
    participant Truto as Truto MCP
    participant Actionstep as Actionstep API

    User->>Claude: "Update Miller case and<br>create binder task"
    Claude->>Truto: list_all_actionstep_actions
    Truto->>Actionstep: GET /actions?q=Miller
    Actionstep-->>Truto: Return Matter ID 44
    Truto-->>Claude: JSON Array
    Claude->>Truto: update_a_actionstep_action_by_id
    Truto->>Actionstep: PUT /actions/44
    Actionstep-->>Truto: 200 OK
    Claude->>Truto: create_a_actionstep_file_note
    Truto->>Actionstep: POST /filenotes
    Actionstep-->>Truto: 201 Created
    Claude->>Truto: create_a_actionstep_task
    Truto->>Actionstep: POST /tasks
    Actionstep-->>Truto: 201 Created
    Truto-->>Claude: JSON Result
    Claude-->>User: "Miller matter updated. File note logged.<br>Paralegal task created."
```

### Scenario 2: Automated Time Tracking from Meetings
Tracking billable hours is a massive friction point for law firms. By connecting Claude to Actionstep, you can parse unstructured summaries or meeting transcripts into structured time records instantly.

> "I spent 45 minutes on a Zoom call negotiating the terms of the commercial lease for matter 109, and another 30 minutes drafting the revisions. Log these as two separate time entries."

**Execution flow:**
1. Claude parses the natural language into two distinct time blocks (0.75 hours and 0.5 hours).
2. Claude calls `create_a_actionstep_time_entry` for the 0.75 hour block, formatting the description specifically for the negotiation.
3. Claude calls `create_a_actionstep_time_entry` for the 0.5 hour block, formatting the description for the drafting work.

The user receives immediate confirmation that 1.25 hours of billable time has been successfully synced to the correct matter in Actionstep, bypassing the complex manual UI entry entirely.

## Stop Wrestling with Legal APIs

[Building an Actionstep integration from scratch](https://truto.one/the-hands-on-guide-to-building-mcp-servers-for-ai-agents-2026/) means writing thousands of lines of boilerplate to handle nested `links` structures, normalizing 429 rate limit responses, and mapping complex entity relationships. Truto abstracts the infrastructure away entirely, providing a dynamic, secure MCP server that your AI agents can connect to instantly.

> Want to give your AI agents secure, authenticated access to Actionstep and 100+ other SaaS APIs? Let's talk about managed MCP architecture.
>
> [Talk to us](https://truto.one/book-a-demo/)
