Connect Aspire to Claude: Sync work tickets, inventory and invoicing

If your team needs to connect Aspire to Claude to automate field operations, allocate inventory, or oversee work ticket lifecycles, you need a Model Context Protocol (MCP) server. This server acts as the translation layer between Claude's natural language tool calls and Aspire's specialized field service management API. 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-aspire-to-chatgpt-manage-field-operations-and-financials/ or explore our broader architectural overview on /connect-aspire-to-ai-agents-automate-service-tracking-and-crm-data/.

Giving a Large Language Model (LLM) read and write access to a complex operational system like Aspire is an engineering challenge. You have to handle unique authentication lifecycles, map massive JSON schemas to MCP tool definitions, and deal with Aspire's specific data constraints. Every time an endpoint changes, 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 Aspire, connect it natively to Claude Desktop, and execute complex field service workflows using natural language.

The Engineering Reality of the Aspire 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 Aspire's APIs is painful. Aspire is built for heavy-duty field service management - encompassing CRM opportunities, property routing, equipment logs, and inventory allocation. Its API reflects that domain complexity.

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

Non-Standard Update Payloads REST purists expect update operations (PUT or PATCH) to accept the resource ID in the URL path (e.g., PUT /companies/{id}). Aspire frequently diverges from this pattern for bulk updates. For endpoints like aspire_companies_bulk_update or aspire_properties_bulk_update, Aspire requires the unique ID (like CompanyID or PropertyID) to be passed inside the request body payload, not the URL. If you expose this directly to an LLM, the model will constantly hallucinate URL paths and fail to include the required ID in the body. Your MCP server must strictly enforce these custom JSON Schemas to guide the LLM to format the payload exactly as Aspire expects.

Short-Lived Authentication Tokens Aspire uses a specific token exchange mechanism via create_a_aspire_access_token. You must exchange a Client ID and Secret Key for an authorization token and a refresh token. These tokens last exactly 24 hours. A custom MCP server must implement a background worker to proactively call the refresh endpoint every 12-20 hours, manage the state of the new token pair, and handle race conditions if an LLM calls a tool right as a token expires.

OData-Style Pagination Constraints Aspire handles large datasets (like thousands of work tickets or inventory logs) using a specific OData-style pagination scheme with $pageNumber and $limit. The default limit is heavy (1,000 per page), which can easily blow out an LLM's context window if the model calls a list endpoint without filtering. Your MCP server needs an abstraction layer that intercepts list calls, enforces safer limits, and passes exact cursor instructions to the LLM to prevent context overflow.

How to Generate an Aspire MCP Server with Truto

Truto eliminates the need to build a custom integration layer. Instead of writing boilerplate code, Truto automatically derives MCP tools from your connected Aspire account's documentation records and serves them over a secure JSON-RPC 2.0 endpoint.

You can create an Aspire MCP server in Truto using either the UI or the API.

Method 1: Via the Truto UI

1. Log into your Truto dashboard and navigate to the Integrated Accounts page.
2. Select your connected Aspire account.
3. Click the MCP Servers tab.
4. Click Create MCP Server.
5. Select your desired configuration (name, allowed methods, tags, and optional expiry).
6. Click Save and copy the generated MCP server URL (e.g., https://api.truto.one/mcp/a1b2c3d4e5f6...).

Method 2: Via the Truto API

For teams building automated agent provisioning, you can generate MCP servers programmatically. This POST request validates that the integration has tools available, generates a secure hashed token, stores it in KV storage, and returns a ready-to-use URL.

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": "Aspire Operations Agent",
    "config": {
      "methods": ["read", "write"],
      "tags": ["work_tickets", "inventory"]
    }
  }'

How to Connect the MCP Server to Claude

Once you have your Truto MCP URL, connecting it to Claude takes less than a minute. You can do this visually in the UI or via a configuration file for Claude Desktop.

Method A: Via the Claude UI (or ChatGPT)

If you are using Claude's web interface (or ChatGPT with custom actions):

1. In Claude, navigate to Settings -> Integrations -> Add MCP Server (or Settings -> Connectors -> Add in ChatGPT).
2. Paste the Truto MCP URL you generated above.
3. Click Add. Claude will immediately handshake with the server, returning a list of available Aspire tools.

Method B: Via the Claude Desktop Config File

For local development or running Claude Desktop, you can add the server directly to your claude_desktop_config.json file using the official Server-Sent Events (SSE) transport.

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

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

Restart Claude Desktop. You will now see the Aspire tools available as a hammer icon in your input bar.

6 Hero Tools for Aspire Automation

Truto automatically generates tools for every documented endpoint in the Aspire API. Here are the 6 highest-leverage tools for automating field service and financial operations.

list_all_aspire_work_tickets

Retrieves a paginated list of work tickets. This is the foundation of field operations, representing the actual labor scheduled or completed for a won opportunity.

"Find all active work tickets assigned to the South Branch for today, and extract the property IDs and scheduled start times."

create_a_aspire_as_needed_work_ticket

Automatically generates work tickets based on opportunity services that need them. Essential for bridging the gap between closing a sale and dispatching a crew.

"The 'Oakwood Estate' opportunity was just marked won. Generate the as-needed work tickets for this contract starting next Monday at 8 AM."

list_all_aspire_item_allocations

Retrieves inventory item allocations. Use this to audit whether crews have the required materials (mulch, fertilizer, parts) allocated to their work tickets before they leave the yard.

"Check the inventory allocation for catalog item 9942 (Premium Mulch) across all work tickets scheduled for tomorrow at the North yard."

create_a_aspire_equipment_reading_log

Adds an equipment reading log (e.g., meter readings, hour tracking). Critical for fleet management and triggering preventative maintenance on expensive assets.

"Log 450 hours on the John Deere mower ID 8912 for today's date. If the total hours exceed 500, generate an alert note that it needs maintenance."

list_all_aspire_opportunities

Retrieves potential or actual work contracts. Use this to monitor the sales pipeline and forecast upcoming resource requirements.

"Pull all opportunities marked as won this week and summarize the total estimated revenue variance."

list_all_aspire_invoices

Retrieves billing statements for services charged to customers. Crucial for financial reconciliation and tracking accounts receivable.

"Fetch all unpaid invoices for property group A from the last 30 days and calculate the total outstanding balance."

To view the complete inventory of available endpoints and schema details, visit the Aspire integration page.

Workflows in Action

Connecting Aspire to Claude transforms static dashboards into dynamic, conversational operations centers. Here is how specific personas execute complex workflows.

Scenario 1: Converting a Won Opportunity into Dispatched Work

Persona: Field Operations Manager

"The 'Riverwalk HOA' landscaping contract just closed. Find the opportunity, generate the necessary work tickets for next week, and verify that we have enough 'Spring Fertilizer' allocated for the job."

Execution Steps:

1. list_all_aspire_opportunities: Claude queries the API for the opportunity named "Riverwalk HOA" to retrieve its ID and service details.
2. create_a_aspire_as_needed_work_ticket: Claude passes the opportunity data and scheduled start dates to generate the required work tickets for the crew.
3. list_all_aspire_catalog_items: Claude searches the catalog to find the exact ID for "Spring Fertilizer".
4. create_a_aspire_item_allocation: Claude allocates the required quantity of fertilizer from the inventory location to the newly created work ticket.

Result: The operations manager has successfully bridged the gap between sales and operations in seconds. The crew has their work tickets generated, and warehouse staff knows exactly what materials to load onto the trucks.

sequenceDiagram
    participant User as Operations Manager
    participant Claude as Claude Desktop
    participant Truto as Truto MCP
    participant Aspire as Aspire API

    User->>Claude: "Contract closed. Generate tickets & allocate fertilizer."
    Claude->>Truto: call tool: list_all_aspire_opportunities
    Truto->>Aspire: GET /Opportunities
    Aspire-->>Truto: Return opportunity ID
    Truto-->>Claude: Return opportunity ID
    Claude->>Truto: call tool: create_a_aspire_as_needed_work_ticket
    Truto->>Aspire: POST /WorkTickets/AsNeeded
    Aspire-->>Truto: Return new ticket IDs
    Truto-->>Claude: Return new ticket IDs
    Claude->>Truto: call tool: create_a_aspire_item_allocation
    Truto->>Aspire: POST /ItemAllocations
    Aspire-->>Truto: Success confirmation
    Truto-->>Claude: Success confirmation
    Claude-->>User: "Tickets generated and fertilizer allocated."

Scenario 2: End-of-Day Equipment Logging & Issue Reporting

Persona: Fleet Supervisor

"Log 8 hours of usage on Truck 4. Also, the driver reported a cracked windshield, so log an issue against the truck and assign it to the maintenance team."

Execution Steps:

1. list_all_aspire_equipments: Claude searches the equipment list for "Truck 4" to retrieve its internal EquipmentID.
2. create_a_aspire_equipment_reading_log: Claude logs the 8 hours against the specific vehicle ID for today's date.
3. list_all_aspire_users: Claude finds the user ID for the maintenance team lead.
4. create_a_aspire_issue: Claude generates a new issue record attached to the equipment, detailing the cracked windshield, and assigns it to the maintenance lead.

Result: The fleet supervisor completes their end-of-day logging via chat instead of navigating through multiple nested menus in the Aspire UI. The maintenance team is immediately alerted to the safety issue.

Security and Access Control

Giving an AI agent access to core operational and financial data requires strict boundaries. Truto's MCP server architecture provides multiple layers of security to ensure Claude only touches what you authorize.

• Method Filtering: You can restrict a server to specific operations. Setting config.methods to ["read"] ensures the agent can query work tickets and invoices, but cannot create or modify them.
• Tag Filtering: Limit the server's scope by functional area. Use config.tags like ["operations"] to expose work tickets and equipment logs, while completely hiding financial endpoints like invoices or bank deposits.
• Secondary Authentication: By enabling require_api_token_auth, Truto forces the client to provide a valid API token in addition to the server URL, adding a critical layer of identity verification.
• Ephemeral Access: Use the expires_at field to create temporary MCP servers. This is perfect for giving a contractor or a temporary AI workflow agent access that automatically revokes itself after a specific time.

Wrap-Up

Connecting Aspire to Claude via a managed MCP server removes the friction between natural language intent and field service execution. Instead of forcing operations managers and fleet supervisors to navigate complex software menus, they can converse directly with their business data. Truto handles the painful reality of OData pagination, ID-in-body updates, and 24-hour token refreshes, allowing your engineering team to focus on building high-value agentic workflows instead of maintaining brittle integration code.