Connect AccuLynx to ChatGPT: Manage Jobs, Leads, and Appointments

If you need to connect AccuLynx to ChatGPT to automate roofing sales workflows, manage field appointments, or orchestrate job estimates, you need a Model Context Protocol (MCP) server. This server acts as the translation layer between ChatGPT's tool calls and AccuLynx'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 Claude, check out our guide on connecting AccuLynx to Claude or explore our broader architectural overview on connecting AccuLynx to AI Agents.

Giving a Large Language Model (LLM) read and write access to a specialized construction CRM like AccuLynx is a massive engineering challenge. You have to handle complex relational data payloads, map dynamic custom fields to MCP tool definitions, and deal with deeply nested API structures.

This guide breaks down exactly how to use Truto to generate a secure, managed MCP server for AccuLynx, connect it natively to ChatGPT, and execute complex field service workflows using natural language.

The Engineering Reality of the AccuLynx 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, implementing it against AccuLynx's highly specific API is exceptionally painful.

If you decide to build a custom MCP server for AccuLynx, you own the entire API lifecycle. Here are the specific integration challenges that break standard CRUD assumptions when working with AccuLynx:

Deeply Nested Hierarchies

AccuLynx data structures are deeply relational. A standard job has associated estimates, but those estimates are further broken down into sections, and those sections contain items. For example, to retrieve or update an estimate item, you cannot just query an item_id. The endpoint requires the estimate_id and the estimate_section_id. If an LLM needs to adjust the price of a specific shingle on an estimate, your MCP server must first guide the LLM to traverse the tree (Job -> Estimate -> Section -> Item) before it can make the update. Failing to expose these dependencies in the JSON schema will result in LLM hallucinations and 404 errors.

Custom Field Validation Constraints

Roofing and contracting companies customize AccuLynx heavily. Updating these custom fields is done via bulk update endpoints (e.g., updating contact custom fields or job custom fields). AccuLynx imposes strict validation limits: you cannot update more than 120 custom fields in a single request, and text fields strictly truncate at 500 characters. If ChatGPT attempts to summarize a lengthy client interaction and write it to a custom text field, a naive MCP server will pass the 1,000-character payload and AccuLynx will truncate it, causing silent data loss.

Multipart Form Data for Field Operations

AccuLynx handles heavy file operations, such as uploading job photos, videos, or XML/JSON measurement files. These operations require multipart/form-data uploads rather than standard JSON payloads. Your MCP server must be capable of translating an LLM's file reference into a binary stream, attaching the correct metadata (like documentFolderId or providerMeasurementOrderId), and executing the multipart upload.

Managing Rate Limits

When making high-volume API requests across multiple jobs and estimates, you will hit AccuLynx's rate limits. It is critical to understand Truto's architectural stance here: Truto does not retry, throttle, or apply backoff on rate limit errors. When the upstream AccuLynx 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. The caller (or the agentic framework executing the tool) is fully responsible for reading these headers and implementing its own retry or backoff logic.

AccuLynx to ChatGPT Quickstart Guide

If you just want the fastest path from a fresh Truto account to ChatGPT calling the AccuLynx API, follow these steps.

What you need:

• A Truto account with API access.
• An AccuLynx account with administrative access to approve the OAuth consent or API key generation.
• A ChatGPT Pro, Plus, Business, Enterprise, or Education seat with Developer mode available.

Step 1: Connect AccuLynx as an Integrated Account

First, you need to establish the core connection between Truto and your AccuLynx instance. In the Truto dashboard, navigate to Integrated Accounts -> New Integrated Account, select AccuLynx, and complete the authentication flow. Truto securely manages the underlying credentials.

Step 2: Grab your integrated_account_id

You can copy this ID directly from the account detail page in the Truto UI, or retrieve it via the Truto API:

curl https://api.truto.one/integrated-account \
  -H "Authorization: Bearer $TRUTO_API_TOKEN"

Step 3: Generate an AccuLynx MCP Server

Truto scopes MCP servers to individual integrated accounts. You can create the server using either the Truto UI or the API.

Option A: Via the Truto UI

1. Navigate to the integrated account page for your AccuLynx connection.
2. Click the MCP Servers tab.
3. Click Create MCP Server.
4. Select your desired configuration (e.g., name, allowed methods, tags, and expiry).
5. Copy the generated MCP server URL.

Option B: Via the API Make a POST request to generate the MCP endpoint. You can filter by methods and tags to strictly limit what ChatGPT can do.

curl -X POST https://api.truto.one/integrated-account/$INTEGRATED_ACCOUNT_ID/mcp \
  -H "Authorization: Bearer $TRUTO_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "AccuLynx for ChatGPT",
    "config": {
      "methods": ["read", "write"],
      "tags": ["jobs", "contacts", "appointments"]
    }
  }'

The response contains a url field (e.g., https://api.truto.one/mcp/<token>). This URL acts as the routing and authentication layer for the MCP protocol. Treat it like a secret.

Step 4: Connect the MCP Server to ChatGPT

You can expose this server to ChatGPT using either the desktop application UI or a configuration file.

Option A: Via the ChatGPT UI

1. Open ChatGPT and navigate to Settings -> Apps -> Advanced settings.
2. Enable Developer mode (required for MCP custom connectors).
3. Under MCP servers / Custom connectors, click add.
4. Enter a name (e.g., "AccuLynx via Truto") and paste the MCP server URL you copied in Step 3.
5. Click Add or Save. ChatGPT will immediately handshake with the URL and list the available AccuLynx tools.

Option B: Via Manual Config File If you are configuring this programmatically for local agent testing (e.g., using a desktop client that relies on a config file), you can set up the Server-Sent Events (SSE) transport wrapper. Add the following to your configuration file:

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

Hero Tools for AccuLynx

Truto automatically generates LLM-ready tools based on AccuLynx's API documentation. Here are the most critical, high-leverage tools available for your AI agents.

List All AccuLynx Jobs

Tool Name: list_all_accu_lynx_jobs

This tool retrieves a paginated listing of Jobs. It is the starting point for almost all field service operations. It supports filtering by startDate and endDate, which default to filtering on the CreatedDate.

"Get all the AccuLynx jobs created in the last 7 days and summarize their current status."

Create a Contact

Tool Name: create_a_accu_lynx_contact

Contacts are the foundational entity in AccuLynx; jobs cannot exist without a primary contact. This tool creates a new contact record, processing basic information, phone numbers, and addresses.

"We have a new lead: Sarah Connor at 555-0199. Create a new contact record for her in AccuLynx."

Create a Job

Tool Name: create_a_accu_lynx_job

Once a contact exists, this tool provisions a new job. Jobs are created in the 'Lead' milestone with an 'Unassigned' representative by default. The LLM must pass the valid contact ID to link the primary contact.

"Create a new job for contact ID 12345 to evaluate their roof for hail damage."

Update Job Initial Appointment

Tool Name: accu_lynx_job_initial_appointments_bulk_update

This is a critical scheduling tool. It allows the agent to add or modify the initial appointment for a job. The LLM handles passing the datetimes in the required UTC ISO 8601 format (suffixed with 'Z').

"Schedule the initial appointment for job ID 9876 for tomorrow at 2:00 PM UTC."

List All Job Estimates

Tool Name: list_all_accu_lynx_job_estimates

Retrieves the estimates tied to a specific job ID. This is vital for AI agents calculating potential revenue, reviewing line items with customers, or identifying jobs that need financial follow-up.

"Pull the estimates for the Smith job (ID 5544) and tell me the total amount quoted."

Create Job Message

Tool Name: create_a_accu_lynx_job_message

Posts a comment directly to the job's message feed. This makes the comment visible in the AccuLynx web and mobile apps, bridging the gap between the AI agent's logic and the human field workers using the mobile app.

"Post a message on job ID 9876 tagging the sales rep, asking them to verify the shingle color with the homeowner before ordering materials."

For the complete inventory of AccuLynx tools, JSON schemas, and required parameters, visit the AccuLynx integration page.

Workflows in Action

Connecting tools is just the beginning. The real power of MCP is allowing ChatGPT to orchestrate complex, multi-step business logic across AccuLynx data.

Workflow 1: Lead Qualification and Job Provisioning

When a new inbound request arrives (e.g., via a website chatbot or email), the AI agent must verify if the contact exists, create them if they don't, provision the job, and queue the initial site visit.

"A new customer, Michael Scott (michael@example.com), wants a roof inspection. Check if he exists. If not, add him as a contact, create a new job for an inspection, and schedule the initial appointment for next Tuesday at 9 AM UTC."

Execution Steps:

1. ChatGPT calls list_all_accu_lynx_contact_search_results (or the equivalent list endpoint) passing the email or name to verify existence.
2. If no match is found, ChatGPT calls create_a_accu_lynx_contact with the provided details.
3. Using the returned Contact ID, ChatGPT calls create_a_accu_lynx_job to initialize the project pipeline.
4. Using the returned Job ID, ChatGPT calls accu_lynx_job_initial_appointments_bulk_update to lock in the Tuesday 9 AM UTC appointment.

sequenceDiagram
    participant User as User Prompt
    participant ChatGPT as ChatGPT
    participant TrutoMCP as Truto MCP Server
    participant AccuLynx as AccuLynx API

    User->>ChatGPT: "Create contact, job, and appointment"
    ChatGPT->>TrutoMCP: Call list_all_accu_lynx_contact_search_results
    TrutoMCP->>AccuLynx: POST /api/v2/contacts/search
    AccuLynx-->>TrutoMCP: Empty Result
    TrutoMCP-->>ChatGPT: No contact found
    ChatGPT->>TrutoMCP: Call create_a_accu_lynx_contact
    TrutoMCP->>AccuLynx: POST /api/v2/contacts
    AccuLynx-->>TrutoMCP: Contact ID: 123
    TrutoMCP-->>ChatGPT: Contact created
    ChatGPT->>TrutoMCP: Call create_a_accu_lynx_job (Contact: 123)
    TrutoMCP->>AccuLynx: POST /api/v2/jobs
    AccuLynx-->>TrutoMCP: Job ID: 456
    TrutoMCP-->>ChatGPT: Job created
    ChatGPT->>TrutoMCP: Call accu_lynx_job_initial_appointments_bulk_update
    TrutoMCP->>AccuLynx: PUT /api/v2/jobs/456/initial-appointment
    AccuLynx-->>TrutoMCP: 200 OK
    TrutoMCP-->>ChatGPT: Appointment scheduled
    ChatGPT-->>User: "I have created the contact, set up the job, and booked the appointment."

Workflow 2: Estimate Review and Field Escalation

Sales managers spend hours reviewing stagnant jobs. An AI agent can proactively audit estimates and alert field reps via the AccuLynx message feed.

"Find all jobs created this month. Check their estimates. For any job with an estimate but no initial appointment set, post a message to the job feed asking the team to schedule a follow-up immediately."

Execution Steps:

1. ChatGPT calls list_all_accu_lynx_jobs using the startDate and endDate parameters for the current month.
2. For each returned job, ChatGPT calls list_all_accu_lynx_job_estimates and list_all_accu_lynx_job_initial_appointments.
3. The LLM evaluates the results in its context window. If a job has estimates > 0 but the appointment array is empty, it identifies a stalled pipeline.
4. ChatGPT calls create_a_accu_lynx_job_message for each stalled job, pushing an alert directly to the mobile app of the assigned rep.

Security and Access Control

Giving AI agents access to a production CRM requires tight security. Truto's MCP servers are designed to limit blast radius through strict, server-level configurations:

• Method Filtering: Restrict servers to specific operations. By passing config: { methods: ["read"] } during creation, the server will only generate tools for GET and list endpoints, entirely preventing the AI from creating or updating AccuLynx data.
• Tag Filtering: Scope the server to specific business domains. Using config: { tags: ["jobs", "estimates"] } ensures the LLM cannot access unrelated endpoints like webhooks or company settings.
• Token Authentication: By enabling require_api_token_auth: true, the MCP server requires the client to pass a valid Truto API token in the Authorization header, ensuring that possessing the MCP URL alone is not enough to execute tools.
• Time-To-Live (TTL): Set an expires_at ISO datetime when generating the server. Once the timestamp passes, Truto's Durable Object alarms automatically delete the underlying KV records and database entries, instantly revoking access.

Rethinking CRM Automation with AI

Integrating AccuLynx with ChatGPT fundamentally changes how roofing and contracting teams interact with their data. Instead of forcing reps to navigate complex UI menus to check estimate statuses or log initial appointments, they can direct an AI agent to handle the heavy lifting.

By leveraging Truto's MCP server infrastructure, you bypass the massive technical debt of building custom API parsers, handling OAuth refreshes, and writing tedious JSON schemas. Truto dynamically converts AccuLynx's API surface into LLM-native tools, so you can focus on building intelligent workflows instead of wrestling with CRM documentation.