A8gent
Build guide - Jobber + n8n

Jobber and n8n: build any automation without a node

There is no Jobber node in n8n. How to authenticate to Jobber's GraphQL API from the HTTP Request node, verify webhooks and ship a working workflow.

A8gent
·

What you get from this guide

  • Why n8n has no Jobber node, and why that changes almost nothing about what you can build
  • The OAuth 2.0 flow against Jobber, set up as a reusable n8n credential rather than hand-rolled token juggling
  • GraphQL queries and mutations written for the HTTP Request node, with the headers Jobber requires
  • Webhook subscription plus HMAC-SHA256 signature verification, so you never act on a forged payload
  • One complete workflow from quote event to follow-up task, and the rate limits that will bite you at scale

Why there is no Jobber node

If you have searched for a Jobber node in n8n and come up empty, you have not missed a setting. As of August 2026 n8n ships no built-in Jobber integration, and a query against n8n's public template library for Jobber returns zero workflows. The handful of pages that rank for this search are auto-generated connector stubs on aggregator sites, promising an integration that resolves to a generic HTTP call when you click through.

The reason is unglamorous. n8n writes dedicated nodes for the apps with the largest overlap with its user base, and field service management for trades sits outside that centre of gravity. Jobber is a substantial product with a real public API, it is simply not on the list. Nothing about that prevents you from automating it.

This turns out to matter less than people expect, because a node is a convenience wrapper. It pre-fills an endpoint, hides the authentication, and gives you a dropdown of operations. Underneath, it is making the same HTTP requests you can make yourself. What you lose without a node is discoverability - you have to read the API docs instead of picking from a menu. What you gain is that you are not limited to whatever operations the node author chose to expose. Against a GraphQL API, that is a genuine advantage: you can ask for exactly the fields you want in one round trip.

What this guide assumes

You have an n8n instance you can reach from the internet (self-hosted or Cloud), admin access to a Jobber account, and enough comfort with HTTP that words like "bearer token" do not slow you down. You do not need to have written GraphQL before.

What Jobber's API actually gives you

Jobber's developer platform documents a GraphQL API rather than a REST one. Every request is a POST to a single endpoint at https://api.getjobber.com/api/graphql, and the shape of the response is determined entirely by the query document in the request body. There are no per-resource URLs to learn.

Three headers are required on every call:

Required headers on every Jobber GraphQL request (as of August 2026)
HeaderValueWhy it matters
AuthorizationBearer <ACCESS_TOKEN>The OAuth 2.0 access token for the Jobber account being acted on. Expires roughly every 60 minutes.
X-JOBBER-GRAPHQL-VERSIONAn active API version stringJobber versions the schema and requires you to name the version you built against. Omitting it is the most common first-request failure.
Content-Typeapplication/jsonThe GraphQL query and its variables travel as a JSON body, so this is not optional.

Alongside the query API, Jobber offers webhooks so you can be told when something happens instead of polling for it. Webhook topics follow an OBJECT_ACTION naming pattern - a subscription to a client creation topic, for example, causes Jobber to POST to your endpoint each time a user creates a new client. The complete list of available topics is shown in the Developer Center when you configure a webhook for your app rather than being enumerated in the public docs, so plan to go and look rather than to guess topic names from a blog post.

One honest caveat before you build. Jobber's developer documentation sits behind bot protection, so the facts in this guide were verified through Jobber's indexed documentation and their own published developer material rather than by scraping the pages. Treat the specifics here as a map that gets you moving and confirm the exact scope names, topic names, and current API version against the Developer Center while you are signed in - those are the details most likely to have moved.

Authenticating from n8n's HTTP Request node

This is the part that stops most people, so it is worth being precise. Jobber does not issue static API keys. Authentication is OAuth 2.0, where an admin on each Jobber account authorises your app and you receive a client ID and client secret when the app is created. Even if you are the only person who will ever use the integration, you still walk through the consent flow once.

The authorization URL takes the familiar OAuth parameters - response_type=code, your client_id, the redirect_uri you registered, a state value, and a PKCE code challenge. You exchange the returned code at Jobber's token endpoint with grant_type=authorization_code, your client secret, the same redirect URI, and the code verifier. The token response carries an access token, a refresh token, and an expires_in of 3600 seconds.

1

Create the app and note the credentials

Register in Jobber's Developer Center and create an app. You will be given a client ID and a client secret. Set the redirect URI to a callback you control - if you are self-hosting n8n, the OAuth redirect URL that n8n shows you inside a Generic OAuth2 credential is the natural choice. Request the narrowest scopes that cover your workflow.

2

Let n8n own the token lifecycle

Create a Generic OAuth2 API credential in n8n with Jobber's authorize and token URLs, your client ID and secret, and authorization code as the grant type. Attach that credential to an HTTP Request node. n8n then stores the refresh token and renews the access token for you, which is worth doing properly because the alternative is a workflow that quietly stops at the 61-minute mark.

If you do hand-roll the refresh instead, the non-negotiable rule is that the new refresh token must be persisted the moment it comes back. Jobber documents refresh token rotation, and a rotated token you threw away is an integration you have to re-authorise by hand.

3

Set the headers once, in one place

Put the API version header on the HTTP Request node, not scattered through expressions. Better still, hold it in a single Set node at the top of the workflow and reference it, so upgrading the version later is one edit rather than an audit. The Authorization header comes from the credential, so you do not write it yourself.

The one-hour trap

Almost every "my Jobber workflow worked and then stopped" report comes down to token expiry. If you are testing manually you will never see it, because your token is fresh. Leave the workflow alone for two hours and run it again before you call it finished.

Writing GraphQL queries and mutations

A GraphQL request body is JSON with two keys: query, holding the query document, and variables, holding the values it references. Keeping values in variables rather than string-concatenating them into the query is not a style preference - it is what stops an apostrophe in a customer's name from breaking the request.

HTTP Request node - JSON body for a read

{
  "query": "query GetQuote($id: EncodedId!) {
    quote(id: $id) {
      id
      quoteNumber
      quoteStatus
      amounts { total }
      client { id firstName lastName emails { address } }
    }
  }",
  "variables": { "id": "{{ $json.itemId }}" }
}

Write and test the query in Jobber's GraphiQL explorer first, where you get schema autocomplete and immediate errors, then paste the working document into n8n. Debugging GraphQL through an HTTP node with no schema hints is a bad use of an afternoon.

Two habits pay for themselves. First, ask only for the fields you will actually use - Jobber prices requests by query cost, so a greedy query is a slow and expensive one. Second, remember that GraphQL returns HTTP 200 with an errors array when a query fails at the schema level. An n8n node checking only the status code will sail past a failed request. Add an IF node that inspects errors explicitly.

  • Paginate with cursors on any list query. Jobber's own guidance is to collect data in batches rather than all at once, precisely to stay under the cost limit.
  • Send mutations the same way as queries: same endpoint, same headers, a mutation document instead of a query document.
  • Check the errors array on every response, not just the HTTP status.
  • Keep the query documents in Set nodes or workflow-level variables if two workflows share them, so a schema change is one fix.

Webhooks and signature verification

Polling Jobber on a schedule works, but it burns your rate limit and adds latency to everything. Webhooks are better on both counts. You subscribe your app to a topic in the Developer Center and give Jobber a URL; the n8n Webhook node provides that URL.

Two things about the payload matter more than anything else in this guide.

First, verify the signature. Jobber signs webhook deliveries using an HMAC-SHA256 signature derived from your app's OAuth client secret. Your webhook URL is a public endpoint on the internet, and anyone who learns it can POST to it. Without verification, your automation will happily act on invented events. Compute the digest over the raw request body with your client secret and compare it to the signature header before doing anything else.

n8n Code node - verify before you trust

const crypto = require('crypto');

const raw = $input.first().json.body;      // raw string, not parsed
const signature = $input.first().json.headers['x-jobber-hmac-sha256'];

const expected = crypto
  .createHmac('sha256', $env.JOBBER_CLIENT_SECRET)
  .update(raw, 'utf8')
  .digest('base64');

const ok = crypto.timingSafeEqual(
  Buffer.from(expected),
  Buffer.from(signature || '')
);

if (!ok) throw new Error('Invalid Jobber webhook signature');
return $input.all();

Two details that break signature checks

Compare against the raw body, not a re-serialised version of the parsed JSON - key order and whitespace change the digest. And confirm the exact header name and encoding in the Developer Center, since that is the sort of detail that differs between providers and is not worth guessing.

Second, the payload is a pointer, not the record. Jobber sends event metadata and an identifier, not the full object. Your workflow's next step is always a GraphQL query using that id to fetch the fields you need. This is a feature: it means the data you act on is current at the moment you read it rather than at the moment the event fired, which matters when three edits land in quick succession.

A complete workflow, end to end

Here is the whole thing for a real automation: when a quote is sent from Jobber, create a follow-up record and notify the estimator. It exercises every piece above - webhook, verification, lookup, branch, write.

1

Webhook node receives the quote event

Set the node to POST, enable raw body access so the signature check has something to hash, and copy the production URL into the Developer Center against the quote topic you want. Fire a test event and confirm you see it arrive before building anything downstream.

2

Code node verifies the HMAC signature

Exactly the snippet above. Anything that fails verification throws, and the workflow's error handler picks it up. Do not log the client secret, and do not fall back to "process it anyway" when the header is missing.

3

HTTP Request node fetches the quote

Using the Generic OAuth2 credential and the version header, POST the quote query with the id from the payload. You get back the quote number, status, total, and the client's contact details in one round trip - which is the part a REST API would have made you do in three.

4

IF node checks the status is one you care about

A quote event fires on more transitions than the one you want. Branch on the status field so a quote that was archived, converted, or edited does not enter a follow-up sequence intended for quotes awaiting a response. Getting this filter right is most of the difference between a useful automation and an embarrassing one.

5

Write the follow-up record

Append a row to a sheet, Airtable base, or Postgres table with the quote id, client contact, amount, sent timestamp, status = open, step = 0, and a next-touch timestamp. This table is the state of the sequence. The quote follow-up guide covers why a state table beats multi-day wait nodes, and it applies here unchanged.

6

Notify the estimator

A Slack, email, or SMS node with the quote number, the client name, and the amount. Keep it to one line - the point is awareness, not a report.

7

Add an error workflow and a retry policy

Set an error workflow on the whole thing so a failure alerts a human rather than disappearing. On the HTTP Request node, enable retry on fail with a backoff, because a throttled Jobber response is a temporary condition that a second attempt usually clears.

Every other Jobber automation is a variation on this skeleton. Swap the topic and the query and you have job completion triggering a review request, invoice creation triggering a payment reminder, or a new client triggering a welcome sequence. The authentication and verification layers never change, which is why it is worth building them carefully once.

Rate limits, versioning, and what breaks

Jobber applies two independent limits. The first is a query cost model: each app and account pair holds a pool of points, every query deducts its cost from that pool, and points refill over time on a leaky bucket. A query that costs more than is currently available comes back throttled rather than executing. The second is DDoS protection middleware that limits a given app and account to 2,500 requests per five minutes, applied per app and account rather than per IP address.

Neither is tight for an owner-operated business automating its own workflows. Both become real if you backfill history, poll aggressively, or run the same integration across many Jobber accounts. Jobber's own advice is to paginate and collect data in batches, which is the whole mitigation for most builds.

What actually goes wrong with Jobber and n8n, and the fix
SymptomCauseFix
Worked in testing, dead the next morningAccess token expired after roughly 60 minutes and nothing refreshed it.Use a Generic OAuth2 credential, or persist the rotated refresh token every time.
HTTP 200 but nothing downstream is rightGraphQL returned an errors array with a 200 status and the workflow never looked.Add an IF node that checks for errors before the success branch.
Requests rejected immediatelyMissing or stale X-JOBBER-GRAPHQL-VERSION header.Set the version in one place and pin it to a version you have tested.
Throttled responses under loadA large unpaginated query exceeded the available query cost points.Paginate with cursors, request fewer fields, retry with backoff.
Automation fired on an event nobody triggeredWebhook signature never verified on a public endpoint.HMAC-SHA256 verification against the raw body, before any other node.
Integration stopped for several clients at onceAn app left in Draft state connected to more than five paying Jobber accounts.Move the app out of Draft, or build per-account custom integrations.

On versioning: Jobber adds a new API version when there are breaking or dangerous changes and supports older versions for twelve months after a newer one ships. That is a generous window, but it is a window. Put a calendar reminder at nine months rather than finding out from a broken workflow.

If you run a trades business and this is starting to sound like a project rather than an afternoon, that is a fair read - the authentication and verification work is genuinely the bulk of it. The HVAC and plumbing automation page covers which workflows are worth that effort first, and cleaning companies have a slightly different order of operations. For what a build like this costs to have done for you, see what an automation build actually costs.

FAQ

Is there a Jobber node in n8n?
No. As of August 2026 there is no built-in Jobber node in n8n, and a search of n8n's public template library for Jobber returns zero workflows. You connect Jobber through the generic HTTP Request node against its GraphQL API, plus a Webhook node for inbound events. That is not a workaround or a downgrade, it is simply how you integrate any app n8n has not written a dedicated node for.
Does Jobber have a REST API?
Jobber's public developer API is GraphQL. All API requests are sent as POST requests to a single GraphQL endpoint at api.getjobber.com, and what you get back is determined by the query document you send rather than by the URL path. If you are used to REST, the main adjustment is that you ask for exactly the fields you want and there is one endpoint rather than many.
Can I use a plain API key instead of OAuth?
No. Jobber documents OAuth 2.0 rather than static API keys: a company admin on each Jobber account authorises your app, and you receive a client ID and client secret when you create the app. This means the first hour of any Jobber integration is spent on the authorization flow, not on the automation itself. Budget for it.
How long do Jobber access tokens last?
Jobber's documented token response carries an expires_in of 3600 seconds, so an access token is good for about 60 minutes and then has to be refreshed. Refresh tokens can also be invalidated by app disconnection, a rolled client secret, re-authorisation after a scope change, or refresh token rotation, so build the failure path where a refresh returns an error and someone gets told.
What are the Jobber API rate limits?
Two separate limits apply. Jobber uses a query cost model where each app and account pair has a pool of points that queries draw down and that refills over time on a leaky bucket, returning a throttled response when a query costs more than is currently available. Separately, DDoS protection middleware limits a given app and account to 2,500 requests per five minutes. Paginate rather than requesting everything at once and both limits stay comfortably out of the way.
Do I need to publish an app in Jobber's marketplace?
Not for a single business automating its own account. Jobber documents custom integrations as apps that connect to one or more Jobber accounts for a purpose specific to that service provider, without any intent to publish in the App Marketplace. The one constraint to know about is that Jobber documents blocking API access for an app left in Draft state once it is detected connecting to more than five paying Jobber accounts, so an agency building for many clients needs a different plan from one business building for itself.
Should I self-host n8n for this?
It makes the OAuth callback and the token storage easier to reason about, because you control the URL and the database, but it is not required. n8n Cloud can hold a Generic OAuth2 credential and expose a webhook URL perfectly well. Choose based on whether you already run infrastructure, not on the Jobber integration, and see the platform comparison if you are still deciding.
What happens when Jobber changes its API?
Jobber versions the GraphQL API and requires an explicit version header on every request, adding a new version when there are breaking or dangerous changes, and supporting older versions for twelve months after a newer one ships. Pin the header to a version you have tested rather than tracking the newest, put the version in one place in your workflow, and set yourself a reminder well inside that twelve-month window.

Done for you

Want Jobber wired into the rest of your stack without spending a week on OAuth?

We build Jobber integrations against the GraphQL API - webhook verification, token handling, and the workflow on top - and hand over documentation you can maintain. The audit that decides what to build first is free.

The consult is free, and you keep whatever we build.

Keep building

The rest of the cluster