Jobber Data Source

The Jobber connector enables you to ingest field service data—clients, jobs, quotes, invoices, and properties—from your Jobber account into Nexla. Jobber's GraphQL API supports both single-page queries and cursor-based paginated queries, making it suitable for one-time exports as well as scheduled recurring data pipelines. Follow the instructions below to create a new data flow that ingests data from a Jobber source in Nexla.

Jobber

Create a New Data Flow

1. To create a new data flow, navigate to the Integrate section, and click the New Data Flow button. Then, select the desired flow type from the list, and click the Create button.

2. Select the Jobber connector tile from the list of available connectors. 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.

3. In Nexla, Jobber data sources can be created using pre-built endpoint templates, which expedite source setup for common Jobber GraphQL queries. Each template is designed specifically for the corresponding Jobber data object, making source configuration easy and efficient.
   • To configure this source using a template, follow the instructions in Configure Using a Template.

   Jobber sources can also be configured manually, allowing you to ingest data from any Jobber GraphQL endpoint not included in the pre-built templates or apply further customizations to exactly suit your needs.
   • To configure this source manually, follow the instructions in Configure Manually.

Configure Using a Template

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.

Endpoint Settings

• 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.

Endpoint Testing

Once the selected endpoint template has been configured, Nexla can retrieve a sample of the data that will be fetched according to the current settings. This allows users to verify that the source is configured correctly before saving.

• To test the current endpoint configuration, click the Test button to the right of the endpoint selection menu. Sample data will be fetched & displayed in the Endpoint Test Result panel on the right.

• If the sample data is not as expected, review the selected endpoint and associated settings, and make any necessary adjustments. Then, click the Test button again, and check the sample data to ensure that the correct information is displayed.

Configure Manually

Jobber data sources can 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 or mutation provided in the request body.

Manual configuration provides maximum flexibility for accessing Jobber data objects or applying filters not covered by the pre-built templates.

API Method

1. To manually configure this source, select the Advanced tab at the top of the configuration screen.

2. Select POST as the API method from the Method pulldown menu. All Jobber GraphQL requests use the HTTP POST method, regardless of whether the operation is a query (read) or mutation (write).

API Endpoint URL

3. Enter the Jobber GraphQL endpoint URL in the Set API URL field:

   https://api.getjobber.com/api/graphql

All Jobber API requests—both queries and mutations—are sent to the same endpoint: https://api.getjobber.com/api/graphql. The specific operation (query or mutation) is determined by the request body, not the URL.

Date/Time Macros (API URL)

Optional

Optionally, the API URL can be customized using macros—all macros added to the API URL will be converted into values when Nexla executes the API call. Macros are dynamic placeholders that allow you to create flexible API endpoints that can adapt to different time periods or data requirements.

For Jobber, date/time filtering is typically applied within the GraphQL query body rather than in the URL, since all requests go to the same endpoint. However, URL macros can be useful if you use a proxy or middleware layer in front of the Jobber API.

1. To add a macro, type { at the appropriate position in the API URL (within the Set API URL field), and select the desired macro from the dropdown list.

   • {now} – The current datetime
   • {now-1} – The datetime one time unit before the current datetime
   • {now+1} – The datetime one time unit after the current datetime
   • custom – Datetime macros can reference any number of time units before or after the current datetime—for example, enter (now-4) to indicate the datetime four time units before the current datetime

2. Select the format that will be applied to datetime macros from the Date Format for Date/Time Macro pulldown menu. This format will be applied to the base datetime value of the macro—i.e., the value of {now} in {now-1}.

3. Select the datetime unit that will be used to perform mathematical operations in the included macro(s) from the Time Unit for Operations pulldown menu—for example, for the macro {now-1}, when Day is selected, {now-1} will be converted to the datetime one day before the current datetime.

Lookup-Based Macros (API URL)

Optional

Column values from existing lookups can also be included as macros in the API URL. Lookup-based macros allow you to reference data from previously configured data sources or lookups, enabling dynamic API endpoints that can adapt based on existing data.

1. To include a lookup column value macro, select the relevant lookup from the Add Lookups to Supported Macros pulldown menu.

2. Type { at the appropriate position in the API URL, and select the lookup column-based macro from the dropdown list. Lookup-based macros are automatically populated into the macro list when a lookup is selected in the Add Lookups to Supported Macros pulldown menu.

Path to Data

Optional

Jobber's GraphQL API always returns a JSON response. The actual data records are nested within the response under the data key, then under the specific object name (e.g., clients, jobs, invoices), and finally within a nodes array. Specifying the path to data tells Nexla exactly which part of the response to treat as individual records.

For example, a query for clients returns a response structured as:

{
  "data": {
    "clients": {
      "nodes": [ ... ]
    }
  }
}

• To specify which data should be treated as relevant in responses from this source, enter the path to the relevant data in the Set Path to Data in Response field.

  • For Jobber GraphQL responses, enter the JSON path that points to the nodes array for your queried object. For example:
    • Clients: $.data.clients.nodes[*]
    • Jobs: $.data.jobs.nodes[*]
    • Invoices: $.data.invoices.nodes[*]
    • Quotes: $.data.quotes.nodes[*]
    • Properties: $.data.properties.nodes[*]
  Path to Data Example:

  For a Jobber clients query, the response data path is $.data.clients.nodes[*]. This tells Nexla to treat each element of the nodes array as a separate record in the resulting Nexset.

Autogenerate Path Suggestions

Nexla can also autogenerate data path suggestions based on the response from the API endpoint. These suggested paths can be used as-is or modified to exactly suit your needs.

• To use this feature, click the Test button next to the Set API URL field to fetch a sample response from the API endpoint. Suggested data paths generated based on the content & format of the response will be displayed in the Suggestions box below the Set Path to Data in Response field.

• Click on a suggestion to automatically populate the Set Path to Data in Response field with the corresponding path. The populated path can be modified directly within the field if further customization is needed.

  

Metadata

If metadata is included in the response but is located outside of the defined path to relevant data, you can configure Nexla to include this data as common metadata in each record. For Jobber GraphQL responses, useful metadata may include pagination information such as totalCount or pageInfo.

• To specify the location of metadata that should be included with each record, enter the path to the relevant metadata in the Path to Metadata in Response field.

  • For Jobber responses, pagination metadata is typically found at a path such as $.data.clients.pageInfo or $.data.clients.totalCount.

Request Headers

Optional

• If Nexla should include any additional request headers in API calls to this source, enter the headers & corresponding values as comma-separated pairs in the Request Headers field (e.g., header1:value1,header2:value2). For Jobber, the most common additional header is the API version header.

  The Jobber API uses the X-JOBBER-GRAPHQL-VERSION header to specify the API version (e.g., X-JOBBER-GRAPHQL-VERSION:2023-08-18). This header is pre-configured by the Nexla Jobber connector credential. You do not need to add it manually here unless you need to override the default version. Authorization headers are handled automatically by your Nexla credential.

Endpoint Testing

After configuring all settings for the selected endpoint, Nexla can retrieve a sample of the data that will be fetched according to the current configuration. This allows users to verify that the source is configured correctly before saving.

• To test the current endpoint configuration, click the Test button to the right of the endpoint selection menu. Sample data will be fetched & displayed in the Endpoint Test Result panel on the right.

• If the sample data is not as expected, review the selected endpoint and associated settings, and make any necessary adjustments. Then, click the Test button again, and check the sample data to ensure that the correct information is displayed.

Save & Activate the Source

1. Once all of the relevant steps in the above sections have been completed, 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.