---
title: "Connect Housecall Pro to ChatGPT: Manage Jobs & Field Dispatch"
slug: connect-housecall-pro-to-chatgpt-manage-jobs-field-dispatch
date: 2026-10-10
author: Riya Sethi
categories: ["AI & Agents"]
excerpt: "Learn how to connect Housecall Pro to ChatGPT using an MCP server. Automate field dispatch, job scheduling, and estimates with natural language."
tldr: "A technical guide to building a Housecall Pro MCP server for ChatGPT. Covers Truto setup, handling complex job and estimate payloads, resolving API quirks, and securing AI tool access."
canonical: https://truto.one/blog/connect-housecall-pro-to-chatgpt-manage-jobs-field-dispatch/
---

# Connect Housecall Pro to ChatGPT: Manage Jobs & Field Dispatch


If you need to connect Housecall Pro to ChatGPT to automate field dispatch operations, generate estimates, or orchestrate job scheduling, 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 ChatGPT's tool calls and Housecall Pro's REST APIs. You can either [build and maintain this infrastructure yourself](https://truto.one/how-to-build-mcp-servers-for-ai-agents-2026-hands-on-architecture-guide/), or use a [managed integration platform like Truto to dynamically generate](https://truto.one/auto-generated-mcp-tools-for-ai-agents-a-2026-architecture-guide/) a secure, authenticated MCP server URL.

If your team uses Claude, check out our guide on [connecting Housecall Pro to Claude](https://truto.one/connect-housecall-pro-to-claude-track-leads-sales-estimates/) or explore our broader architectural overview on [connecting Housecall Pro to AI Agents](https://truto.one/connect-housecall-pro-to-ai-agents-automate-invoices-inventory/).

Giving a Large Language Model (LLM) read and write access to a comprehensive field service management platform like Housecall Pro is a massive engineering challenge. You have to handle complex scheduling logic, nested line items within estimate options, and destructive bulk update operations. Every time a developer adds a new resource or updates a schema in Housecall Pro, your custom server code must be updated, redeployed, and tested. 

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

> Stop writing boilerplate API integration code. Let Truto generate secure, managed MCP servers for your AI agents in seconds.
>
> [Talk to us](https://truto.one/book-a-demo/)

## The Engineering Reality of the Housecall Pro API

A [custom MCP server](https://truto.one/how-to-build-mcp-servers-for-ai-agents-2026-hands-on-architecture-guide/) is a self-hosted integration layer. While the open MCP standard provides a predictable way for models to discover tools over JSON-RPC 2.0, implementing it against Housecall Pro's highly specific field service architecture requires navigating several platform-specific quirks.

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

### Destructive Bulk Line Item Updates
When manipulating job line items, Housecall Pro relies heavily on a bulk update endpoint (`housecall_pro_job_line_items_bulk_update`). If an AI agent attempts to append a single line item using this endpoint, it can inadvertently wipe out the entire invoice. By default, the `append_line_items` flag is set to `false`. Any existing line items omitted from the request body are instantly deleted. Your MCP server must force the agent to either fetch the entire array first and append to it, or strictly utilize the single-creation endpoint (`create_a_housecall_pro_job_line_item`) while managing the associated rate limits.

### Schedules versus Appointments
The Housecall Pro API treats scheduling with extreme granularity. Jobs have a base schedule, but a multi-day job might have several discrete appointments. If a job has a multi-day schedule containing more than one appointment, the standard `housecall_pro_job_schedules_bulk_update` endpoint will reject the request. The LLM must be trained to introspect the job, identify if it is a multi-day multi-appointment entity, and pivot to calling the specific appointment endpoints (`list_all_housecall_pro_job_appointments` and `update_a_housecall_pro_job_appointment_by_id`).

### Deeply Nested Estimate Structures
Estimates in Housecall Pro are not flat documents. An estimate belongs to a customer, contains multiple `options`, and each option contains its own array of `line_items`. When an LLM wants to "add a premium tier to the Smith estimate", the server must first pull the estimate, create a new estimate option (`create_a_housecall_pro_estimate_option`), capture the returned `option_id`, and then bulk update the line items specifically for that option. Flattening this into a single MCP tool namespace requires careful schema extraction and documentation.

## Creating the Housecall Pro MCP Server

Truto [dynamically generates MCP tools](https://truto.one/auto-generated-mcp-tools-for-ai-agents-a-2026-architecture-guide/) by reading the underlying integration's resources and documentation records. A tool only appears if it has an explicit documentation entry, ensuring the LLM receives clean, actionable descriptions and strictly enforced JSON schemas. 

You can create an MCP server URL for a connected Housecall Pro account in two ways.

### Method 1: Via the Truto UI

If you prefer a visual interface, you can generate the server directly from the dashboard:

1. Navigate to the **Integrated Accounts** page for your Housecall Pro connection.
2. Click the **MCP Servers** tab.
3. Click **Create MCP Server**.
4. Select your desired configuration. You can name the server (e.g., "Dispatch AI"), restrict the allowed methods (e.g., read-only), and filter the tags (e.g., only expose "jobs" and "customers").
5. Copy the generated MCP server URL. This single URL carries the cryptographic token that authenticates the LLM to the specific Housecall Pro tenant.

### Method 2: Via the API

For teams building automated deployment pipelines or provisioning AI agents programmatically, you can POST directly to the Truto API.

```bash
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": "Housecall Pro Dispatch Bot",
    "config": {
      "methods": ["read", "write"],
      "tags": ["jobs", "employees", "customers"]
    },
    "expires_at": "2026-12-31T23:59:59Z"
  }'
```

The response provides the secure URL:

```json
{
  "id": "mcp_abc123",
  "name": "Housecall Pro Dispatch Bot",
  "url": "https://api.truto.one/mcp/a1b2c3d4e5f6g7h8i9j0"
}
```

Treat this URL like a production secret. It acts as the routing and authentication layer for the JSON-RPC 2.0 communication between ChatGPT and Truto.

## Connecting the MCP Server to ChatGPT

Once you have your Truto MCP URL, you must register it with your LLM client. 

### Option A: Via the ChatGPT UI

If you are using ChatGPT directly:

1. In ChatGPT, navigate to **Settings -> Apps -> Advanced settings**.
2. Ensure **Developer mode** is enabled.
3. Under **MCP servers / Custom connectors**, click to add a new server.
4. Give it a recognizable name like "Housecall Pro (Truto)".
5. Paste the Truto MCP URL into the **Server URL** field and click Save.

ChatGPT will immediately ping the endpoint, perform the MCP `initialize` handshake, and execute `tools/list` to populate its context window with the available Housecall Pro endpoints.

### Option B: Via Manual Config File (Local Agents)

If you are running a local agent, an open-source framework, or testing via an MCP inspector, you configure the server using a JSON configuration file. While Truto's endpoint natively supports HTTP POST JSON-RPC, standard desktop clients often expect a Server-Sent Events (SSE) transport adapter.

You run a standard adapter like `@modelcontextprotocol/server-sse` pointing to your Truto URL:

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

This maps the local standard I/O streams of the client to the remote HTTP POST requirements of the Truto MCP server.

## Hero Tools for Housecall Pro

Truto automatically maps Housecall Pro's API surface into descriptive, snake_case tool names with fully documented JSON schemas. When ChatGPT calls these tools, Truto flattens the query and body schemas into a single namespace, parsing the LLM's arguments and executing the request against the proxy API.

Here are 7 high-leverage tools available for Housecall Pro workflows.

### 1. `list_all_housecall_pro_jobs`

Fetches a paginated list of jobs. Truto automatically injects `limit` and `next_cursor` parameters into the schema. ChatGPT can use this to scan the day's schedule or find jobs matching specific criteria. 

> "Fetch the 10 most recent jobs in Housecall Pro. If there is a next_cursor in the response, fetch the next page and summarize the work_status for all 20 jobs."

### 2. `housecall_pro_company_booking_windows`

Retrieves available windows to book a job or estimate based on Online Booking settings and open employee slots. This is critical for AI booking agents that need to respect actual capacity rather than blindly assigning times.

> "Check the company booking windows for the next 3 days for a standard 60-minute service. What slots are available?"

### 3. `create_a_housecall_pro_customer`

Creates a new customer record. The schema includes nested objects for phone numbers, email addresses, and physical addresses. Truto ensures the LLM provides the strictly required fields based on the documentation records.

> "Create a new customer named Sarah Jenkins. Her email is sarah@example.com, phone is 555-0199, and her address is 123 Maple Street, Austin, TX 78701."

### 4. `create_a_housecall_pro_estimate`

Generates an estimate associated with a specific customer. It optionally accepts a schedule window and assigned employees. This tool is the entry point for quoting workflows.

> "Draft a new estimate for customer ID 'cust_8910'. Set the work status to draft and schedule it for tomorrow at 9 AM."

### 5. `housecall_pro_job_line_items_bulk_update`

Performs bulk operations on job line items. Because this is a destructive operation in the Housecall Pro API, the LLM must explicitly map the IDs of items it wishes to keep. 

> "Update the line items for job ID 'job_554'. Add a new item called 'Emergency Service Fee' for $150, but make sure to include the existing 'Diagnostic Check' item so it doesn't get deleted."

### 6. `housecall_pro_jobs_dispatch`

Assigns a specific job to one or more employees and triggers dispatch notifications. 

> "Dispatch job 'job_992' to employee ID 'emp_12' and confirm the assignment was successful."

### 7. `list_all_housecall_pro_employees`

Retrieves the active employee roster, including their internal IDs, roles, and current status. This is normally used as a lookup step before executing a dispatch operation.

> "List all active employees. Find the ID for the technician named 'Mike' so we can assign him to a new repair job."

For the complete inventory of available Housecall Pro tools - including routing, lead management, and webhook subscriptions - visit the [Housecall Pro integration page](https://truto.one/integrations/detail/housecallpro).

## Workflows in Action

MCP enables ChatGPT to chain multiple Housecall Pro endpoints together to accomplish complex, multi-step field service objectives. Here are two real-world scenarios.

### Workflow 1: Emergency Field Dispatch

A dispatcher interacting with ChatGPT needs to find an available technician, create a customer, generate a job, and dispatch it immediately.

> "A new customer, John Doe (555-0122, 999 Oak Ln, Denver CO), just called with a burst pipe. Find out which employee is available today, create the customer, create an emergency repair job for his address, and dispatch the available employee to the job."

**Step-by-step Execution:**
1. **`housecall_pro_company_booking_windows`**: ChatGPT checks capacity for the day to confirm a slot exists.
2. **`list_all_housecall_pro_employees`**: Retrieves the roster to identify an available technician ID.
3. **`create_a_housecall_pro_customer`**: Creates John Doe's record and retrieves the new `customer_id` and nested `address_id`.
4. **`create_a_housecall_pro_job`**: Uses the IDs to generate the work order.
5. **`housecall_pro_jobs_dispatch`**: Pushes the job to the selected technician's mobile app.

```mermaid
sequenceDiagram
    participant User
    participant GPT as ChatGPT
    participant Truto as Truto MCP Server
    participant Upstream as Housecall Pro API

    User->>GPT: "Create emergency job for John Doe and dispatch..."
    GPT->>Truto: call housecall_pro_company_booking_windows
    Truto->>Upstream: GET /company/booking_windows
    Upstream-->>Truto: 200 OK (Slots available)
    Truto-->>GPT: Returns available windows
    
    GPT->>Truto: call list_all_housecall_pro_employees
    Truto->>Upstream: GET /employees
    Upstream-->>Truto: 200 OK (Employee list)
    Truto-->>GPT: Returns employees
    
    GPT->>Truto: call create_a_housecall_pro_customer
    Truto->>Upstream: POST /customers
    Upstream-->>Truto: 201 Created (customer_id: 123)
    Truto-->>GPT: Returns new customer ID

    GPT->>Truto: call create_a_housecall_pro_job
    Truto->>Upstream: POST /jobs
    Upstream-->>Truto: 201 Created (job_id: 456)
    Truto-->>GPT: Returns job ID

    GPT->>Truto: call housecall_pro_jobs_dispatch
    Truto->>Upstream: POST /jobs/456/dispatch
    Upstream-->>Truto: 200 OK
    Truto-->>GPT: Confirm dispatch success
    GPT-->>User: "Job 456 created and dispatched to Mike."
```

### Workflow 2: Automated Estimate Generation

A sales representative wants ChatGPT to generate a tiered estimate for an existing customer.

> "Find the customer named 'Acme Corp'. Create a new estimate for them. Add two options to the estimate: Option A called 'Standard Service' for $500, and Option B called 'Premium Service' for $800."

**Step-by-step Execution:**
1. **`list_all_housecall_pro_customers`**: ChatGPT searches the customer list for "Acme Corp" to grab the exact `customer_id`.
2. **`create_a_housecall_pro_estimate`**: Generates the base estimate document.
3. **`create_a_housecall_pro_estimate_option`** (Standard): Creates the first tier on the estimate.
4. **`create_a_housecall_pro_estimate_option`** (Premium): Creates the second tier.
5. **`housecall_pro_estimate_option_line_items_bulk_update`**: Attaches the specific $500 and $800 line items to the respective options.

```mermaid
flowchart TD
    A["list_all_housecall_pro_customers<br>Find 'Acme Corp' ID"] --> B["create_a_housecall_pro_estimate<br>Generate base document"]
    B --> C["create_a_housecall_pro_estimate_option<br>Create 'Standard' Option"]
    B --> D["create_a_housecall_pro_estimate_option<br>Create 'Premium' Option"]
    C --> E["housecall_pro_estimate_option_line_items_bulk_update<br>Add $500 line item"]
    D --> F["housecall_pro_estimate_option_line_items_bulk_update<br>Add $800 line item"]
```

## Security and Access Control

Connecting an LLM to a live field service database requires strict boundaries. Truto provides several mechanisms to lock down the MCP server environment:

* **Method Filtering**: You can constrain the server to safe operations. By passing `methods: ["read"]` during creation, Truto filters out all `create`, `update`, and `delete` tools. The LLM can query customer history but cannot mutate data.
* **Tag Filtering**: Restrict the AI's blast radius by functional domain. Setting `tags: ["jobs", "employees"]` ensures the LLM cannot access tools related to billing, estimates, or company settings.
* **Time-to-Live (TTL)**: Temporary servers can be created via the `expires_at` property. Once the Unix timestamp is reached, Truto purges the token from the key-value store and the server self-destructs. This is perfect for short-lived CI/CD integration tests or temporary contractor access.
* **Secondary Authentication**: By enabling `require_api_token_auth`, possession of the MCP URL is no longer sufficient. The connecting client (or human user) must also supply a valid Truto API token in the authorization header. 

**A factual note on rate limits**: Field service APIs are heavily rate limited to protect backend infrastructure. Truto does not retry, throttle, or apply backoff on rate limit errors. When the Housecall Pro API returns an HTTP 429 Too Many Requests error, Truto passes that error directly to the caller. Truto normalizes the upstream rate limit information into standardized IETF headers (`ratelimit-limit`, `ratelimit-remaining`, `ratelimit-reset`). The caller (your AI framework or agent orchestrator) is strictly responsible for implementing its own retry and exponential backoff logic.

## Final Thoughts

Building a custom integration layer between ChatGPT and Housecall Pro forces your team to manage complex scheduling abstractions, nested estimate options, destructive bulk updates, and OAuth token refreshes. 

By leveraging Truto's auto-generated MCP servers, you offload the entire infrastructure burden. Your AI agents gain immediate, schema-validated access to the Housecall Pro API, securely sandboxed by method and tag filters. You focus on engineering the field service prompts and workflows; Truto handles the protocol translation.

> Stop writing boilerplate API integration code. Let Truto generate secure, managed MCP servers for your AI agents in seconds.
>
> [Talk to us](https://truto.one/book-a-demo/)