BackCrew Jobber MCP Server

Think of this project as an employee badge, not a master key.

It lets you connect an AI assistant like Claude to your Jobber account, so you can ask for things in plain English — "find this client," "what jobs are open" — instead of clicking through the Jobber app yourself. But like a real employee badge, it only opens the specific doors you hand it a key for. Out of the box, every door is locked to "look, don't touch." You choose if and when to hand it keys to anything more.

Built by BackCrew — part of a series of free tools like this for the software pest control companies use every day. First entry: Housecall Pro.

Not a developer? That's fine. Everything up through "Testing it safely" is written for you, no coding background needed.

Read this first: this is the most limited repo in the series, and for a specific reason explained below. Jump to Why this one is smaller and more cautious than our other repos.

---

Contents

• What this actually does
• Why this one is smaller and more cautious than our other repos
• Some words you'll see, explained
• How this keeps you safe by default
• What it can look up (always safe)
• ⚠️ What it can change (off by default)
• How to set it up
• Connecting it to Claude
• Testing it safely
• For developers
• What's next
• Built by BackCrew
• License

What this actually does

To be precise about what this is, because it's easy to overstate: this is not an all-knowing office assistant that understands your business and handles things for you. It's a specific, listed set of actions that an AI assistant is allowed to trigger when you ask for them in plain English. The AI doesn't have judgment about your business; it matches what you ask for to the closest action on its list and does exactly that, nothing more.

Why this one is smaller and more cautious than our other repos

Jobber is the biggest platform in this whole series by user count (Jobber reports 250,000+ users), which is exactly why we wanted to include it. But it's also the only one where we couldn't fully verify the API schema before building, and we want to be straight about that rather than quietly paper over it.

The core issue: Jobber's API is GraphQL-based, and Jobber doesn't publish a static, field-by-field schema reference anywhere public. Their own docs say so directly: "For the most up-to-date schema, please follow our Getting Started steps and view everything in GraphiQL." To reach that live schema browser, you need a Jobber account, a separate Developer Center account, and an app registered inside it — all free and self-service, but all account-creation steps. We don't create accounts on your behalf, as a matter of policy — that's true across everything we build, not specific to Jobber — so we built this from what's genuinely public instead:

• Jobber's own Developer Center overview page (public, no login), which lists the API's object types: Clients, Requests, Jobs, Quotes, Invoices, Accounts, Assessments, Expenses, Products/Services, Time Sheet Entries, Properties, Users, Visits
• Jobber's official open-source app template (GetJobber/Jobber-AppTemplate-RailsAPI on GitHub), which includes a real, working clients query example
• A third-party AI-tooling reference (maton-ai/api-gateway-skill on GitHub) that documents a distilled but genuine field list for Client, Job, Invoice, Quote, Property, User, and Account, plus two confirmed mutations (clientCreate, jobCreate) and the pagination/auth conventions

That's enough to build list and get tools for six object types, plus the two mutations we found concrete evidence for. It is not enough to confidently build update or delete mutations for anything — we have no verified evidence of what Jobber calls those (could be clientEdit, clientUpdate, jobClose, or something else entirely), and guessing at mutation names for a live API felt like the wrong tradeoff. So this repo doesn't have them yet.

Every list/get tool includes a fields parameter that lets you override the default field selection with a raw GraphQL selection set. This exists specifically because we can't guarantee our default field names exactly match your account's schema — if a tool errors on a field that doesn't exist, that's the escape hatch.

If you have real Jobber Developer Center access, opening GraphiQL and confirming the actual field names and mutation list would make this repo dramatically better and is genuinely useful — contributions very welcome.

Some words you'll see, explained

• API — a locked door into Jobber's data that only software can open. This project is a key that opens that door.
• GraphQL — a different style of API than most of our other repos use. Instead of one URL per action, you send a single request describing exactly which fields you want back.
• MCP — the standard way an AI assistant like Claude is told what it's allowed to do.
• Server — a small program that sits between Claude and Jobber, translating requests back and forth.
• OAuth — the login flow Jobber uses to issue an access token. There's no simpler "generate a key" option for Jobber, unlike some of our other repos.
• Terminal — a plain-text window where you type commands.
• Tool — one specific, individually named action the AI is allowed to take.

How this keeps you safe by default

• Out of the box, this server can only look things up. It ships in read-only mode.
• When you're ready for more, you choose a badge level:
  • readonly-owner — same as the default. Look-ups only.
  • office-ops — the two confirmed write actions this repo ships: create a client, create a job.
  • admin — currently identical to office-ops. There's nothing delete/void-type confirmed yet to put here — see the scope explanation above.
• A typo can't accidentally open more doors than intended. An invalid profile falls back to the safest option.

What it can look up (always safe)

What it covers	Examples
Clients	Search and view client records
Jobs	View job details
Invoices	View invoice details
Quotes	View quote/estimate details
Properties	View service addresses
Users & account	View team members and basic account info

12 look-up actions in total.

⚠️ What it can change (off by default)

office-ops level — the only two write actions in this repo, both confirmed against real Jobber schema evidence:

• Create a new client
• Create a new job for a client

That's it for now — see why above.

How to set it up

You'll need:

• A computer with Node.js installed
• A Jobber account, and about 15 minutes to complete Jobber's OAuth setup (there's no shortcut here — see below)

Step 1: Download the project

git clone https://github.com/jayson-svg/backcrew-mcp-jobber.git
cd backcrew-mcp-jobber
npm install
npm run build

Step 2: Get a Jobber access token

This is the one extra step Jobber requires that our other repos don't:

1. Go to Jobber's Developer Center and follow "Create a New Jobber Account To Test With" if you don't already have one
2. Create a free Developer Center account and register an app (any name/description is fine — you can change it later)
3. Follow Jobber's OAuth 2.0 flow to get an access token for your own account

This is entirely free and self-service — Jobber just doesn't offer a simpler path for this particular API.

Step 3: Save your token and choose your safety level

cp .env.example .env

Edit .env:

JOBBER_ACCESS_TOKEN=your_token_here

JOBBER_MCP_MODE=read_only
JOBBER_MCP_PROFILE=readonly-owner

Save the file. Keep it private.

Connecting it to Claude

Open Claude's settings file (for Claude Desktop, claude_desktop_config.json) and add:

{
  "mcpServers": {
    "jobber": {
      "command": "node",
      "args": ["/absolute/path/to/backcrew-mcp-jobber/dist/index.js"],
      "env": {
        "JOBBER_ACCESS_TOKEN": "your_token_here",
        "JOBBER_MCP_MODE": "read_only",
        "JOBBER_MCP_PROFILE": "readonly-owner"
      }
    }
  }
}

Restart Claude. Also works with other MCP-compatible AI tools.

Testing it safely

1. Start in read-only mode and stay there for a while.
2. When you turn on office-ops, test on a clearly fake client first.
3. Never share your access token — treat it like a password.
4. If a tool errors on an unrecognized field, try the fields parameter to supply your own GraphQL selection — see why above for why this exists.
5. If something looks wrong, switch back to JOBBER_MCP_MODE=read_only immediately.

For developers

Everything below this point assumes a coding background.

Tool reference

Run the server and call tools/list to see exact schemas.

Project layout

src/
  index.ts          Server entrypoint
  client.ts          GraphQL client (Bearer auth + X-JOBBER-GRAPHQL-VERSION header)
  toolkit.ts          Tier/profile-aware helper that wires a Zod input schema + handler into an MCP tool
  tools/
    clients.ts
    jobs.ts
    invoicesAndQuotes.ts
    propertiesAndAccount.ts

The tier/profile system

Same pattern as the rest of this series. JOBBER_MCP_MODE/JOBBER_MCP_PROFILE gate what's registered at startup; read_only always wins; invalid profile falls back to the safest tier.

Notes on the Jobber API

• Endpoint: POST https://api.getjobber.com/api/graphql (single endpoint for everything, as with all GraphQL APIs)
• Auth: Authorization: Bearer <access_token> plus a required X-JOBBER-GRAPHQL-VERSION header (this repo uses 2025-04-16, current as of when this was built — check Jobber's docs if requests start failing, as this may need bumping)
• Pagination: Relay-style cursors (first, after args; pageInfo { hasNextPage endCursor } in the response)
• IDs are EncodedId — opaque base64-ish strings, not raw UUIDs. Treat them as opaque; don't try to decode or construct them.
• Rate limits: 2,500 requests per 5 minutes; query cost limit of 10,000 points per request (per Jobber's public docs)

Confidence level, to be blunt about it: the six list/get object types and their default field selections, plus the two create mutations, are grounded in real evidence (Jobber's own app template + a third-party integration reference), not guesses about what a typical GraphQL API "probably" looks like. But none of it has been tested against a live Jobber account by us, and Jobber's schema could easily have moved since the source material was written. Treat this repo as a solid starting point, not a verified-against-production reference the way the other repos in this series are.

This repo intentionally stops at honest API access. It does not include business-logic features — those live in BackCrew's managed offering, not in this public repo. See ROADMAP.md.

What's next

See ROADMAP.md for the rest of the planned series, and for what this repo needs next (real GraphiQL-verified field names).

Built by BackCrew

This project is free and open for anyone to use, copy, or build on.

It's also a sample of the kind of work BackCrew does. If you have real Jobber Developer Center access and want this expanded and verified, or you'd rather not deal with Jobber's OAuth setup yourself, that's exactly the kind of project we take on.

Want this done for you? Reach out: jayson@backcrew.co

No pressure either way — everything above works on its own, for free.

License

MIT