How to Connect Make.com and Jobber (When You Don't Have an IT Guy)

Disclosure: Some links in this article are affiliate links. If you purchase through them, we may earn a small commission at no extra cost to you.

Does Make.com have a Jobber integration? No. There is no native Jobber module in Make.com as of May 2026 (verified via major integration directories). But you can still connect the two using Make’s HTTP module to talk directly to Jobber’s API (the door that lets outside software read and write your Jobber data). No programming environment required.

Quick answer: Make.com has no native Jobber integration. You have two paths: use a different platform that has a native Jobber connector, or use Make’s built-in HTTP module to talk directly to Jobber’s API (application programming interface). The HTTP route takes 45-90 minutes for your first connection. No programming environment needed — you are copying and pasting a template request, not writing code.

The math: Time to implement: ~60 min | Tasks automated: new-job notifications, client sync, invoice triggers | Weekly time reclaimed: ~2-5 hours

TL;DR:

No native Make.com + Jobber tile exists as of May 2026.
Make’s HTTP module connects to Jobber’s GraphQL API without coding.
Setup takes about 60 minutes and can save 2-5 hours of weekly copy-paste.

Heads up: Pricing changes. All figures in this article are accurate as of May 2026. Verify current pricing directly on each tool’s website before making a purchase decision.

The Short Answer: No, But You Have Two Options

Here’s the thing: the missing logo does not mean the connection is impossible.

Make.com is a workflow automation platform that connects different apps so data flows between them without you copying and pasting. Jobber is field service management software built for trades like HVAC, plumbing, landscaping, and electrical work. You would expect these two to have a ready-made connector. They do not.

The Make.com community forum thread on Jobber’s API is a good example of the problem. Users ask how to connect these tools, and the answers jump straight into OAuth 2.0 tokens, GraphQL queries, and JSON payloads. If those words mean nothing to you, that response feels like being handed a repair manual in a language you do not speak.

The community forums are not wrong about the technical steps. They are wrong about the starting point. You do not need to understand how an API works under the hood. You need to understand which door to knock on and what to ask for when it opens.

Your two options:

Option A: Skip Make for this one connection and use a platform that already has a native Jobber app built in. Fastest path, least friction, some trade-offs.
Option B: Stay in Make and use the HTTP module to talk directly to Jobber’s API. More setup time upfront, more flexibility long-term.

Task	The Old Way	The AI Way	Time Saved
New job alert to your CRM	Check Jobber, copy details, paste into CRM	Make.com HTTP module sends it automatically	~15 min/job
Client info sync	Retype name, address, phone into second system	Jobber API feeds client record to Make scenario	~10 min/client
Invoice follow-up	Remember to check unpaid invoices, send texts manually	Make triggers a follow-up message when invoice status changes	~30 min/week

Option A: When to Skip Make Entirely for This Connection

The upshot: if Jobber is your only reason for using Make, a different platform may save you an hour of setup.

There are other automation platforms with a pre-built Jobber connector. The setup is drag-and-drop: pick Jobber from the app list, sign in, and start building. No API keys, no developer accounts, no authorization URLs.

This matters because Make.com charges by credits. The free tier gives you 1,000 credits per month with 2 active scenarios. If Jobber-to-CRM sync is the only automation you need, and you are not already using Make for other workflows, the simplest path may be a platform that already speaks Jobber natively.

Who should take Option A: You run fewer than 3 automations total. You do not use Make for anything else. You need this working today, not this weekend.

Who should skip Option A: You already use Make for other business automations (email marketing, lead routing, scheduling). You want all your workflows in one dashboard. You need custom logic that a drag-and-drop connector cannot handle.

If you already rely on Make for other parts of your business, keep reading. Option B is where the real flexibility lives.

Option B: The DIY Make.com Workaround (Translated for Non-Developers)

What matters here: APIs are just digital mail carriers, and you are writing the address on the envelope.

Get Your Free AI Tools Starter Kit

Take the 2-minute quiz to find your AI match — plus get the tools, checklist, and 50 prompts matched to your business type.

Take the Quiz →

An API (application programming interface) is the door Jobber leaves open so other software can ask for data or send data in. Jobber’s API uses GraphQL. That sounds technical, but all it means is: instead of getting a dump of everything in your Jobber account, you write a short request that says “give me only the client name, phone number, and job status.” You ask for exactly what you need.

Make.com’s HTTP module knocks on that door for you. You paste in the address (a URL), attach your credentials (an API key), and tell it what to ask for. Make handles the rest. No code editor. No terminal window. No developer on speed dial. You will copy-paste a template request — not write anything from scratch.

The honest limitation: the first-time setup takes longer than a native integration. You will spend 45-90 minutes getting your credentials, authorizing the connection, and testing your first request. After that, each new automation takes 10-15 minutes to build.

If you want to send Jobber data into HighLevel for automated follow-ups, this is the path. HighLevel starts at $97/month (usage-based charges for SMS and calls are extra), and once Jobber job data lands there, you can trigger review requests, quote follow-ups, or rebooking campaigns without touching your phone.

For a deeper look at how contractors are wiring up these kinds of automations, our guide to AI tools for small contractors covers the broader stack.

Your 2-Step Setup Guide Using the HTTP Module

Before starting, confirm: you have an active Jobber account on the Connect plan ($119/month monthly, $84/month annual) or higher. API access typically requires the Connect tier or above. Also confirm you have a Make.com account (free tier works for testing).

Step 1: Create a Jobber Developer Account (15 minutes)

Jobber has a separate developer portal where you register your “app.” This is not building software. This is telling Jobber “I want to let Make.com read my data.”

Go to Jobber’s developer portal (search “Jobber Developer” or find it linked from Jobber’s main site footer).
Sign up using your existing Jobber email.
Create a new application. The name can be anything. “Make Connection” works.
Jobber will give you two pieces of text: a Client ID and a Client Secret. These are your credentials. Copy both into a password manager or a secure note. Do not paste them into a shared Google Doc.
Set the Redirect URI to the one Make.com gives you. You will find this inside Make when you set up the HTTP OAuth connection (next step). It looks like a long URL ending in “oauth/cb.” Paste that exact URL into Jobber’s redirect field.

You will know Step 1 worked when: Jobber’s developer portal shows your app as “Active” with a Client ID and Client Secret visible.

Pro tip: Your Client Secret is shown once. If you lose it, you will need to regenerate it and redo the OAuth connection in Make. Save it somewhere secure right now.

Step 2: Set Up the OAuth 2.0 Connection in Make (20 minutes)

OAuth 2.0 is the security handshake between Make and Jobber. Think of it as Jobber asking “Do you really want to let Make read your jobs?” and you clicking “Yes, allow access.”

Here is how to wire it up inside Make:

Create a new scenario in Make.com.
Add an HTTP module. Choose “Make an OAuth 2.0 request.”
Click “Add” next to the Connection dropdown. This opens the OAuth 2.0 configuration panel.
Fill in the fields using your Jobber developer app details:

Field	What to Paste
Client ID	The Client ID from your Jobber developer app
Client Secret	The Client Secret you saved in Step 1
Authorize URI	`https://api.getjobber.com/api/oauth/authorize`
Token URI	`https://api.getjobber.com/api/oauth/token`
Scope	`read_clients read_jobs write_jobs` (adjust based on what you need)

Copy the Redirect URI that Make displays at the top of this configuration panel. This is the URL ending in “oauth/cb” mentioned in Step 1. If you have not already pasted it into your Jobber developer app, go back and do that now.
Click “Save” and then “Authorize.” A Jobber login window will pop up. Sign in with your Jobber account and click “Allow.”

You will know Step 2 worked when: The connection dropdown in Make shows a green checkmark, and the status reads “Verified” or “Connected.”

Jobber isn’t the only field service platform you can automate this way — connecting Make.com to Housecall Pro follows a very similar weekend setup process.

Solo operators, especially those looking at electrical contractor software for 1-man shops, will find Make.com automations particularly valuable for replacing office manager tasks.

Many small business owners also wonder about connecting HighLevel to QuickBooks integration when managing client billing across platforms.

Common hangup: If you get a “redirect_uri mismatch” error, the URL in your Jobber developer app does not match Make’s redirect URI character for character. Copy it fresh from Make, paste it into Jobber, save, and try authorizing again.

Now that Make can talk to Jobber, you need to tell it what to actually say. Jobber uses a GraphQL API, which means you send a specific query to one endpoint rather than hitting different URLs for different data.

Before diving into Make.com automations, you may want to settle the housecall pro vs servicetitan debate so you’re building workflows around the right platform.

While you’re automating workflows, you might also explore whether AI for HVAC lead generation could bring more jobs into your pipeline automatically.

You might also be exploring whether Make.com integrates with ServiceTitan, which requires a similar API bridge setup worth understanding first.

Here is a practical first scenario: When a new client is created in Jobber, send their details to a Google Sheet.

Add a new HTTP module to your scenario. In Make, click the “+” to add another module after any trigger (or use this as a standalone scheduled scenario). Choose HTTP > Make a request — this is the standard request module, separate from the OAuth setup module you used in Step 2. When you configure it, select the OAuth connection you created in Step 2 from the Connection dropdown.

Configure the module as follows:

For after-hours coverage, you can also explore an AI front desk ServiceTitan integration to automatically capture jobs while you sleep.

You might also explore whether GoHighLevel integrates with ServiceTitan if you’re weighing platforms before committing to any automation stack.

URL: https://api.getjobber.com/api/graphql
Method: POST
Headers:

– Content-Type : application/json

– X-JOBBER-GRAPHQL-VERSION : 2024-10-18 (Jobber requires a version header — check Jobber’s API changelog for the current value)

Body type: Raw
Content type: JSON
Request content (copy-paste this template — do not type it manually):

{

“query”: “{ clients(first: 10, orderBy: {field: CREATED_AT, direction: DESC}) { nodes { id name email phone } } }”

}

Click “Run once” at the bottom left. If the OAuth connection is active and your headers are correct, you will see Jobber client data appear in the output panel.

From there, add a Google Sheets module after the HTTP module. Map the client name, email, and phone fields from the Jobber output into your spreadsheet columns.

Pro tip: Use Make’s built-in Scheduler to run this scenario every 15 minutes. New Jobber clients show up in your spreadsheet automatically.

You will know it worked when: Your Google Sheet populates with real client data from your Jobber account.

Pick One and Go: What to Do in the Next 30 Minutes

You do not need to build the entire automation today. You need to take one step that makes the second step inevitable. Here is your move:

Go to developer.getjobber.com and create your developer account. Set up your app. Get your Client ID and Client Secret saved somewhere secure.

That is it. That is the step that turns “I should automate this” into “I already started.” Once those credentials exist, connecting Make takes 20 minutes and building your first scenario takes 30 more.

two massive data rivers converging inside a cathedral-scale server hall at midnight, teal light refracting through crystalline conduits where the streams merge into one silent torrent, every packet finding its destination, the architecture humming in perfect sync — AIscending guide

Before You Go — Grab Your Free AI Tools Starter Kit

Join 250+ small business owners getting smarter about AI. Take the 2-minute quiz and get your personalized toolkit.

Get Your Free Kit →

Frequently Asked Questions

How much does Jobber cost for a small plumbing business?

Jobber’s Core plan is $49/month (as of May 2026) billed annually ( $119/month on monthly billing ). It covers scheduling, invoicing, and client management for a small team. Higher-tier plans add quoting and advanced reporting at higher price points. Jobber charges per account, not per user, so your cost does not scale with headcount.

Does Jobber work with accounting software?

Yes, Jobber has native integrations with popular accounting platforms so invoices, payments, and client details sync automatically. You do not need Make.com or any other automation tool to set up those core accounting connections, they are built into Jobber directly. Check Jobber’s integrations page for the current list of supported platforms.

Can I set up the Make and Jobber connection without an IT background?

Yes. The process uses Make’s visual builder and involves copying and pasting your Jobber API credentials and a JSON template request, no software development required. Most small business owners complete their first automation (like sending new job notifications to a spreadsheet) in under 90 minutes by following the steps above.

How long before I see time savings after automating with Make?

You can start saving time the same day you finish setup. Automations like syncing new Jobber clients to your CRM or triggering invoice follow-ups run the moment they are active. Most owners report reclaiming several hours a week after their first two or three scenarios are live.

How we create this content

AIscending articles are researched using public documentation, verified user reviews, and published benchmarks, then written with AI assistance and editorially reviewed for accuracy. Some links on this site are affiliate links — we may earn a commission if you sign up, at no extra cost to you. Affiliate relationships never influence our recommendations. Read our editorial policy for details.