BackCrew Jobber Server

Think of this like a brand-new employee on their first day, not a business partner. A new hire only does the exact tasks you've shown them, nothing more, until you decide they're ready for more responsibility.

It lets you connect an AI assistant like Claude or ChatGPT 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. On day one, it only knows how to look things up. You decide if and when to train it up to doing more.

Built by BackCrew, part of a series of free tools like this for the software pest control companies use every day.

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 use an independent MCP server instead of the platform's own AI?
• Why this one is smaller and more cautious than our other repos
• Also from BackCrew
• 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

Let's be upfront about what this is, because it's easy to oversell: 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 use an independent MCP server instead of the platform's own AI?

Software platforms are increasingly shipping their own built-in AI features. Worth knowing why you might still reach for this instead:

• No plan-tier gates. Native AI features are often locked to a platform's most expensive plan. This project just needs API access, which is usually available on lower tiers too.
• Cross-platform, not walled off. A platform's own AI only sees that platform's own data; it has no reason to work fluently with your accounting software, another CRM, or your email, since those are somebody else's product. An MCP-connected assistant can have multiple servers attached at once (this one plus another BackCrew server covering a different part of your business), so it can work across your whole stack in one conversation.
• Your choice of AI, not theirs. You keep using whichever assistant you already trust (Claude, ChatGPT, whatever) instead of learning a new vendor-specific AI interface.

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.

Also from BackCrew

This is one of several MCP connectors BackCrew builds, same idea, different software. We've also got QuickBooks for the accounting side, plus CRM connectors like HubSpot and GoHighLevel for lead and marketing data. Full list and what's live right now: see ROADMAP.md.

Beyond this repo: once a business gets comfortable with an AI assistant reading its data, there's often more it wants to do with it, like catching missed calls faster, processing invoices and paperwork automatically, following up on quotes without someone having to remember, reactivating customers who've gone quiet, or pulling reports without digging through the software. That's a separate, scoped conversation, not part of this free, open-source repo. Same contact as in Built by BackCrew below if it's something you want to explore.

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 or ChatGPT is told what it's allowed to do.
• Server: a small program that sits between an AI assistant like Claude or ChatGPT 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 responsibility 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 hand out more trust than you 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

This one has an extra wrinkle: Jobber requires an OAuth login flow instead of a simple "generate a key" button, so Step 2 below takes longer than in our other repos; budget about 15 minutes for it. Still, do these three steps in order and you won't have to jump back and forth.

You'll need a computer with Node.js installed before you start.

Step 1: Make a folder for this on your computer

Open Finder (Mac) or File Explorer (Windows), go to your Desktop or Documents, and create a new folder. Give it a name you'll recognize later, like backcrew-mcp-jobber.

That's it for now: just know where this folder is. Everything else gets put inside it.

Step 2: Get a Jobber access token

This is the one extra step Jobber requires that our other repos don't; it's entirely free and self-service, Jobber just doesn't offer a simpler path for this particular API. Do this now, before touching the terminal:

1. Go to Jobber's Developer Center
2. If you don't already have a Jobber account to test with, follow their "Create a New Jobber Account To Test With" instructions
3. Create a free Developer Center account and register an app (any name/description is fine, since you can change it later)
4. Follow Jobber's OAuth 2.0 flow to authorize your own account and get an access token
5. Copy that access token into a temporary note somewhere; you'll paste it in during Step 3

Step 3: Install it

With your folder made and your access token in hand, this is one continuous run; don't skip ahead or double back.

1. Open a terminal. On a Mac, press Cmd+Space, type "Terminal," and hit enter. On Windows, click the Start menu, type "PowerShell," and hit enter. Use PowerShell rather than Command Prompt: a couple of the commands below, like pwd, only work in PowerShell.
2. Type cd (with a space after it), then drag your Step 1 folder from Finder/File Explorer straight into the terminal window; it'll paste the folder's path in automatically. Press enter.
3. Paste this exact command and press enter; it downloads the project directly into the folder you made (the trailing . matters, it means "put it here, not in a new folder"):

   git clone https://github.com/jayson-svg/backcrew-mcp-jobber.git .
   

4. Paste this and press enter; it installs the project's dependencies:

   npm install
   

5. Paste this and press enter; it builds the project:

   npm run build
   

6. Paste this and press enter; it prints the full folder path. Don't close this terminal window yet; you'll need this exact text in the next section.

   pwd
   

7. Paste this and press enter; it creates your settings file from a template:

   cp .env.example .env
   

8. Open that new .env file in a text editor. On a Mac, paste open -e .env into the terminal and press enter. On Windows, paste notepad .env and press enter.
9. Find the line that says JOBBER_ACCESS_TOKEN=. Paste in the token you copied in Step 2, right after the =, with no extra spaces or quotes.
10. Leave JOBBER_MCP_MODE=read_only and JOBBER_MCP_PROFILE=readonly-owner exactly as they are for now; that's the safe default. Save the file and close the editor.

Connecting it to Claude

This step comes last on purpose; it needs the exact folder location from Step 3, and now you have it.

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

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

Replace PASTE_YOUR_PWD_OUTPUT_HERE with the exact text the pwd command printed back in Step 3 (keep the /dist/index.js part after it). If you're on Windows, swap any backslashes in that path for forward slashes (for example C:/Users/yourname/Desktop/... instead of C:\Users\yourname\Desktop\...), since the config file needs regular slashes.

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

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: [email protected]

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

License

MIT