Ellipse Gradient for Header

UKG Ready Integration Guide

UKG Ready integrates with enterprise systems through provisioned REST APIs, selected event notifications, scheduled synchronization, and customer-approved file exchanges.

UKG Ready integration options at a glance

UKG Ready integrations should primarily use the REST APIs available for the customer’s tenant, licensed modules, permissions, and provisioned API product. Martini can authenticate to those APIs, retrieve or update Employees, Jobs, Departments, Locations, Timecards, and other confirmed resources, then transform and route the data through workflows. Selected UKG configurations may provide outbound callbacks or event notifications, but broad webhook coverage should not be assumed. Scheduled incremental synchronization is the safer default where events are unavailable. Customer-approved CSV, Excel, or other file exports can also be processed when API coverage is insufficient, with credentials and tenant-specific settings stored securely as Martini secrets.

Integration pointSupported by UKG Ready?Common use casesHow Martini supports it
REST APIsYesRetrieve and, where supported, create or update Employees, Jobs, Departments, Locations, Timecards, Time-off requests, and other tenant-provisioned resources. Exact endpoints, operations, filters, and models depend on the customer’s UKG Ready API product and modules.Martini can consume UKG Ready REST APIs from workflows, apply authentication, pagination, filtering, validation, mapping, retries, and idempotent upserts, and expose normalized REST APIs for downstream systems.
Webhooks / outbound callbacksLimitedSelected UKG configurations may provide outbound callbacks or event notifications for particular resources or events. Broad coverage across employee, time, payroll, and leave objects is not confirmed.Martini can receive supported UKG notifications through a workflow trigger, deduplicate the notification, retrieve the authoritative resource, and continue downstream processing. Scheduled reconciliation should remain available.
Bulk / asynchronous / batch APIsLimitedBatch or export capabilities may be available through particular UKG integration products or customer configurations. Broad product-wide bulk API support was not verified.Martini can orchestrate paginated and controlled batch retrieval, checkpoint progress, constrain concurrency, process approved exports, and resume failed windows.
File import/exportLimitedCustomer-approved CSV, Excel, or other file exports and imports may support selected UKG Ready workflows where API coverage is insufficient. Formats and delivery channels must be confirmed.Martini can receive or retrieve files, parse and validate rows, map fields to canonical models, apply business rules, and load accepted results into downstream applications.
AuthenticationLimitedUKG provides authenticated API access, including OAuth-based access for at least some modern offerings. Exact grant types, scopes, credentials, tenant URLs, and provisioning requirements vary by API product.Martini can store tenant-specific credentials, tokens, client settings, and environment values as secrets and use them from workflows consuming UKG Ready APIs.
SOAP APIsNot confirmedA current general-purpose UKG Ready SOAP API was not verified. A specific legacy interface should be used only when UKG supplies an official service definition and documentation.Martini can consume SOAP services when an official UKG service definition is provided, but SOAP should not be selected as the default UKG Ready integration mechanism.
Database / analytics accessNot confirmedDirect access to the hosted UKG Ready application database was not verified and should not be assumed. APIs, reports, exports, or approved integration interfaces are the appropriate alternatives.Martini can connect to approved downstream databases or data stores, but it should not be designed around direct UKG Ready database access.

How UKG Ready exposes data and business events

UKG Ready REST APIs

UKG provides REST-oriented API capabilities through its developer ecosystem. The available resources, operations, models, filters, and pagination behavior depend on the customer’s UKG Ready tenant, licensed modules, permissions, and provisioned API product.

Martini implementation pattern

Martini uses a workflow to authenticate to the confirmed UKG Ready API, retrieve or update resources, handle pagination and incremental filters, transform payloads, apply business rules, and write results to downstream systems or a controlled data store. Martini can also expose a REST API that presents normalized UKG data to consumers.

Implementation sequence

Confirm the UKG Ready tenant, modules, API product, resources, and permissions
Store UKG credentials, tokens, tenant settings, and environment values as Martini secrets
Invoke the documented UKG Ready REST resource
Follow pagination and persist a synchronization checkpoint
Validate and map the UKG payload to the target model
Apply status, effective-date, and reference-data business rules before writing the result

UKG Ready Event Notifications

Selected UKG configurations may provide outbound callbacks or event notifications, but broad coverage across Employees, Timecards, payroll, and Time-off requests is not confirmed. Event availability must be verified for the customer’s tenant and API product.

Martini implementation pattern

Martini can receive a supported notification through a workflow trigger, authenticate or validate it according to the UKG configuration, deduplicate it, and retrieve the current UKG resource before processing. Scheduled reconciliation should supplement event-driven processing because notifications may be limited or unavailable.

Implementation sequence

Confirm supported UKG Ready event types and callback security requirements
Receive the notification with a Martini workflow trigger
Validate the notification and reject unauthorized or malformed requests
Deduplicate the event using its available identifier or resource key
Retrieve the authoritative UKG resource through the REST API
Apply the downstream mapping and retain scheduled reconciliation as a fallback

UKG Ready File Exchanges

Customer-approved CSV, Excel, or other file exports and imports may be available for selected UKG Ready workflows. File formats, delivery channels, schedules, and module coverage must be confirmed with UKG or the implementation partner.

Martini implementation pattern

Martini can orchestrate a file-based workflow when the required data is not available through the provisioned API. The workflow parses the file, validates required columns and reference values, maps rows to a canonical model, routes rejected rows for review, and writes accepted data to target systems.

Implementation sequence

Confirm the approved UKG file format, delivery location, schedule, and ownership
Receive or retrieve the UKG export in the Martini workflow
Validate the file structure, required fields, and duplicate rows
Map employee, organizational, time, or leave fields to the target model
Write accepted rows and route rejected rows to controlled exception handling
Record the file checkpoint and prevent reprocessing of the same delivery

Common UKG Ready integration patterns

Pattern 1: Synchronize employees and organizational data

When to use this pattern

Use this pattern when UKG Ready is the authoritative source for workforce identity and organizational attributes that must be reflected in identity, service management, finance, or business applications. Scheduled incremental retrieval is appropriate where broad UKG event coverage is unavailable.

Integration direction
UKG Ready
Martini
Microsoft Entra ID / ServiceNow / Salesforce
Example Mapping
UKG Ready FieldCanonical FieldTarget Field
employeeIdworker.externalIdexternalEmployeeId
employmentStatusworker.statusactive
departmentCodeorganization.departmentCodedepartment
locationCodeorganization.locationCodelocation
Martini implementation pattern

A scheduled Martini workflow retrieves changed Employees, Jobs, Departments, and Locations using documented filters and pagination where available. It validates organizational references, normalizes status and effective dates, applies joiner-mover-leaver or ownership rules, and performs idempotent target updates. Failed records are routed separately from transient API failures, which can be retried with backoff.

Martini capabilities used
  • workflows
  • API consumption
  • scheduling
  • data mapping
  • business rules
  • validation
  • error handling

Pattern 2: Send approved timecards to finance or payroll

When to use this pattern

Use this pattern when approved UKG Ready Timecards must be transferred to NetSuite, ADP, finance, project accounting, or billing systems. The workflow should distinguish approved, corrected, reopened, and historical time.

Integration direction
UKG Ready
Martini
NetSuite / ADP
Example Mapping
UKG Ready FieldCanonical FieldTarget Field
timecardIdtimeEntry.externalIdexternalTimeEntryId
employeeIdworker.externalIdemployee
hourstimeEntry.quantityhours
departmentCodecosting.departmentCodedepartment
Martini implementation pattern

Martini retrieves approved or changed Timecards for a controlled payroll or accounting window, validates employee, job, department, and location references, converts time zones and period boundaries as required, and maps the result to the target API. Cross-reference keys and source statuses prevent duplicate postings, while corrections and rejected records follow explicit exception paths.

Martini capabilities used
  • workflows
  • API consumption
  • pagination
  • data transformation
  • validation
  • idempotent upserts
  • retry handling

Pattern 3: Synchronize approved time-off requests

When to use this pattern

Use this pattern when downstream scheduling, workforce, payroll, or employee-facing systems need approved UKG Ready leave information and status changes. It is especially useful when requests can be corrected, cancelled, or reapproved.

Integration direction
UKG Ready
Martini
ServiceNow / Workday
Example Mapping
UKG Ready FieldCanonical FieldTarget Field
timeOffRequestIdleave.externalIdrequestId
employeeIdleave.workerIdemployee
statusleave.approvalStatusapprovalState
startDateleave.startDatestart
Martini implementation pattern

A Martini workflow retrieves changed Time-off requests and, where exposed, balances or approval details. It preserves the UKG request identifier, evaluates approval and cancellation rules, converts dates using the tenant or location time zone, and sends only eligible state changes downstream. Reconciliation and duplicate checks protect against repeated processing.

Martini capabilities used
  • scheduled workflows
  • API consumption
  • mapping
  • date and time transformation
  • business rules
  • idempotency
  • monitoring

Pattern 4: Event-assisted employee provisioning

When to use this pattern

Use this pattern only when the customer’s UKG Ready configuration provides supported outbound notifications for the required employee events. It provides faster lifecycle processing while retaining scheduled reconciliation for missed or unsupported events.

Integration direction
UKG Ready
Martini
Okta / Microsoft Entra ID
Example Mapping
UKG Ready FieldCanonical FieldTarget Field
employeeIdidentity.externalIdexternalId
emailidentity.emailuserPrincipalName
employmentStatusidentity.lifecycleStatestatus
effectiveDateidentity.effectiveDatestartDate
Martini implementation pattern

Martini receives the UKG notification, validates its security and structure, deduplicates the event, and retrieves the complete Employee resource from UKG before applying identity lifecycle rules. It then creates, updates, or deactivates the target identity, records the cross-reference, retries transient failures, and runs periodic reconciliation to detect missed events.

Martini capabilities used
  • workflow triggers
  • webhook consumption
  • API consumption
  • data mapping
  • business rules
  • deduplication
  • retry and reconciliation

Applications commonly integrated with UKG Ready

UKG Ready commonly serves as a source of workforce, organizational, time, and employment data. The following adjacent applications represent practical enterprise architecture patterns; exact integration availability depends on the customer’s products, modules, tenant configuration, and the authoritative system for each data domain.

Application Scenario Direction Martini Pattern
Salesforce Synchronize employee, manager, territory, or user information for account ownership and internal operations. UKG Ready → Martini → Salesforce A scheduled Martini workflow retrieves changed Employees and organizational attributes, validates manager and department references, maps them to Salesforce users or workforce-related data, and performs idempotent updates with error routing.
ServiceNow Keep employee and organizational data aligned for onboarding, service requests, and identity-related workflows. UKG Ready → Martini → ServiceNow Martini retrieves Employees, Jobs, Departments, and Locations from UKG Ready, applies lifecycle and organizational rules, and submits normalized updates to ServiceNow while retaining UKG identifiers for reconciliation.
Microsoft Entra ID Provision, update, or deactivate workforce identities based on employee status and employment changes. UKG Ready → Martini → Microsoft Entra ID A scheduled or event-assisted workflow retrieves the authoritative Employee resource, evaluates employment status and effective dates, maps identity attributes, and calls Entra ID APIs with retry and deprovisioning controls.
Okta Drive workforce identity lifecycle and access changes from authoritative employee status data. UKG Ready → Martini → Okta Martini consumes UKG Ready employee changes, validates required identity fields, applies joiner-mover-leaver rules, and invokes Okta APIs with idempotency and periodic reconciliation.
NetSuite Transfer employee, department, location, time, or payroll-related data for finance and workforce processes. UKG Ready → Martini → NetSuite A workflow retrieves confirmed UKG Ready objects, maps organizational and time dimensions to NetSuite structures, validates accounting references, and upserts data using stable external identifiers.
ADP Coordinate employee, payroll, tax, or workforce information where an organization operates both UKG and ADP products. UKG Ready → Martini → ADP Martini orchestrates the agreed source-of-truth flow between UKG Ready and ADP, transforms employee or payroll-related payloads, applies effective-date rules, and routes rejected or conflicting records for review.
Workday Exchange employee or organizational reference data during coexistence, migration, or multi-system operating models. UKG Ready → Martini → Workday Martini coordinates scheduled extracts or API retrieval from each platform, maps identifiers and organizational codes into a canonical model, applies ownership rules, and records reconciliation results.
Jira Synchronize employee or team information for project access, ownership, or workforce-related automation. UKG Ready → Martini → Jira A workflow retrieves approved UKG Ready employee and organizational changes, maps them to Jira users or project ownership attributes, and handles API validation failures through controlled retries and exception routing.

How to build a UKG Ready integration in Martini

Objective

Confirm the UKG Ready tenant, API product, licensed modules, resources, permissions, and authentication process before implementation.

Instructions in Martini

  • Confirm the customer-specific UKG Ready API documentation and tenant settings
  • Configure the required OAuth or customer-provisioned credentials in Martini secrets
  • Separate development, test, and production environment values
  • Verify least-privilege access to the required UKG objects

Objective

Select scheduled synchronization as the default trigger unless UKG confirms supported notifications for the required events.

Instructions in Martini

  • Use a scheduler for incremental or periodic retrieval
  • Use a workflow trigger only for confirmed UKG outbound notifications
  • Define a reconciliation schedule even when event notifications are available
  • Set the synchronization window and checkpoint strategy

Objective

Call the documented UKG Ready resources and obtain complete, authoritative data for processing.

Instructions in Martini

  • Invoke the confirmed REST endpoints or process an approved UKG file export
  • Follow the documented pagination mechanism
  • Use modification filters or date windows where available
  • Persist checkpoints and retain an overlap window for late updates

Objective

Coordinate retrieval, validation, transformation, target calls, and exception handling in a maintainable Martini workflow.

Instructions in Martini

  • Separate authentication, retrieval, transformation, and target-writing stages
  • Route transient API failures separately from validation failures
  • Control concurrency and honor applicable throttling guidance
  • Use reusable workflow logic for common employee and reference-data processing

Objective

Convert UKG Ready payloads into canonical and target-specific models while protecting data quality.

Instructions in Martini

  • Map Employees, Jobs, Departments, Locations, Timecards, and Time-off requests explicitly
  • Validate required fields and organizational references
  • Normalize status values, dates, time zones, and effective dates
  • Preserve UKG identifiers and source timestamps

Objective

Apply lifecycle, approval, payroll-period, duplicate, and source-of-truth rules before writing downstream data.

Instructions in Martini

  • Process only approved or eligible Timecards and Time-off requests where required
  • Apply joiner-mover-leaver rules for identity targets
  • Handle corrections, cancellations, reopenings, and reapprovals explicitly
  • Use idempotent keys and cross-reference values to prevent duplicates

Common UKG Ready data objects used in integrations

ObjectTypical UseCommon target systemsMartini handling
EmployeesSynchronize worker identity, employment status, contact details, manager relationships, and employment attributes.Microsoft Entra ID, Okta, ServiceNow, Salesforce, Workday, NetSuiteMartini retrieves Employees through confirmed API resources or approved exports, validates required attributes and effective dates, maps the data to target models, and performs idempotent upserts using stable UKG identifiers.
JobsExchange job assignments, job codes, titles, and employment classifications.ServiceNow, Salesforce, NetSuite, WorkdayMartini maps UKG job codes and titles to target reference data, validates active assignments, and routes unmapped or conflicting codes to an exception flow.
DepartmentsMaintain organizational units used for workforce management, reporting, access, and accounting.ServiceNow, Microsoft Entra ID, NetSuite, SalesforceMartini synchronizes department identifiers and names, applies hierarchy and active-status rules where available, and preserves cross-system references.
LocationsRepresent work, organizational, or payroll locations used by employees and time processes.ServiceNow, NetSuite, Workday, SalesforceMartini normalizes location codes, time-zone attributes, and status values, then validates references before writing dependent employee or time data.
TimecardsExchange worked time, punches, hours, approval state, corrections, and time-entry dimensions.NetSuite, ADP, payroll applications, finance or billing platformsMartini retrieves approved or changed Timecards, distinguishes current, corrected, and reopened periods, applies employee, job, department, and location mappings, and prevents duplicate postings.
Time-off requestsSynchronize leave requests, balances where exposed, approval statuses, cancellations, and effective dates.ServiceNow, Workday, scheduling applications, payroll applicationsMartini preserves the UKG request identifier and approval state, applies effective-date and duplicate controls, and sends only eligible status changes downstream.

Authentication and security considerations

Tenant-specific authentication

UKG Ready authentication depends on the customer’s API product, tenant configuration, and provisioning process. OAuth 2.0 is available for at least some modern UKG offerings, while client credentials or other customer-provisioned credentials may apply to specific interfaces.

Secrets and permissions

Store UKG client credentials, tokens, tenant URLs, customer identifiers, and environment values as Martini secrets. Use least-privilege API permissions and confirm the required scopes and object access with UKG.

Sensitive workforce data

Employees, payroll records, Timecards, and Time-off requests can contain sensitive personal or financial information. Use TLS-protected endpoints, restrict workflow and log access, redact diagnostic data, and apply appropriate retention policies.

Operational considerations for UKG Ready integrations

Pagination and rate limits

Follow UKG’s documented pagination model and persist synchronization checkpoints. Confirm applicable rate limits, bound concurrency, use exponential backoff, and honor Retry-After guidance where supplied.

Idempotency and reconciliation

Use stable UKG identifiers, upserts, cross-reference values, and explicit duplicate controls. Reconcile periodically, including when event notifications are available, because events may be delayed, limited, or missed.

Schema and tenant variability

Objects, fields, status values, custom attributes, and operations may vary by module, country, subscription, and tenant. Validate optional fields and reference data, and test changes before production rollout.

Time and effective dating

Define canonical timestamp formats, payroll-period boundaries, tenant or location time zones, effective dates, daylight-saving behavior, and rules for overnight or date-crossing time entries.

Testing and monitoring

Test authentication, pagination, corrections, cancellations, rejected references, throttling, and partial failures with representative data. Monitor workflow executions, request outcomes, retries, checkpoints, and exception queues without exposing sensitive payloads.

Why use Martini instead of scripts or point-to-point integrations?

Orchestrated integration logic

Martini provides a structured workflow for authentication, API retrieval, pagination, validation, transformation, business rules, target writes, retries, and reconciliation rather than embedding this logic in isolated scripts.

Reusable and maintainable assets

Common UKG Ready processing such as employee mapping, reference-data validation, checkpointing, and error handling can be organized into reusable integration logic and controlled environment configuration.

API-led access

Martini can consume UKG Ready APIs and expose a controlled REST API façade for downstream applications. This reduces direct coupling to tenant-specific UKG models and centralizes security and transformation behavior.

Operational control

Workflows provide a consistent place to manage schedules, event triggers, retries, exception routing, monitoring, and deployment across multiple UKG Ready integrations.

Frequently asked questions

How can UKG Ready be integrated with enterprise systems?

UKG Ready can be integrated primarily through the REST APIs available for the customer’s tenant, licensed modules, permissions, and provisioned API product. Selected configurations may also provide outbound callbacks or event notifications, while approved CSV, Excel, or other file exchanges can support workflows where API coverage is insufficient. Scheduled incremental synchronization is the safer default when event coverage is limited.

Can Martini integrate with UKG Ready?

Yes. Martini can integrate with UKG Ready by consuming confirmed UKG Ready REST APIs, orchestrating scheduled workflows, processing approved file exports, and receiving supported outbound notifications when the customer’s configuration provides them. A native Martini UKG Ready connector was not documented in the supplied materials.

Do I need a connector to integrate UKG Ready with Martini?

No. A dedicated UKG Ready connector is not required. Martini can use UKG Ready’s confirmed native integration mechanisms, including provisioned REST APIs, applicable authentication methods, supported event notifications, and approved file exchanges.

Is there any extra Lonti cost to integrate UKG Ready with Martini?

Lonti does not charge an additional per-connector or per-vendor fee to integrate UKG Ready. The integration is subject to the provisioned capacity of the Martini environment. Separate costs may apply from UKG, cloud infrastructure, or other third-party systems depending on subscription, usage, and deployment model.

Which UKG Ready integration methods should be used?

REST APIs should be the primary approach when the required resource and operation are available for the customer’s tenant. Scheduled incremental synchronization is appropriate for broad workforce data flows. Supported callbacks or event notifications can supplement scheduling, while approved file exports can be used when API coverage is insufficient. GraphQL is not confirmed and a general current SOAP API was not verified.

Does UKG Ready provide webhooks for employee, payroll, or leave events?

Broad webhook coverage across UKG Ready objects should not be assumed. Selected UKG configurations may provide outbound callbacks or event notifications for particular events, but the supported event types must be confirmed for the customer’s tenant and API product. Scheduled reconciliation should remain in the design.

How should UKG Ready data synchronization handle changes and duplicates?

Use documented modification filters or date windows where available, persist checkpoints, and reconcile an overlap period for late updates. Stable UKG identifiers should be retained as external keys, with idempotent upserts and explicit handling for corrections, cancellations, reapprovals, and inactive reference data.

Can Martini expose an API façade for UKG Ready data?

Yes. Martini can expose a REST API that retrieves or returns normalized UKG Ready data through workflows. This can shield downstream consumers from tenant-specific UKG models, centralize authentication and business rules, and provide a controlled interface for employee, organizational, time, or leave information.

Related Martini documentation

APIs

Workflows

Data

Security

Operations

Connect UKG Ready with your enterprise systems

Use Martini to implement maintainable UKG Ready integrations around confirmed APIs, scheduled workflows, supported notifications, approved file exchanges, secure data handling, and downstream business rules.

EXPLORE MARTINI
BOOK A DEMO