Skip to main content

Jobber Destination

Nexla's bi-directional connectors allow data to flow both to and from any location, making it simple to create a FlexFlow data flow that sends data to a Jobber location.
jobber_api_destination.png

Jobber

Create a Jobber Destination​

  1. Click the + icon on the Nexset that will be sent to the Jobber destination, and select the Send to Destination option from the menu.

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

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

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

Configure Using a Template​

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.

  • To configure this destination using a template, 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 (described in Configure Manually) 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.

Configure Manually​

Jobber destinations can 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.

Using manual configuration, you can also configure Nexla to automatically send the response received from the Jobber API after each call to a new Nexla webhook data source.

API Method​

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

  2. Select POST from the Method pulldown menu. All Jobber GraphQL requests—both queries and mutations—use the HTTP POST method.

Data Format​

  1. Select JSON as the content format from the Content Format pulldown menu. The Jobber GraphQL API requires requests to use the application/json content type, and the mutation payload must be a valid JSON object containing the GraphQL mutation string.

API Endpoint URL​

  1. Enter the Jobber GraphQL endpoint URL in the URL field:

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

All Jobber GraphQL write operations (mutations) are sent to the same endpoint as read operations: https://api.getjobber.com/api/graphql. The specific operation is determined by the content of the request body.

Request Headers​

Optional

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

    The Jobber connector credential automatically includes the Authorization: Bearer {token} header and the X-JOBBER-GRAPHQL-VERSION header. You do not need to add these manually. Only add headers here that are not already part of your Jobber credential configuration.

Exclude Attributes from the Call​

Optional

  • If any record attributes in the Nexset should be omitted when sending data to this Jobber destination, select the attributes from the Exclude Attributes pulldown menu.

  • Any number of attributes can be selected for exclusion, and all excluded attributes will be shown in the field. To remove an attribute from the list, click the X icon next to the attribute name.

Record Batching​

Optional

  1. If records should be sent to this destination in batched API calls, check the box next to Would you like to batch your records together? to enable record batching.

  2. Enter the maximum number of records that should be batched together in a single API call in the Batch Size field. By default, this value is set to 100.

  3. Select the algorithm that will be used to group records into batches from the Grouping Algorithm pulldown menu. The sample request shown in the panel on the right will be updated to reflect the current batching settings.

Jobber's GraphQL API processes one mutation per request. If batching is enabled, ensure your mutation format and grouping algorithm are compatible with sending multiple records within a single payload structure. For most Jobber mutation use cases, sending one record per request (no batching) is the recommended approach.

Response Webhook​

Optional

Nexla can automatically send the response received from the Jobber API after each call to a new Nexla webhook data source. This option allows you to keep track of the status of each API call and capture any data returned by Jobber after each mutation (such as the newly created record's ID or any validation errors).

  • To enable this option, check the box next to Would you like to process the API response as a Nexla Webhook source?.

Sample Request Payload​

Sample request payloads containing a portion of the Nexset data that will be sent to the Jobber API endpoint based on the current settings are shown in the Sample Payload panel on the right. These samples can be referenced to ensure that the destination and request settings are correctly configured.

  • Click on a sample request payload to expand it and view the complete payload content.
  • Sample payloads are automatically updated with each setting change, making it easy to verify that changes achieve the desired effect.

Endpoint Testing (Manual Configuration)​

After all endpoint settings have been configured, Nexla can send a test payload to the Jobber API to ensure that the destination is configured correctly.

  1. To send a test payload, select the Test button at the top of the Sample Payload panel, and click on a listed sample payload to expand it.

  2. If any modifications to the sample payload are needed, make the necessary changes directly within the sample window.

  3. Click the Send Test Data button at the top of a sample payload to send the test payload to the Jobber API using the current settings.

Save & Activate the Destination​

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