Jobber

Jobber is a cloud-based field service management platform for home service businesses. It helps companies in landscaping, cleaning, HVAC, plumbing, electrical, and pest control run their entire operation — client management, job scheduling, quoting, invoicing, payments, and team coordination. Its GraphQL API lets developers access and modify account data for analytics, reporting, and BI tools.

Power end-to-end data operations for your Jobber API with Nexla. Our bi-directional Jobber connector is purpose-built for Jobber, making it simple to ingest data, sync it across systems, and deliver it anywhere — all with no coding required. Nexla turns API-sourced data into ready-to-use, reusable data products and makes it easy to send data to Jobber or any other destination. With comprehensive monitoring, lineage tracking, and access controls, Nexla keeps your Jobber workflows fast, secure, and fully governed.

Features

Type: API

SourceDestination

• Seamless API Integration: Connect to any endpoint as source or destination without coding, with automatic data product creation
• Visual Composition & Chaining: Build complex integrations using visual templates, chain API calls, and compose workflows with data validation and filtering
• API Proxy: Expose curated slices of your data securely with a secure and customizable API proxy that validates and transforms data on the fly
• Request optimization with intelligent batching, retry, and caching to minimize API calls and costs

Prerequisites

Nexla connects to Jobber using the OAuth 2.0 authorization code flow. To complete credential setup, you must first register an application in the Jobber Developer Center to obtain a Client ID and Client Secret.

Create a Jobber Developer Center App

1. Sign in to or create an account at the Jobber Developer Center.

2. Navigate to the Apps page in the Developer Center dashboard.

3. Click Create App (or New App) to begin creating a new application.

4. Fill in the required application details:

   • App Name: Enter a descriptive name for your integration (e.g., "Nexla Integration").

   • Redirect URI: Enter https://app.nexla.io/oauth/callback as the redirect URI. This is the URL to which Jobber will redirect after a user authorizes your application.

5. Save or submit the app registration form. Jobber will generate and display your application credentials:

   • Client ID: A publicly visible identifier for your application.

   • Client Secret: A confidential string used to authenticate your application with the Jobber API. Store this value securely and do not share it.

The Client Secret is displayed only once at the time of app creation. Copy it immediately and store it in a secure location such as a password manager or secrets vault. Additional details about the OAuth 2.0 flow are available in the Jobber App Authorization documentation.

6. Note the API Version used by the Jobber GraphQL API. The default version used by the Nexla connector is 2023-08-18, which is sent in the X-JOBBER-GRAPHQL-VERSION request header. Consult the Jobber API changelog if you need to use a different version.

Authenticate

Credentials required

Authenticate with Jobber using OAuth 2.0 authorization code flow. Requires Client ID and Secret from Jobber Developer Center.

Field	Required	Secret	Description
Client ID	Yes	No	OAuth2 Client ID from your Jobber Developer Center app
Client Secret	Yes	Yes	OAuth2 Client Secret from your Jobber Developer Center app

Create a credential in Nexla

1. After selecting the data source/destination type, click the Add Credential tile to open the Add New Credential overlay.

2. Enter a name for the credential in the Credential Name field and a short, meaningful description in the Credential Description field.

3. Jobber uses the OAuth 2.0 authorization code flow (3-legged OAuth). Enter the Client ID from your Jobber Developer Center app in the Client ID field. This value is the publicly visible identifier for your registered application.

4. Enter the Client Secret from your Jobber Developer Center app in the Client Secret field. This value authenticates your application with the Jobber API and must be kept confidential.

   Nexla pre-configures the API version (default 2023-08-18, sent in the X-JOBBER-GRAPHQL-VERSION header) and the GraphQL query used to validate the credential (default query { account { id name } }). These are hidden from the standard credential form and are suitable for most integrations; contact your Nexla administrator if you need to override them.

5. After entering your Client ID and Client Secret, click Authorize (or Connect) to initiate the OAuth 2.0 authorization flow. You will be redirected to the Jobber login and authorization page; sign in to your Jobber account and click Authorize to grant Nexla access to your Jobber data. After successful authorization, you will be redirected back to Nexla, and the credential will be validated automatically using a test GraphQL query against the Jobber API.

6. Click the Save button at the bottom of the overlay. The newly added credential will now appear in a tile on the Authenticate screen during data source/destination creation and can be selected for use with a new data source or destination.

Use as a data source

To create a new data flow, navigate to the Integrate section, and click the New Data Flow button. Select the Jobber connector tile, then select the credential that will be used to connect to the Jobber instance, and click Next; or, create a new Jobber credential for use in this flow.

Endpoint templates

Nexla provides pre-built templates that can be used to rapidly configure data sources to ingest data from common Jobber endpoints. Each template is designed specifically for the corresponding Jobber GraphQL query, making data source setup easy and efficient. Select the endpoint from which this source will fetch data from the Endpoint pulldown menu. Available endpoint templates are listed in the expandable boxes below. Click on an endpoint to see more information about it and how to configure your data source for this endpoint.

Query Clients

Fetches client data using a custom GraphQL query. Use this template when you need to retrieve client records from your Jobber account and can supply your own GraphQL query string and response path. Supports single-page results.

• Enter your GraphQL query string in the GraphQL Query field. This is the full GraphQL query that will be sent to the Jobber API at https://api.getjobber.com/api/graphql. For example, to retrieve basic client information:

  • query { clients(first: 50) { nodes { id firstName lastName companyName emails { address } } } }
• Enter the JSON path to the data within the GraphQL response in the Response Path field. For example, if your query returns clients nested at data.clients.nodes, enter $.data.clients.nodes[*] as the response path. This tells Nexla where to find the individual records within the API response.

The Jobber GraphQL API endpoint is https://api.getjobber.com/api/graphql and requires POST requests. The Query Clients template sends a single request; for large datasets spanning multiple pages, use the Query Clients (Paginated) template instead. For a full reference of available fields and query syntax, consult the Jobber GraphQL documentation.

Query Clients (Paginated)

Fetches all pages of client data using cursor-based pagination. Use this template when your Jobber account has a large number of clients and you need to retrieve all records across multiple pages. This template automatically handles Jobber's cursor-based pagination to fetch every page of results.

• This template is pre-configured with a two-step paginated query. The first step fetches the initial page of up to 50 client records and captures the cursor from pageInfo.endCursor. The second step iterates using the cursor value to retrieve subsequent pages until all records have been fetched.
• No additional configuration is required beyond selecting this endpoint template. The template automatically retrieves the following client fields: id, firstName, lastName, companyName, emails { address }, and balance.

Jobber uses cursor-based pagination—each page returns a pageInfo.endCursor value that is used as the after argument in the next request. This template manages that process automatically. To retrieve different or additional client fields, use the Query Clients template and supply a custom GraphQL query.

Query Jobs

Fetches job data using a custom GraphQL query. Use this template when you need to retrieve job records from your Jobber account and can supply your own GraphQL query string and response path. Supports single-page results.

• Enter your GraphQL query string in the GraphQL Query field. For example, to retrieve basic job information:

  • query { jobs(first: 50) { nodes { id jobNumber title jobStatus createdAt client { id name } } } }
• Enter the JSON path to the records within the GraphQL response in the Response Path field. For example, $.data.jobs.nodes[*] to access individual job records from within the response.

Jobber job records include details such as job number, title, instructions, status, scheduling information, and associated client. For a full list of available job fields, refer to the Jobber GraphQL schema documentation.

Query Jobs (Paginated)

Fetches all pages of job data using cursor-based pagination. Use this template when you need to retrieve all job records from a Jobber account that contains a large number of jobs.

• This template is pre-configured with a two-step paginated query that retrieves up to 50 job records per page and automatically follows the cursor to fetch all subsequent pages. The following job fields are retrieved: id, jobNumber, title, instructions, jobStatus, createdAt, and client { id name }.
• No additional configuration is required beyond selecting this endpoint template. The template manages the full pagination cycle automatically.

Job status values in Jobber include states such as unscheduled, scheduled, active, completed, requires_invoicing, and archived. Use the Query Jobs template with a custom query to filter jobs by status or add additional fields.

Query Quotes

Fetches quote data using a custom GraphQL query. Use this template when you need to retrieve quote records from your Jobber account and can supply your own GraphQL query string and response path. Supports single-page results.

• Enter your GraphQL query string in the GraphQL Query field. A sample query to retrieve quotes:

  • query { quotes(first: 50) { nodes { id quoteNumber title total quoteStatus createdAt client { id name } } } }
• Enter the JSON path to the records within the response in the Response Path field (e.g., $.data.quotes.nodes[*]).

Jobber quotes capture pricing and scope information for potential jobs. Quote status values typically include draft, sent, approved, converted, archived, and changes_requested. For pagination support, use the Query Clients (Paginated) pattern as a reference and adapt it to the quotes object.

Query Invoices

Fetches invoice data using a custom GraphQL query. Use this template when you need to retrieve invoice records from your Jobber account and can supply your own GraphQL query string and response path. Supports single-page results.

• Enter your GraphQL query string in the GraphQL Query field. A sample query to retrieve invoices:

  • query { invoices(first: 50) { nodes { id invoiceNumber subject total amountDue invoiceStatus createdAt client { id name } } } }
• Enter the JSON path to the records within the response in the Response Path field (e.g., $.data.invoices.nodes[*]).

Jobber invoice records contain billing details including invoice number, subject, total amount, amount due, and payment status. Invoice status values typically include draft, sent, paid, partial, bad_debt, and void.

Query Invoices (Paginated)

Fetches all pages of invoice data using cursor-based pagination. Use this template when you need to retrieve all invoice records from a Jobber account that contains a large number of invoices.

• This template is pre-configured with a two-step paginated query that retrieves up to 50 invoice records per page and automatically follows the cursor to fetch all subsequent pages. The following invoice fields are retrieved: id, invoiceNumber, subject, total, amountDue, invoiceStatus, createdAt, and client { id name }.
• No additional configuration is required beyond selecting this endpoint template.

Cursor-based pagination is managed automatically by this template. Each page fetches up to 50 records; the cursor from pageInfo.endCursor is used to advance to the next page until hasNextPage is false.

Query Properties

Fetches property data using a custom GraphQL query. Use this template when you need to retrieve service location (property) records from your Jobber account. This template supports filtering by client ID and other custom query parameters.

• Enter your GraphQL query string in the GraphQL Query field. A sample query to retrieve properties:

  • query { properties(first: 50) { nodes { id address { street1 street2 city province postalCode country } client { id name } } } }
• Enter the JSON path to the records within the response in the Response Path field (e.g., $.data.properties.nodes[*]).

Properties in Jobber represent the physical service locations associated with clients. Each property stores address details and is linked to a client record. Properties are required when scheduling jobs at specific service addresses.

Once the selected endpoint template has been configured, click the Test button to the right of the endpoint selection menu to retrieve a sample of the data that will be fetched. Sample data will be displayed in the Endpoint Test Result panel on the right, allowing you to verify that the source is configured correctly before saving.

Manual configuration

Jobber data sources can also be manually configured to ingest data from any valid Jobber GraphQL query. Because Jobber's API is entirely GraphQL-based, all requests are sent as HTTP POST requests to the single endpoint https://api.getjobber.com/api/graphql, with the query provided in the request body. Select the Advanced tab at the top of the configuration screen, and follow the instructions in Connect to Any API to configure the API method, endpoint URL, date/time and lookup macros, path to data, metadata, and request headers.

Jobber's GraphQL responses nest records under data.<object>.nodes. Set the Path to Data in Response field accordingly for each object type: Clients $.data.clients.nodes[*], Jobs $.data.jobs.nodes[*], Invoices $.data.invoices.nodes[*], Quotes $.data.quotes.nodes[*], and Properties $.data.properties.nodes[*]. Pagination metadata (such as totalCount or pageInfo) can be captured via the Path to Metadata in Response field—for example, $.data.clients.pageInfo. The X-JOBBER-GRAPHQL-VERSION header is pre-configured by the Nexla Jobber credential and does not need to be added manually unless overriding the default version.

Once all of the relevant settings have been configured, click the Create button in the upper right corner of the screen to save and create the new Jobber data source. Nexla will now begin ingesting data from the configured endpoint and will organize any data that it finds into one or more Nexsets.

Use as a destination

Click the + icon on the Nexset that will be sent to the Jobber destination, and select the Send to Destination option from the menu. Select the Jobber connector from the list of available destination connectors, then select the credential that will be used to connect to the Jobber account, and click Next; or, create a new Jobber credential for use in this flow.

Endpoint templates

Nexla provides pre-built templates that can be used to rapidly configure destinations to send data to common Jobber endpoints. Each template is designed specifically for the corresponding Jobber GraphQL mutation, making destination setup easy and efficient. Select the endpoint to which data will be sent from the Endpoint pulldown menu. Then, click on the template in the list below to expand it, and follow the instructions to configure additional endpoint settings.

Create Client

Creates a new client record in Jobber using the GraphQL clientCreate mutation. Use this template when you need to create new client records in Jobber from data in another system, such as a CRM, marketing platform, or e-commerce database.

• The request body must be a valid JSON object containing a GraphQL mutation that follows Jobber's clientCreate input schema. The Nexset data sent to this destination should be transformed to match the required mutation format before reaching this destination. A typical payload looks like:

  {
    "query": "mutation { clientCreate(input: { firstName: \"Jane\", lastName: \"Smith\", emails: [{ address: \"jane@example.com\", primary: true }] }) { client { id firstName lastName } userErrors { message path } } }"
  }

• The clientCreate mutation supports a variety of input fields including firstName, lastName, companyName, emails, phones, and notes. Refer to the Jobber GraphQL documentation for the complete list of supported input fields.
• The response from Jobber will include the newly created client's id and any userErrors that occurred. Enabling the response webhook option in the destination's manual configuration allows Nexla to capture and process the API response for each mutation call.

Jobber's clientCreate mutation validates input data and returns user-friendly error messages in the userErrors field if required fields are missing or invalid. Review these errors to troubleshoot failed record creation.

Create Job

Creates a new job record in Jobber using the GraphQL jobCreate mutation. Use this template when you need to create new job records in Jobber, such as when provisioning jobs from an external work order system or customer portal.

• The request body must be a valid JSON object containing a GraphQL mutation that follows Jobber's jobCreate input schema. Required fields typically include the client ID and property ID. A basic payload example:

  • The jobCreate mutation requires at minimum a clientId and a propertyId to associate the job with an existing Jobber client and service location.
  • Optional fields include title, instructions, startAt, endAt, and lineItems.
• Ensure that the client and property records referenced in the job creation payload already exist in Jobber before sending data to this destination. Use the Create Client template to create client records first if needed.

For a complete list of supported jobCreate input fields and their formats, refer to the Jobber GraphQL mutations documentation.

Create Quote

Creates a new quote record in Jobber using the GraphQL quoteCreate mutation. Use this template when you need to generate Jobber quotes from external data, such as from a pricing engine or proposal management tool.

• The request body must be a valid JSON object containing a GraphQL mutation that follows Jobber's quoteCreate input schema. Quotes in Jobber are associated with a client and can include line items with descriptions, quantities, and unit prices.
• The Nexset data sent to this destination should be pre-transformed to match the mutation format. Line items can be included within the mutation input to specify the services or products being quoted.

Quotes created via the API are initially created in draft status. They can be sent to the client directly from the Jobber interface or via a subsequent API mutation. Refer to the Jobber developer documentation for details on the quote lifecycle and available status transitions.

Create Invoice

Creates a new invoice record in Jobber using the GraphQL invoiceCreate mutation. Use this template when you need to generate Jobber invoices from external billing systems, completed job data, or automated billing workflows.

• The request body must be a valid JSON object containing a GraphQL mutation that follows Jobber's invoiceCreate input schema. Invoices in Jobber are associated with a client and optionally with a specific job. Required fields typically include the client ID and one or more line items.
• Line items in the invoice should include a description, unit price, and quantity. Additional fields such as tax rates and discount amounts are also supported in the input schema.

Invoices created via the API begin in draft status. They must be sent to be visible to clients. Use the Jobber interface or a separate mutation to transition invoices to sent status. For complete input schema details, refer to the Jobber GraphQL documentation.

Update Job

Updates an existing job record in Jobber using the GraphQL jobUpdate mutation. Use this template when you need to synchronize job status changes, scheduling updates, or other job modifications from an external system into Jobber.

• The request body must be a valid JSON object containing a GraphQL mutation that follows Jobber's jobUpdate input schema. The mutation requires the Jobber jobId of the record to be updated, along with the fields to modify.
• Fields that can be updated include title, instructions, startAt, endAt, and lineItems. Ensure the Nexset includes the correct Jobber job ID for each record to be updated.

Job IDs can be retrieved using the Query Jobs or Query Jobs (Paginated) source templates. When building an update workflow, consider first using a Jobber data source to retrieve current job IDs and then referencing those IDs in the update mutation payload.

Custom Mutation

Executes any custom GraphQL mutation against the Jobber API. Use this template when none of the pre-built mutation templates match your use case, or when you need to perform write operations on Jobber objects not covered by the other templates.

• The request body must be a complete, valid GraphQL mutation request formatted as a JSON object with a query key containing the mutation string. The mutation must conform to the Jobber GraphQL schema.

• This template sends the Nexset data payload directly as the request body ({message.json}). Ensure your Nexset records are pre-formatted as complete GraphQL mutation objects before reaching this destination. Common use cases include:

  • Updating client contact information
  • Creating or updating expense records
  • Managing time sheet entries
  • Triggering status transitions on quotes or invoices

To explore all available mutations in the Jobber GraphQL schema, navigate to the Jobber Developer Center, open your app, click the three-dot menu, and select Test in Playground. Click the DOCS button in the GraphQL Playground to browse the full schema including all available mutations and their input types. Additional information is available in the Jobber GraphQL documentation.

Manual configuration

Jobber destinations can also be manually configured to send data to any valid Jobber GraphQL mutation endpoint. Because Jobber's API is entirely GraphQL-based, all write operations are performed as HTTP POST requests to https://api.getjobber.com/api/graphql, with the mutation provided in the request body as application/json. Select the Advanced tab at the top of the configuration screen, and follow the instructions in Connect to Any API to configure the API method, data format, endpoint URL, request headers, attribute exclusions, record batching, and response webhooks.

The Jobber connector credential automatically includes the Authorization: Bearer {token} header and the X-JOBBER-GRAPHQL-VERSION header; only add headers here that are not already part of your Jobber credential configuration. Jobber's GraphQL API processes one mutation per request—for most Jobber mutation use cases, sending one record per request (no batching) is the recommended approach.

Save & activate

Once all endpoint settings have been configured, click the Done button in the upper right corner of the screen to save and create the destination. To send the data to the configured Jobber destination, open the destination resource menu, and select Activate.

The Nexset data will not be sent to Jobber until the destination is activated. Destinations can be activated immediately or at a later time, providing full control over data movement.