---
title: "Connect Jobber to Claude: Track Work Requests and Service Bookings"
slug: connect-jobber-to-claude-track-work-requests-and-service-bookings
date: 2026-09-01
author: Yuvraj Muley
categories: ["AI & Agents"]
excerpt: "Learn how to connect Jobber to Claude using a managed MCP server. Automate service requests, client tracking, and job scheduling workflows with AI."
tldr: "Connect Jobber to Claude via a managed MCP server to automate field service workflows. This guide covers REST vs GraphQL quirks, handling strict state machines, and executing AI-driven dispatch tasks."
canonical: https://truto.one/blog/connect-jobber-to-claude-track-work-requests-and-service-bookings/
---

# Connect Jobber to Claude: Track Work Requests and Service Bookings


If you need to connect Jobber to Claude to automate field service operations, triage incoming work requests, or track service job statuses, 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 Jobber's 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 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 Jobber to ChatGPT](https://truto.one/connect-jobber-to-chatgpt-manage-leads-requests-and-job-status/) or explore our broader architectural overview on [connecting Jobber to AI Agents](https://truto.one/connect-jobber-to-ai-agents-automate-client-and-request-workflows/).

Giving a Large Language Model (LLM) read and write access to a complex field service ecosystem like Jobber is an engineering challenge. You have to handle OAuth 2.0 token lifecycles, map massive JSON schemas to MCP tool definitions, and deal with Jobber's strict workflow rules and dual REST/GraphQL architectures. Every time Jobber updates an endpoint or deprecates a field, 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 Jobber, connect it natively to Claude Desktop, and execute complex dispatch and scheduling workflows using natural language.

> Want to give your AI agents secure, authenticated access to Jobber and 100+ other SaaS APIs? Let's talk about [managed MCP architecture](https://truto.one/managed-mcp-for-claude-full-saas-api-access-without-security-headaches/).
>
> [Talk to us](https://truto.one/book-a-demo/)

## The Engineering Reality of the Jobber 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 Jobber's APIs requires navigating a highly opinionated platform designed around physical field service workflows.

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

**The REST vs. GraphQL Paradigm Split**
Jobber operates dual APIs, and your LLM needs access to both to be effective. The REST API is excellent for listing records and triggering basic actions. However, creating a fully fleshed-out client using the standard `POST /clients` REST endpoint only accepts scalar fields. If you want to attach emails, phone numbers, billing addresses, or status tags during creation, you must execute a GraphQL `clientCreate` mutation. An effective MCP server must abstract this reality, exposing clear, typed REST tools for standard CRUD, while providing a GraphQL escape hatch for nested object mutations.

**Strict Workflow State Machines**
An LLM cannot simply force a work request into a completed state by sending a `PATCH` request with `"requestStatus": "converted"`. Jobber's statuses are derived from its internal workflow engine. A request converts only when a quote is generated and approved. A client remains a "lead" (`isLead: true`) until their first job is booked, at which point Jobber automatically flips the boolean. Your MCP tools must be carefully documented so Claude understands it cannot directly mutate these derived status fields, avoiding endless hallucinated API calls that return 400 Bad Request errors.

**Complex Archival Dependencies**
Data deletion in Jobber is heavily guarded to protect accounting and service histories. If an AI agent attempts to archive a client, Jobber will refuse the request if the client has open jobs, active quotes, or pending work requests, returning a strict `userErrors` response. Your AI needs tools to query rollups - like `jobs.totalCount` - before attempting state changes to handle these guarded actions gracefully.

## Generating the Jobber MCP Server

Truto handles the heavy lifting of API translation through a dynamic, documentation-driven architecture. Instead of hand-coding tool definitions for every Jobber endpoint, Truto derives them from internal resource definitions and documentation records. 

This means a tool only appears in the MCP server if it has a corresponding documentation entry, ensuring the LLM only sees curated, AI-ready tools. Truto manages the OAuth token refresh lifecycle and proxies the execution directly to Jobber.

*A critical factual note on rate limits: Truto does not swallow or automatically retry rate-limited requests. When Jobber returns an HTTP 429 error, Truto passes that error directly to the caller. Truto normalizes upstream rate limit info into standardized headers (`ratelimit-limit`, `ratelimit-remaining`, `ratelimit-reset`) per the IETF spec. Your client application or agent framework is responsible for handling retry and backoff logic.*

You can generate an MCP server for Jobber via the Truto dashboard or programmatically via the API.

### Method 1: Via the Truto UI

For teams testing workflows or setting up internal agents, the UI is the fastest path.

1. Navigate to the **Integrated Accounts** page in your Truto dashboard.
2. Select your connected Jobber account.
3. Click the **MCP Servers** tab.
4. Click **Create MCP Server**.
5. Select your desired configuration (e.g., allow all methods, or restrict to read-only).
6. Copy the generated MCP server URL (e.g., `https://api.truto.one/mcp/a1b2c3d4...`).

### Method 2: Via the Truto API

For production use cases where you need to provision MCP servers dynamically for your end-users, use the REST API. This request validates the underlying tools, generates a secure cryptographic token, and schedules an automatic cleanup alarm if an expiration is set.

```bash
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": "Jobber Dispatch Agent",
    "config": {
      "methods": ["read", "write", "custom"]
    }
  }'
```

The API returns a payload containing the secure connection URL:

```json
{
  "id": "mcp-jobber-890",
  "name": "Jobber Dispatch Agent",
  "config": { "methods": ["read", "write", "custom"] },
  "expires_at": null,
  "url": "https://api.truto.one/mcp/a1b2c3d4e5f6g7h8..."
}
```

Keep this URL secure. It contains a cryptographic token that maps directly to the specific Jobber tenant connection.

## Connecting the MCP Server to Claude

Once you have your Truto MCP URL, connecting it to Claude is a matter of configuration. The standard JSON-RPC 2.0 protocol handles tool discovery automatically.

### Method A: Via the Claude UI (or ChatGPT UI)

If you are using Claude's web interface or ChatGPT's custom connectors, you can add the server directly through the UI settings.

1. **In Claude:** Go to Settings -> Integrations -> Add MCP Server. Paste your Truto MCP URL and click Add.
2. **In ChatGPT:** Go to Settings -> Apps -> Advanced settings -> Enable Developer mode. Under MCP servers, click add new, provide a name (e.g., "Jobber Production"), paste the URL, and save.

### Method B: Via the Claude Desktop Config File

For developers building local agentic workflows with Claude Desktop, you can mount the server via your configuration file using the official MCP SSE transport.

Locate your `claude_desktop_config.json` file:
- Mac: `~/Library/Application Support/Claude/claude_desktop_config.json`
- Windows: `%APPDATA%\Claude\claude_desktop_config.json`

Add the Jobber MCP server using the `@modelcontextprotocol/server-sse` package:

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

Restart Claude Desktop. You will see a new hammer icon indicating the Jobber tools have been successfully ingested.

## High-Leverage Hero Tools for Jobber

Truto exposes Jobber operations as strictly typed tools with combined query and body schemas. Here are six high-leverage hero tools that unlock dispatching and field service automation. 

### 1. list_all_jobber_requests

Requests are inbound enquiries for work. This tool allows the LLM to pull all pending enquiries, filter by status, and identify which clients need immediate attention. 

**Usage note:** Use the `filter` parameter to narrow down the list. For example, passing `{"status": "new"}` returns only un-actioned requests.

> "Pull all 'new' work requests from Jobber. For each one, tell me the company name, contact details, and the assigned salesperson."

### 2. get_single_jobber_client_by_id

Fetches a comprehensive profile of a specific client, including their outstanding balance, phone numbers, tags, and total counts for jobs and invoices. 

**Usage note:** A client where `jobs.totalCount` equals `0` has never had work booked. Jobber enforces the `isLead` status based on this metric, meaning the LLM can infer client maturity simply by checking the job count.

> "Look up client ID 849201. Have they had any actual jobs completed with us, or are they still just a lead? What is their current outstanding balance?"

### 3. list_all_jobber_jobs

Retrieves scheduled and completed work orders. This is the core operational entity in Jobber, allowing the AI to see job statuses, totals, scheduled dates, and the associated property.

**Usage note:** This is critical for agents acting in a dispatch or customer service capacity. If a customer calls in asking about their service window, this tool provides the exact scheduling timestamps.

> "List all recent jobs. Find the one for 'Acme Corp' and tell me its current status and the scheduled start time."

### 4. create_a_jobber_request

Allows the LLM to programmatically log a new work enquiry against an existing client. The new request will automatically be given the `requestStatus` of "new".

**Usage note:** The `client_id` is required in the body. This tool only accepts scalar fields (like the title or basic details). If you need to attach complex line items or nested property details upon creation, you must use the GraphQL tool.

> "Log a new work request for client ID 10924. The title should be 'Emergency HVAC repair - No cooling'."

### 5. update_a_jobber_request_by_id

Once a request is generated, this tool allows the agent to update specific assignments. 

**Usage note:** You can update the title, assigned property, referring client, and the salesperson. You cannot manually update the `requestStatus` - that requires moving the request through the Jobber workflow (e.g., quoting it).

> "Update request ID 5820. Assign 'Sarah Jenkins' as the salesperson and confirm the update was successful."

### 6. create_a_jobber_graphql

This is the ultimate escape hatch. For anything the typed REST tools cannot express - like setting nested addresses during client creation, applying status tags, or interacting with deep Jobber configurations - the LLM can construct and fire an arbitrary GraphQL mutation or query.

**Usage note:** The tool accepts `{query, variables}` in the body. It returns Jobber's raw GraphQL response, including the `data` object and any nested `userErrors` arrays.

> "Use the GraphQL tool to run a clientEdit mutation on client ID 9921. Add the tag 'VIP-Customer' to their profile."

For the complete tool inventory, including detailed JSON Schemas for every operation, check out the [Jobber integration page](https://truto.one/integrations/detail/jobber).

## Workflows in Action

Connecting Jobber to Claude transforms static field service data into actionable, agentic workflows. Here is how specific personas use these tools in practice.

```mermaid
sequenceDiagram
    participant Claude as Claude Desktop
    participant Truto as Truto MCP Router
    participant Proxy as Truto Proxy API
    participant Jobber as Jobber API

    Claude->>Truto: tools/call (list_all_jobber_requests)<br>filter: {"status": "new"}
    Truto->>Proxy: Execute Proxy Handler
    Proxy->>Jobber: GET /requests?status=new
    Jobber-->>Proxy: 200 OK (Requests Data)
    Proxy-->>Truto: Normalized API Response
    Truto-->>Claude: JSON-RPC Result
```

### Scenario 1: The Dispatcher Triaging New Leads

Field service dispatchers need to move fast when new work enquiries come in. Instead of clicking through the Jobber interface to identify new requests and assign them, they can ask Claude to handle the triage.

> "Check Jobber for any new work requests that haven't been assigned yet. Give me a summary of who the client is, and then assign all of them to salesperson ID 445."

**Execution flow:**
1. Claude calls `list_all_jobber_requests` with the filter `{"status": "new"}`.
2. The model parses the returned array of requests, noting the missing salesperson assignments.
3. Claude loops through the array, calling `update_a_jobber_request_by_id` for each unassigned request, passing the specified salesperson ID.
4. Claude returns a text summary confirming exactly which requests were updated and assigned.

### Scenario 2: The Service Manager Auditing High-Value Leads

Managers need to separate noise from high-value prospects. Jobber tracks lead status implicitly through the absence of booked jobs. 

> "Find all our clients who are currently tagged as leads. Filter for any that have a balance greater than 0, meaning they might have paid a deposit but haven't had a job logged yet. If you find any, use GraphQL to add the tag 'Needs-Follow-Up'."

**Execution flow:**
1. Claude calls `list_all_jobber_clients` with the filter `{"isLead": true}`.
2. The model evaluates the returned `balance` fields, filtering out anyone with a 0 balance.
3. For matching clients, Claude formats a GraphQL mutation string.
4. Claude calls `create_a_jobber_graphql` with the `clientEdit` mutation to append the "Needs-Follow-Up" tag.
5. Claude replies with a list of the updated high-value leads.

## Security and Access Control

When exposing B2B APIs to LLMs, security and blast-radius containment are paramount. Truto's MCP servers provide strict boundaries at the token level, ensuring agents only access what they explicitly require.

*   **Method Filtering (`methods`):** Restrict an MCP server to read-only access by passing `["read"]` during server creation. This exposes only `get` and `list` operations, physically preventing the LLM from mutating Jobber data.
*   **Tag Filtering (`tags`):** Group tools by business function. If you only want an agent to handle work requests and ignore invoicing, specify relevant tags to drop unrelated tools from the server payload entirely.
*   **Expiration Controls (`expires_at`):** Generate short-lived MCP servers for contractors or temporary AI workflows. Once the ISO datetime is reached, Truto automatically cleans up the database record and invalidates the edge KV storage.
*   **Double Authentication (`require_api_token_auth`):** For strict security environments, toggle this flag to true. The caller must possess the secret MCP URL *and* pass a valid Truto API token in the Authorization header to execute tools.

## Architecting AI-Driven Field Service

Connecting Jobber to Claude via MCP moves your operational data out of isolated dashboards and into natural language workflows. Whether you are automating dispatch logic, auditing lead statuses via GraphQL, or triaging emergency service requests, a managed MCP server removes the friction of OAuth token management and documentation mapping.

Instead of wasting engineering cycles reading Jobber API docs and maintaining brittle REST wrappers, you can focus on writing better agent prompts and orchestrating faster service delivery.

> Ready to connect your AI agents to Jobber without the integration overhead? Let's talk about Truto's managed MCP servers.
>
> [Talk to us](https://truto.one/book-a-demo/)