Skip to main content

Setting up technical integrations with Roubler

Audience

This article is for IT / technical teams at customer organisations who need to:

  • Connect Roubler to other systems (e.g. HR, recruitment, payroll, identity)
  • Build or maintain API‑based or webhook‑based integrations with Roubler
  • Troubleshoot integration‑related errors

For end‑user “how to” (e.g. day‑to‑day use of Roubler), please refer to your standard user guides instead.

Before you start

Before implementing or changing any integration, make sure you have:

  1. Confirmed the integration type

    • Direct API integration your team is building using the public Roubler API (REST). Refer to the Roubler developer site for endpoint, payload and authentication details:  https://developer.roubler.com/.

    • Partner or middleware integrations (for example, payroll or recruitment systems) where a 3rd‑party platform calls the Roubler external API on your behalf (e.g. Expr3ss, SimplePay, Payspace, EnableHR, etc.).

  2. Roubler and partner access
    • Active Roubler subscription for the environment you are integrating.

    • Active subscription with any partner system involved (e.g. Expr3ss, payroll provider, HR platform).

  3. API / integration credentials

    Depending on the integration pattern, you may need:

    • Roubler API credentials or client registration (for direct API access or partner systems calling Roubler).

    • Credentials / configuration in the partner system (for example, SimplePay/Payspace tokens, EnableHR API user, etc.).

    These are usually exchanged and stored by the integrator (e.g. Expr3ss, EST/middleware, or your internal dev team).

  4. Non‑production environment (recommended)
    • If available, use a test or sandbox tenant plus test accounts in the connected system(s) before applying changes to production.
  5. Internal ownership
    • Nominate an internal owner (in your organisation) for each integration: they should understand what data is exchanged, and which system is “source of truth” for each data domain (employees, pay, leave, etc.).

What integrations are available?

Roubler supports several integration patterns. Availability for your organisation depends on your commercial agreement and enablement by MYOB/Roubler and/or partners.

1. Direct REST API integrations

  • Roubler provides an external API that can be consumed by your applications or by authorised integrators.

  • Typical use cases:
    • Creating or updating employees
    • Syncing data to/from HR, payroll, or middleware platforms

  • Technical reference:  https://developer.roubler.com/.

2. Recruitment / ATS integrations

  • Expr3ss! → Roubler

    • One‑way integration where Expr3ss calls the Roubler external API (endpoint named addEmployee (draft)) to create employees in Roubler when candidates are hired.

    • Records are created in Roubler in a draft/incomplete state for your team to complete onboarding.

    • This integration is implemented and primarily supported by Expr3ss, with Roubler providing API access.

3. HR / onboarding integrations

  • EnableHR → Roubler Reserve Bench

    • enableHR fields are mapped into Roubler Reserve Bench (for example, sending new hire information into Roubler).

    • This is typically used to streamline HR onboarding flows between enableHR and Roubler.

4. Payroll and time/leave integrations

  • SimplePay ↔ Roubler

    • Used to sync information such as leave, pay rate, and employee status between Roubler and SimplePay.

    • Failures are reported via “Roubler Integration Update” emails from the integration platform, listing each failed record and reason (e.g. “does not map serviceKey from Roubler to SimplePay”).

  • Payspace ↔ Roubler

    • Used for employee and pay data between Roubler and Payspace (for example, “Basic Integration” for employee details).

    • Access token issues on the Payspace side are surfaced as integration errors (e.g. “Error occurred in Payspace Access token, please reconnect Payspace company to proceed further.”).

Note: These payroll integrations are usually operated by an integration partner (e.g. Expert Solution Technologies) who runs a separate monitoring portal and email notifications.

5. Webhooks and event‑driven integrations

  • Roubler can send webhook events (for example, employee status changes) to downstream systems such as identity / SCIM providers or internal middleware.

  • This pattern is commonly used to:
    • Keep identity platforms in sync
    • Trigger downstream workflows when employees join, move, or leave

If you need a new integration or to confirm whether a specific product is supported, contact your MYOB/Roubler account manager or Roubler Support (see “Who to contact for help”).

Overview of OAuth 2.0 (conceptual)

Some Roubler integrations and API access patterns will use OAuth 2.0 for secure, delegated access. This is a high‑level overview only; always follow the exact configuration provided by Roubler and the partner system.

Key concepts

  • Resource Owner – the user or organisation who owns the data.
  • Client – the application that wants to access Roubler APIs (e.g. your middleware or a partner system).
  • Authorization Server – issues access tokens to clients once they are authorised.
  • Resource Server – the API endpoint (e.g. Roubler API) that validates tokens and serves data.

Common flows you may encounter

  • Client Credentials flow
    • Used for machine‑to‑machine calls (no interactive user).
    • Your integration service authenticates with its own client ID/secret and receives an access token.
  • Authorization Code flow (with or without PKCE)
    • Used when a user needs to grant access.
    • The user is redirected to log in and approve access; your app receives an authorization code, then exchanges it for an access token.

Tokens

  • Access token – sent with each API request (typically in the Authorization header).
  • Refresh token – optionally used to obtain a new access token without re‑prompting the user.

In all cases, you should:

  • Store secrets and tokens securely (e.g. in a secrets manager).
  • Handle HTTP 401/403 responses by refreshing tokens or re‑authorising, per the integration’s specification.
  • Limit scopes/permissions to the minimum required for your use case.

Frequently asked questions and troubleshooting

1. Where can I find the Roubler API reference?

The public API documentation is hosted at  https://developer.roubler.com/. This site will be expanded over time as more API types and fields are stabilised.

For partner‑owned integrations (e.g. Expr3ss → Roubler), field‑level behaviour is often documented by the partner rather than within Roubler docs.

2. Is this a Roubler‑owned integration or a partner‑owned one?

  • Partner‑owned (examples):

    • Expr3ss! integration – Expr3ss calls Roubler’s external API to create draft employees, and primary support is provided by Expr3ss (they control data processing, logic, and have their own error logs/diagnostics).

    • Some payroll integrations (SimplePay, Payspace) where Expert Solution Technologies manage the integration platform and issue “Roubler Integration Update” emails.

  • Roubler‑owned (examples):

    • Roubler webhooks (e.g. employee status change events).

    • Direct use of the Roubler external API by your own middleware or applications.

If unsure, check:

  • Who provided the integration documentation and credentials.

  • Whether failure emails come from a 3rd‑party platform (e.g. Expert Solution Technologies).

3. We’re getting “access token” / 401 errors from a payroll integration

Examples from common errors:

  • Payspace – "Error occurred in Payspace Access token, Please reconnect Payspace company to proceed further."

  • Generic JWT error – {"statusCode": 401, "message": "Invalid JWT."} during integration runs.

How to troubleshoot

  1. Check the failure email or monitor logs from the integration platform for the exact error message and time.

  2. Re‑establish the connection in the payroll system or middleware if instructed (e.g. reconnect the Payspace company, refresh the token or app connection).

  3. Confirm with your payroll / integration partner that:
    • The OAuth / access token configuration is still valid.
    • Client ID/secret or certificates have not expired or changed.
  4. If the error persists after reconnecting, provide:
    • Timestamps, employee IDs, and complete error text
    • Confirmation of which system is making the failing call
      to Roubler Support and the relevant partner (see “Who to contact for help”).

4. Employees or updates are not syncing into the target system

Common scenarios:

  • Employee terminations done in Roubler are not yet visible in SimplePay or similar.

  • New or changed employee data does not appear in payroll after several hours.

Checklist

  1. Confirm timing and expectations
    • Some integrations run on scheduled jobs (e.g. every X minutes/hours); check whether the expected job has run since your change.
    • Use the integration partner’s “Monitor Logs” or equivalent to see if:
      • The record was processed

      • It failed, and why.

  2. Look for specific failure reasons

    Example failures:

    • Duplicate email in Roubler – e.g. “Email address already exists in Roubler”.

    • Missing or invalid mapping – e.g. “Employee [Name] does not map serviceKey from Roubler to SimplePay”.

    In these cases, you typically need to:

    • Correct the underlying data (e.g. resolve duplicate emails, fix mapping keys).

    • Trigger a re‑sync from the source system (payroll / HR / middleware).

  3. Confirm the employee exists and is in scope

    • For recruitment integrations (e.g. Expr3ss), check whether employees are created as draft employees in the employee list rather than in Reserve Bench, depending on the integration behaviour.

  4. If you still cannot see the record after these checks, gather:
    • Employee identifier(s)
    • Date/time of change
    • Screenshots of source and target systems
      and share them with Roubler Support and, if applicable, the integration partner.

5. We see many “Roubler Integration Update” emails – what should we do with them?

“Roubler Integration Update” emails are generated by a middleware platform when integrations run. They:

  • List each integration system and company, the module (e.g. Leave, PayRate, Basic Integration), and whether each row was Success or Failure.

  • Include the reason for failure per row (e.g. invalid token, duplicate email, missing mapping, business rule violations like conflicting leave records).

Best practice:

  1. Route these emails to a shared mailbox or distribution list monitored by your IT or payroll ops team.
  2. Capture and address repeated failure types (e.g. mapping issues, data quality problems).
  3. For systemic or unclear failures, forward a copy to Roubler Support and the integration partner, noting:

    • Whether the integration is actually used (some clients receive error emails for unused integrations).

Who to contact for help

To get the right support quickly, please use the following paths:

  1. Partner / integrator support (where applicable)
    • Expr3ss! integration

      • Primary investigation and resolution are led by Expr3ss, as they manage data processing, logic, and error logs.

      • Involve Expr3ss support for:
        • Field‑level mapping questions

        • Errors originating inside Expr3ss or its call to Roubler’s addEmployee (draft) endpoint.

    • Payroll integrations (SimplePay, Payspace, others)
      • Engage your payroll provider and/or the integration platform operator (e.g. Expert Solution Technologies) for:
        • Access token errors
        • Mapping issues (e.g. serviceKey mismatches)

        • Clarification on rules that cause failures in the integration logs.

  2. Roubler Support Support

    Contact Roubler Support (via your normal support channel or in‑app help) when:

    • You need help confirming whether an integration is supported or enabled for your tenant (including webhooks and new integrations).

    • You suspect issues in Roubler’s API, webhooks, or tenant configuration.

    • You need assistance coordinating with partners (where Roubler must adjust API access, credentials, or tenant‑level configuration).

When logging a support ticket, include:

  • Your company name and Roubler environment (production / test)
  • The integration in question (e.g. SimplePay, Payspace, Expr3ss, EnableHR, custom API, webhooks)
  • Exact error messages, timestamps, and at least one example employee or record
  • Any recent configuration changes in either Roubler or the connected system

This information significantly reduces investigation time and helps route your case to the right technical team.