.png)
PageUp Integration Guide
Connect PageUp recruitment and talent data with HR, job-board, onboarding, and enterprise workflow systems through APIs, callbacks, scheduled exchanges, and files.
PageUp integration options at a glance
PageUp integrations commonly use customer-specific REST APIs, scheduled exchanges, job-board feeds, file transfers, and implementation-specific HR integrations. Callback-style notifications may be available for selected recruitment events, but broad webhook coverage should be confirmed for each PageUp tenant and module. Bulk or batch exchange can support candidate, application, requisition, employee, and job-advertisement synchronization where PageUp provides the relevant interface. Authentication is tenant-specific and may use OAuth 2.0 or another customer-authorized method, so credentials and scopes must be confirmed with PageUp. Martini can consume approved PageUp endpoints, expose receiving APIs, schedule workflows, transform payloads, maintain synchronization state, and route failures for retry or review.
| Integration point | Supported by PageUp? | Common use cases | How Martini supports it |
|---|---|---|---|
| REST APIs | Limited | Retrieve or update supported Candidates, Applications, Job requisitions, Employees, and other recruitment or talent-management data. Endpoint coverage, API version, pagination, and rate limits are tenant-specific. | Martini can consume approved PageUp REST endpoints from workflows, transform responses, apply business rules, and write results to downstream systems or databases. |
| Webhooks / outbound callbacks | Limited | Selected recruitment or onboarding events may be delivered through callback-style interfaces, but broad coverage for candidate, application, requisition, and employee changes is not confirmed. | Martini can expose a REST API to receive an approved callback, validate and deduplicate the payload, route it through a workflow, and persist processing status. |
| Bulk / async / batch APIs | Limited | Batch-oriented exchange is relevant to HR synchronization, job feeds, and scheduled recruitment data transfers, although a public bulk API specification was not verified. | Martini can schedule extraction, process batches, maintain watermarks or checkpoints, and handle partial failures without reprocessing completed items. |
| File / attachment APIs | Limited | File exchange may support job feeds, candidate data, onboarding documents, and reports. Formats, transfer methods, and attachment endpoints require confirmation. | Martini can process supported files, map structured content, retrieve or forward approved attachments, and separate document failures from core record processing. |
| Scheduled synchronization | Yes | Scheduled polling or export processing can support candidate, application, requisition, employee, and job-advertisement synchronization when event delivery is unavailable or insufficient. | Martini scheduler-triggered workflows can retrieve bounded change windows, paginate through results, store durable watermarks, and perform idempotent writes. |
| Authentication | Limited | PageUp requires customer-authorized credentials, but the applicable authentication scheme, OAuth grant, token endpoint, and scopes depend on the interface and tenant. | Martini can keep confirmed credentials in secrets or environment configuration and apply the agreed authentication configuration to API workflows. |
| Database / analytics access | Not confirmed | Direct access to PageUp-managed production data was not verified and should not be assumed. | Martini can write synchronized PageUp data to an organization's own SQL database, but should use PageUp-supported APIs, exports, reports, or files for extraction. |
How PageUp exposes data and business events
PageUp REST APIs
PageUp supports enterprise data exchange through customer-specific API or integration arrangements. REST endpoint coverage, object availability, authentication, pagination, and rate limits must be confirmed for the relevant tenant and product module.
Martini implementation pattern
Martini implementation pattern: Martini invokes approved PageUp REST endpoints from a workflow, retrieves pages or bounded change sets, validates the response, maps PageUp objects to a canonical model, applies business rules, and writes to target applications or a synchronization database.
Implementation sequence
PageUp callbacks
PageUp may provide callback-style notifications for selected recruitment or onboarding events, but broad webhook coverage is not verified. Each event type and tenant configuration requires confirmation.
Martini implementation pattern
Martini implementation pattern: Martini exposes a receiving REST API, validates the callback, checks replay or duplicate conditions, retrieves additional PageUp data when required, and routes the event to downstream systems through a workflow.
Implementation sequence
PageUp batch and file exchanges
Batch-oriented integrations and file exchanges are relevant to HR synchronization, job feeds, reports, candidate data, and onboarding documents. Exact formats, protocols, and attachment behavior must be confirmed with PageUp.
Martini implementation pattern
Martini implementation pattern: Martini schedules a workflow to retrieve or receive the approved file or batch, parses the content, validates rows and references, transforms records, and checkpoints successful items so a failed batch can be corrected and replayed.
Implementation sequence
PageUp scheduled synchronization
Scheduled polling or export processing is appropriate when callback coverage is unavailable or limited. Candidate, application, requisition, employee, and job-advertisement changes should use documented incremental filters where available.
Martini implementation pattern
Martini implementation pattern: A scheduler starts a workflow that reads a durable watermark, requests a bounded change window, paginates through the result, applies idempotent writes, and advances the watermark only after successful processing.
Implementation sequence
Common PageUp integration patterns
Pattern 1: Sync PageUp applications to an HRIS
When to use this pattern
Use this pattern when approved candidates or hire-ready applications must be transferred to an HR system without manual re-entry. The flow should distinguish a Candidate from each Application and use application status or modification time to control eligibility.
Integration direction
Example Mapping
| PageUp Field | Canonical Field | Target Field |
|---|---|---|
| Candidate.id | person.externalId | Workday Worker Reference ID |
| Candidate.email | person.email | Workday Primary Email |
| Application.status | application.stage | Workday Hire Process Status |
| Job requisition.id | position.externalId | Workday Position Reference ID |
Martini implementation pattern
A scheduled Martini workflow retrieves changed Applications with their related Candidates and Job requisitions, filters for an approved hiring stage, validates mandatory identity and position references, maps the data to the HRIS model, and performs an idempotent create or update. Unknown requisitions, duplicate identities, and transient API failures are routed to controlled retry or exception handling.
Martini capabilities used
- scheduled workflows
- API consumption
- data mapping
- business rules
- idempotent processing
- error handling
Pattern 2: Synchronize HRIS employees to PageUp
When to use this pattern
Use this pattern when PageUp needs current employee, manager, organization, or employment information for onboarding, talent management, or internal mobility. The accepted PageUp fields and transport must be confirmed before implementation.
Integration direction
Example Mapping
| PageUp Field | Canonical Field | Target Field |
|---|---|---|
| Worker.workerId | employee.externalId | PageUp Employee ID |
| Worker.name | employee.fullName | PageUp Employee Name |
| Worker.managerId | employee.managerExternalId | PageUp Manager Reference |
| Worker.organization | employee.organizationCode | PageUp Organization |
Martini implementation pattern
Martini retrieves changed employees from the HRIS, validates required identity and organizational references, transforms values to the PageUp interface or approved file format, and submits only permitted fields. The workflow records the source and target identifiers, retries transient failures, and quarantines rejected employee updates for correction.
Martini capabilities used
- workflow orchestration
- API consumption
- data transformation
- validation
- secure configuration
- retry handling
Pattern 3: Publish PageUp job advertisements to job boards
When to use this pattern
Use this pattern when published vacancies must be distributed consistently to supported job boards. Publication status, closing dates, location formats, and job-board-specific schemas should be treated as explicit business rules.
Integration direction
Example Mapping
| PageUp Field | Canonical Field | Target Field |
|---|---|---|
| Job advertisement.title | job.title | Indeed Job Title |
| Job advertisement.description | job.description | Indeed Job Description |
| Job advertisement.location | job.location | Indeed Location |
| Job advertisement.closingDate | job.expiryDate | Indeed Expiration Date |
Martini implementation pattern
A Martini workflow retrieves eligible Job advertisements, filters out unpublished or expired items, transforms content and location fields for the target job board, and submits or produces the approved feed. It stores the PageUp advertisement identifier and publication result, prevents duplicate postings, and routes rejected advertisements for remediation.
Martini capabilities used
- scheduled workflows
- file or API processing
- mapping and transformation
- conditional routing
- duplicate prevention
- monitoring
Pattern 4: Route PageUp hiring events to onboarding workflows
When to use this pattern
Use this pattern when a PageUp callback, export, or scheduled change should create downstream onboarding or employee-service work. Because event coverage is selective, the trigger must be confirmed for the PageUp tenant.
Integration direction
Example Mapping
| PageUp Field | Canonical Field | Target Field |
|---|---|---|
| Application.id | hiringEvent.applicationId | ServiceNow Correlation ID |
| Candidate.name | person.fullName | ServiceNow Requested For |
| Job requisition.title | position.title | ServiceNow Onboarding Summary |
| Onboarding activities.status | onboarding.status | ServiceNow Task State |
Martini implementation pattern
Martini receives the confirmed callback or processes a scheduled export, validates the event and related objects, applies hire-stage and task-creation rules, and creates or updates ServiceNow onboarding work. Event keys and source identifiers provide replay protection, while failed lookups and downstream errors are placed into an exception path for retry.
Martini capabilities used
- REST API exposure
- workflow orchestration
- event validation
- data mapping
- business rules
- replay protection
- error handling
Applications commonly integrated with PageUp
PageUp can be integrated with named HR, payroll, job-board, and enterprise workflow products when the relevant PageUp interface and target-system capabilities are confirmed. Martini can coordinate these flows without assuming that every listed relationship is an officially packaged PageUp integration.
| Application | Scenario | Direction | Martini Pattern |
|---|---|---|---|
| Workday | Synchronize hiring, worker, organization, position, and onboarding information between PageUp and the HR system of record. | PageUp → Martini → Workday | Use scheduled PageUp API retrieval or approved file exchange, map Candidates, Applications, Job requisitions, and Employees into Workday structures, preserve cross-system identifiers, and route validation or duplicate conflicts for review. |
| SAP SuccessFactors | Align recruiting, employee, position, and onboarding information across PageUp and the enterprise talent platform. | PageUp → Martini → SAP SuccessFactors | Orchestrate incremental PageUp extraction and target updates through a Martini workflow, apply status and organizational mappings, and retry transient failures while isolating permanent validation errors. |
| UKG | Exchange employee, organizational, and hiring information between PageUp and workforce-management processes. | PageUp → Martini → UKG | Retrieve approved PageUp objects or process scheduled exports, normalize employee and hiring fields, apply deterministic matching, and write idempotent updates to UKG through its supported interface. |
| ADP | Transfer new-hire or employee information from recruitment processes into payroll and workforce operations. | PageUp → Martini → ADP | Trigger on a hire-ready application or scheduled change set, validate required payroll fields, transform the PageUp payload to ADP's accepted model, and retain processing status and downstream identifiers. |
| Distribute published job advertisements and support candidate-acquisition workflows where the applicable PageUp and LinkedIn interfaces are enabled. | PageUp → Martini → LinkedIn | Extract eligible Job advertisements, map titles, locations, descriptions, and closing dates to the approved LinkedIn interface, prevent duplicate publication, and record publication outcomes. | |
| Indeed | Distribute vacancies and support applicant-acquisition workflows through a job-board exchange where supported. | PageUp → Martini → Indeed | Process PageUp job feeds or API results, transform job-board-specific fields, apply publication and expiry rules, and handle rejected or malformed postings through an exception workflow. |
| SEEK | Publish vacancies and support candidate acquisition in markets where SEEK is used and the relevant interfaces are available. | PageUp → Martini → SEEK | Schedule extraction of published Job advertisements, normalize location and employment fields, submit supported feeds, and maintain a reconciliation record for updates and closures. |
| ServiceNow | Create employee-service, onboarding, or access-provisioning tasks from PageUp hiring and onboarding events. | PageUp → Martini → ServiceNow | Receive a PageUp callback or scheduled export, validate the new-hire payload, map it to ServiceNow task or request fields, and use idempotency keys to prevent duplicate onboarding work. |
How to build a PageUp integration in Martini
Objective
Confirm the PageUp tenant interface, supported objects, authentication method, permissions, endpoint or file details, and target-system credentials before building the workflow.
Instructions in Martini
- Confirm the PageUp API, callback, export, or file interface with the implementation team
- Store customer-authorized credentials in Martini secrets or environment configuration
- Avoid assuming OAuth flows, API keys, scopes, formats, or attachment endpoints
- Validate access to the required recruitment or talent-management objects
Objective
Select a trigger that matches the confirmed PageUp capability and the required freshness of the integration.
Instructions in Martini
- Use a PageUp callback only for confirmed event types
- Use a scheduler for polling, exports, or batch exchange
- Define the polling interval, bounded change window, and concurrency limits
- Record the event key, modification timestamp, or other synchronization reference
Objective
Obtain complete and current PageUp data while accounting for pagination, related objects, attachments, and tenant-specific response structures.
Instructions in Martini
- Retrieve the selected Candidates, Applications, Job requisitions, Employees, or Job advertisements
- Continue through every available page or batch segment
- Retrieve related objects when the initial payload contains references only
- Handle candidate attachments through the separately confirmed interface
Objective
Build the Martini workflow that coordinates validation, enrichment, transformation, target writes, and operational state.
Instructions in Martini
- Separate PageUp-specific retrieval logic from downstream mapping logic
- Apply conditional routing for status, module, locale, and target-system rules
- Store source identifiers, watermarks, downstream identifiers, and processing status
- Use reusable workflow logic where multiple PageUp flows share validation or mapping behavior
Objective
Convert PageUp object structures into a canonical model and then into the target application's fields without losing identity or business context.
Instructions in Martini
- Keep Candidate and Application identifiers separate
- Normalize statuses, dates, locations, organizations, and manager references
- Validate required fields and reject malformed records before target writes
- Protect personal, employment, résumé, and assessment information in logs and intermediate storage
Objective
Create or update downstream records, files, tasks, or database rows with deterministic matching and controlled side effects.
Instructions in Martini
- Use stable PageUp identifiers or deterministic business keys for upserts
- Apply hire-ready, publication, onboarding, and expiry rules
- Write successful results and downstream identifiers to synchronization state
- Handle partial batch success without replaying completed items
Common PageUp data objects used in integrations
| Object | Typical Use | Common target systems | Martini handling |
|---|---|---|---|
| Job requisitions | Represent requests to open and manage vacancies, including approval and recruitment-stage information. | Workday, SAP SuccessFactors, UKG, job boards | Martini retrieves or receives supported requisition data, normalizes status and organizational fields, preserves the PageUp identifier, and applies target-specific validation. |
| Job advertisements | Represent published versions of requisitions for career sites and external job boards. | LinkedIn, Indeed, SEEK, career sites | Martini filters by publication status, maps titles, descriptions, locations, and closing dates, prevents duplicate postings, and reconciles updates or closures. |
| Candidates | Represent people applying for or being considered for positions. | Workday, SAP SuccessFactors, background-checking systems, reporting databases | Martini separates candidate identity from application identity, protects personal data, maps contact fields, and applies duplicate detection and privacy-aware logging. |
| Applications | Represent candidate submissions associated with Job requisitions and recruitment stages. | Workday, SAP SuccessFactors, ADP, onboarding platforms | Martini uses application status and modification information for incremental processing, retains PageUp and downstream identifiers, and applies hire-ready or stage-based business rules. |
| Employees | Represent workers used in talent-management, onboarding, and internal-mobility processes. | Workday, SAP SuccessFactors, UKG, ADP, ServiceNow | Martini validates organizational and employment fields, maps manager and identity references, and writes idempotent updates to approved target interfaces. |
| Onboarding activities | Represent tasks and workflow information associated with new hires. | ServiceNow, HR systems, identity and access workflows | Martini can transform supported onboarding information into downstream tasks, track processing state, and route missing references or failed provisioning actions for replay. |
Authentication and security considerations
Tenant-specific authentication
PageUp authentication depends on the interface and customer tenant. OAuth 2.0 may be available for some integrations, but the grant type, token endpoint, scopes, and other credential details must be confirmed with PageUp.
Protect recruitment and employee data
- Store approved credentials in Martini secrets or environment configuration.
- Use encrypted transport and restrict workflow access to required users and services.
- Limit diagnostic logging for names, contact details, résumés, applications, assessments, and employment information.
- Confirm permissions for each required PageUp object and target operation.
Operational considerations for PageUp integrations
Throughput and completeness
- Confirm PageUp rate limits, concurrency restrictions, pagination behavior, and endpoint quotas.
- Use bounded incremental windows, durable watermarks, or documented change tokens where available.
- Continue through all pages and batch segments rather than relying on default page sizes.
Reliable processing
- Retry transient 429, 5xx, and network failures with backoff.
- Use stable identifiers and idempotency controls to prevent duplicate deliveries.
- Separate permanent validation, authorization, missing-reference, and state-conflict errors from retryable failures.
Schema and attachment changes
PageUp implementations can vary by tenant, module, locale, and configuration. Isolate PageUp-specific mappings, validate optional and custom fields, and confirm whether candidate documents use separate endpoints, expiring URLs, or file delivery.
Why use Martini instead of scripts or point-to-point integrations?
Coordinate complex integration behavior
Scripts often combine authentication, pagination, transformation, retries, and target writes in code that is difficult to govern across multiple PageUp flows. Martini provides workflows for orchestration, scheduling, API consumption, API exposure, mapping, validation, and controlled error paths.
Keep integrations maintainable
- Separate PageUp-specific mappings from downstream application mappings.
- Reuse synchronization, validation, and exception-handling logic across recruiting and talent workflows.
- Maintain watermarks, external identifiers, processing status, and replay controls.
- Use environment configuration and secrets rather than embedding customer credentials.
Support changing tenant configurations
PageUp fields, modules, statuses, and interfaces can vary by implementation. Martini allows these differences to be handled through explicit mappings and business rules while preserving an operational workflow for monitoring and troubleshooting.
Frequently asked questions
PageUp can be integrated through customer-specific REST APIs, scheduled polling, batch or export exchanges, job-board feeds, files, and selected callback-style interfaces. The available objects, authentication method, event coverage, pagination, and file formats depend on the PageUp tenant and product modules and should be confirmed before implementation.
Yes. Martini can integrate with PageUp by consuming confirmed PageUp REST endpoints, processing approved files or exports, receiving selected callbacks through a Martini REST API, and orchestrating scheduled synchronization workflows. Martini can map PageUp objects, apply business rules, and write to HR, payroll, job-board, onboarding, or database targets.
No. A dedicated PageUp connector is not required. Martini can use PageUp's confirmed native APIs, callbacks, file exchanges, scheduled exports, and tenant-specific authentication methods, subject to the interfaces enabled for the customer.
Lonti does not charge an additional per-connector or per-vendor fee to integrate PageUp. The integration is subject to the provisioned capacity of the Martini environment. Separate costs may apply from PageUp, infrastructure providers, job boards, HR systems, or other third-party services depending on subscriptions, usage, and deployment model.
Use a confirmed PageUp REST API when the required objects and operations are available. Use callbacks for confirmed event types, and scheduled APIs, exports, batch exchanges, or files when event coverage is limited. Direct PageUp database access should not be assumed, and SOAP or GraphQL should not be selected without explicit PageUp confirmation.
PageUp may provide callback-style notifications for selected recruitment or onboarding events, but broad webhook coverage is not verified. Confirm each required event, payload, security model, and retry behavior with PageUp. If callbacks are unavailable, Martini can use scheduled polling or exports.
Martini can maintain watermarks or bounded change windows, paginate through PageUp results, map objects through a canonical model, and preserve source and downstream identifiers. Idempotency keys or deterministic business keys help prevent duplicate Candidates, Applications, Employees, or onboarding tasks. Transient failures can be retried with backoff, while validation and authorization errors can be routed for correction.
Yes. Martini can expose a REST API that receives approved PageUp callbacks or presents a controlled interface to downstream applications. A workflow can authenticate or validate requests, transform PageUp-compatible payloads, apply business rules, and route data to internal systems without exposing every downstream endpoint directly.
Related Martini documentation
Workflows
Operations
Plan your PageUp integration
Use Martini to connect PageUp with HR, payroll, job-board, onboarding, and enterprise workflow systems through governed APIs, scheduled workflows, files, and approved callbacks.