Ellipse Gradient for Header

Oracle Primavera Cloud Integration Guide

Integrate Oracle Primavera Cloud with enterprise systems through its REST APIs, OAuth-based authentication, scheduled synchronization, and Martini workflows.

Oracle Primavera Cloud integration options at a glance

Oracle Primavera Cloud provides REST APIs as its primary confirmed programmatic integration mechanism. Martini can authenticate with OAuth access tokens, retrieve or update supported Workspaces, Projects, Activities, Issues, Risks, and Resources, and orchestrate scheduled synchronization workflows. Because a general-purpose webhook facility, current bulk API, file API, GraphQL API, and SOAP API were not confirmed, integrations should normally use paginated REST requests, incremental selection, stored checkpoints, and controlled retries. Martini can transform Primavera Cloud payloads into ERP, reporting, collaboration, or service-management models, and can expose a separate REST API for controlled access to normalized project data.

Integration pointSupported by Oracle Primavera Cloud?Common use casesHow Martini supports it
REST APIsYesRead workspace and project information, retrieve Activities, Issues, Risks, and Resources, and update supported Primavera Cloud resources. Resource availability and CRUD operations must be confirmed in the current tenant API reference.Martini can consume the REST API from workflows, validate responses, paginate through collections, transform payloads, apply business rules, and call downstream APIs.
AuthenticationYesOAuth-based access tokens are used for API requests, with access governed by application authorization and Primavera Cloud user permissions.Martini can store OAuth client configuration, tokens, tenant URLs, and related secrets in environment-specific secure configuration.
Scheduled synchronizationYesScheduled polling can identify changed project data when a general-purpose webhook or callback facility is unavailable or not confirmed.Martini can invoke workflows on a schedule, use timestamps or status filters, persist checkpoints, and process paginated results incrementally.
Webhooks or outbound callbacksNot confirmedA general-purpose webhook model covering all Primavera Cloud object changes was not verified. Selected event facilities may exist for particular tenants or Oracle features.Martini can receive webhook-style notifications when a specific Oracle capability is documented, but otherwise can implement polling-based synchronization.
Bulk, asynchronous, or batch APIsNot confirmedProduct import and export capabilities exist, but a generally available REST bulk or asynchronous API was not confirmed.Martini can process paginated REST responses in bounded batches and persist checkpoints while bulk API availability is verified.
File and attachment APIsNot confirmedPrimavera Cloud includes document-related product features, but a generally available file or attachment REST API was not confirmed.Martini can synchronize approved metadata or documented exports, but binary file transfer should not be designed until the relevant API is verified.
GraphQL APIsNot confirmedNo official Oracle Primavera Cloud GraphQL API was verified in the supplied research.Martini can consume GraphQL generally, but this integration should use the confirmed Primavera Cloud REST interface instead.
SOAP APIsNot confirmedNo current Primavera Cloud SOAP API was confirmed, and SOAP support should not be inferred from other Oracle or legacy Primavera products.Martini can consume SOAP services generally, but no SOAP-based Primavera Cloud design should be assumed.

How Oracle Primavera Cloud exposes data and business events

Oracle Primavera Cloud REST APIs

REST is the primary confirmed programmatic integration mechanism for Oracle Primavera Cloud. It can provide access to supported Workspaces, Projects, Activities, Issues, Risks, and Resources, with exact resources, fields, filters, and operations dependent on the current API reference and tenant permissions.

Martini implementation pattern

Martini implementation pattern: a workflow authenticates with an OAuth access token, calls the required REST resource, validates and paginates the response, maps the Primavera Cloud object into a canonical model, applies business rules, and writes the result to another API, database, or reporting endpoint.

Implementation sequence

Obtain an OAuth access token using the configured tenant credentials
Call the confirmed Primavera Cloud REST resource
Follow pagination and validate each response
Map the object into the canonical integration model
Apply ownership, validation, and deduplication rules
Write the transformed result to the target system

Scheduled synchronization

A general-purpose webhook facility for all Primavera Cloud object changes was not confirmed. Scheduled REST polling is therefore the conservative approach for incremental synchronization where timestamps, status filters, or other change-selection fields are available.

Martini implementation pattern

Martini implementation pattern: a scheduler starts the workflow, the workflow loads the last successful checkpoint, retrieves changed objects through paginated REST calls, processes each object idempotently, and stores the new checkpoint only after successful completion.

Implementation sequence

Start the workflow on an agreed schedule
Load the last successful synchronization checkpoint
Retrieve changed Primavera Cloud objects using supported filters
Process pages with bounded concurrency
Persist source and target identifiers after successful writes
Store the new checkpoint and route failures for replay

OAuth authentication

Oracle Primavera Cloud API requests use OAuth-based access tokens, while access is constrained by application authorization and the Primavera Cloud user's permissions.

Martini implementation pattern

Martini implementation pattern: credentials, tenant URLs, client configuration, and token settings are stored in secure environment configuration; the workflow obtains or refreshes access and sends the bearer token only to the required API calls.

Implementation sequence

Store environment-specific OAuth settings as Martini secrets
Request or refresh the access token
Send the bearer token with Primavera Cloud API requests
Validate authorization and permission failures separately
Rotate credentials without changing workflow mappings

Common Oracle Primavera Cloud integration patterns

Pattern 1: Sync projects and activities to an ERP

When to use this pattern

Use this pattern when approved project structures, schedule status, activity dates, or project identifiers must be aligned with financial and enterprise project systems. Confirm that the tenant exposes the required schedule and cost fields before implementation.

Integration direction
Oracle Primavera Cloud
Martini
Oracle Fusion Cloud ERP
Example Mapping
Oracle Primavera Cloud FieldCanonical FieldTarget Field
projectIdproject.sourceIdProjectNumber
projectNameproject.nameProjectName
activityStatusactivity.statusProjectTaskStatus
plannedFinishDateactivity.plannedFinishTaskPlannedFinishDate
Martini implementation pattern

A scheduled Martini workflow retrieves changed Projects and Activities through paginated REST calls, normalizes dates and status values, validates financial dimensions, and updates the ERP. Stable source identifiers and a cross-reference store make retries idempotent; validation failures are quarantined for review.

Martini capabilities used
  • scheduled workflows
  • API consumption
  • pagination and checkpointing
  • data mapping
  • business rules
  • error handling

Pattern 2: Enrich Primavera Cloud projects from an ERP

When to use this pattern

Use this pattern when an ERP owns approved project metadata, budgets, cost codes, or organizational information that must be reflected in Primavera Cloud. Define field ownership before enabling updates to avoid conflicting writes.

Integration direction
Oracle Fusion Cloud ERP
Martini
Oracle Primavera Cloud
Example Mapping
Oracle Primavera Cloud FieldCanonical FieldTarget Field
projectNumberproject.externalIdProjectExternalNumber
approvedBudgetproject.approvedBudgetApprovedBudget
costCenterproject.costCenterCostCode
organizationCodeproject.organizationWorkspaceOrganization
Martini implementation pattern

Martini retrieves eligible ERP projects, resolves the corresponding Primavera Cloud Workspace and Project identifiers, validates permitted fields, and submits updates only for attributes owned by the ERP. The workflow records response identifiers, distinguishes authorization errors from transient failures, and avoids update loops with source markers or comparison rules.

Martini capabilities used
  • workflow orchestration
  • REST API consumption
  • identifier resolution
  • data transformation
  • conditional routing
  • retry handling

Pattern 3: Route issues and risks to operational teams

When to use this pattern

Use this pattern when selected high-priority Issues or Risks need assignment, escalation, or follow-up in ServiceNow or Jira. Since universal Primavera Cloud webhooks were not confirmed, use scheduled polling unless a tenant-specific event mechanism is documented.

Integration direction
Oracle Primavera Cloud
Martini
ServiceNow
Example Mapping
Oracle Primavera Cloud FieldCanonical FieldTarget Field
issueIdworkItem.sourceIdCorrelationId
issueTitleworkItem.titleShortDescription
priorityworkItem.priorityPriority
assignedToworkItem.ownerAssignedTo
Martini implementation pattern

A scheduled workflow retrieves Issues and Risks, filters by project and severity, maps the selected objects to operational work items, and creates or updates them using a stored cross-system identifier. Business rules suppress low-priority items, while failed records are logged and made available for replay.

Martini capabilities used
  • scheduler triggers
  • filtering and business rules
  • data mapping
  • API orchestration
  • idempotency
  • operational error handling

Pattern 4: Build a project reporting dataset

When to use this pattern

Use this pattern when project progress, activity status, issue aging, risk exposure, or resource utilization must be consolidated for reporting. Use stable identifiers and plan for historical snapshots when trend analysis is required.

Integration direction
Oracle Primavera Cloud
Martini
PostgreSQL
Example Mapping
Oracle Primavera Cloud FieldCanonical FieldTarget Field
projectIdproject.sourceIdprimavera_project_id
activityStatusactivity.statusactivity_status
issueStatusissue.statusissue_status
riskScorerisk.scorerisk_score
Martini implementation pattern

Martini retrieves paginated REST results, normalizes each object into reporting tables, applies incremental-selection logic, and writes records to a reporting database. Checkpoints, stable keys, and upsert rules prevent duplication; rejected payloads and database failures are routed to operational logs.

Martini capabilities used
  • scheduled workflows
  • REST API consumption
  • JSON transformation
  • database writes
  • incremental synchronization
  • monitoring and error handling

Applications commonly integrated with Oracle Primavera Cloud

Oracle Primavera Cloud can be integrated with adjacent project, financial, construction, and operational platforms. The exact direction and field coverage should be confirmed against the available APIs, tenant permissions, and ownership model.

Application Scenario Direction Martini Pattern
Oracle Primavera P6 EPPM Exchange or consolidate schedule and project-planning information across Primavera environments when different business units use different planning platforms. Oracle Primavera Cloud → Martini → Oracle Primavera P6 EPPM Use scheduled REST workflows to retrieve selected project and activity data, normalize identifiers and schedule fields, apply system-of-record rules, and send approved updates through the target platform's supported interface.
Oracle Fusion Cloud ERP Align project structures, approved budgets, financial dimensions, procurement information, and cost data with project planning. Oracle Primavera Cloud → Martini → Oracle Fusion Cloud ERP Retrieve eligible Projects and Activities, map project identifiers and financial attributes, validate ownership and required fields, then create or update corresponding ERP project data with retry and duplicate controls.
Oracle Unifier Connect project controls, contracts, cost management, business processes, and project records across Oracle construction applications. Oracle Primavera Cloud → Martini → Oracle Unifier Orchestrate bidirectional workflows where supported, maintain cross-system project identifiers, route only approved changes, and isolate product-specific mappings from the canonical project model.
Oracle Aconex Associate planning information with document collaboration, correspondence, and project records while avoiding unsupported binary attachment assumptions. Oracle Primavera Cloud → Martini → Oracle Aconex Synchronize project and activity metadata through supported APIs, preserve stable identifiers and links, and defer document-content transfers until the required file interfaces are verified.
NetSuite Synchronize project, customer, financial, or resource information with project planning data. Oracle Primavera Cloud → Martini → NetSuite Use scheduled workflows to select changed Primavera Cloud objects, map them to NetSuite project and financial structures, apply field-ownership rules, and persist cross-reference identifiers.
SAP S/4HANA Connect project planning and schedule information with enterprise finance, procurement, and controlling processes. Oracle Primavera Cloud → Martini → SAP S/4HANA Read paginated Primavera Cloud resources, transform schedule and project attributes into SAP-compatible structures, validate organizational mappings, and handle rejected objects separately from retryable transport failures.
ServiceNow Create operational work items from selected project Issues and Risks for assignment, escalation, and service-management follow-up. Oracle Primavera Cloud → Martini → ServiceNow Poll selected Issues and Risks, apply priority and project filters, create or update ServiceNow items using a stored cross-reference, and return status changes only where ownership has been explicitly defined.
Jira Route engineering, delivery, or software-related project issues into team workflows and optionally synchronize status updates. Oracle Primavera Cloud → Martini → Jira Use scheduled REST polling, map issue identity and priority to Jira fields, prevent duplicate creation with stable source IDs, and apply explicit rules for any status updates returned to Primavera Cloud.

How to build a Oracle Primavera Cloud integration in Martini

Objective

Establish secure, environment-specific access to the Oracle Primavera Cloud tenant and the target systems.

Instructions in Martini

  • Store tenant URLs, OAuth client configuration, scopes, and secrets in Martini secure configuration
  • Confirm the integration user's workspace, project, and functional permissions
  • Validate connectivity with a low-risk REST request

Objective

Select a trigger that reflects the confirmed Primavera Cloud capabilities and required synchronization latency.

Instructions in Martini

  • Use a scheduler for normal incremental synchronization
  • Use a documented tenant-specific event or callback only if Oracle confirms it for the required objects
  • Define the initial-load and recurring-sync schedules separately

Objective

Read the required Primavera Cloud objects reliably without assuming that a single response contains the complete collection.

Instructions in Martini

  • Call the confirmed REST resources
  • Follow the API pagination model
  • Use supported filters, timestamps, or status fields for incremental selection
  • Persist page and synchronization checkpoints

Objective

Coordinate retrieval, transformation, target writes, and recovery in a maintainable Martini workflow.

Instructions in Martini

  • Separate API-specific retrieval logic from canonical mapping logic
  • Process large projects in bounded batches
  • Route validation, authorization, and transient failures through different branches

Objective

Transform Primavera Cloud objects into the target system's model while preserving stable identifiers and semantic meaning.

Instructions in Martini

  • Map Workspaces, Projects, Activities, Issues, Risks, and Resources explicitly
  • Normalize dates, durations, statuses, and time-zone semantics
  • Maintain source-to-target cross-reference data

Objective

Prevent conflicting updates, invalid writes, and duplicate target objects.

Instructions in Martini

  • Define field ownership for every bidirectional attribute
  • Validate required fields and permitted values
  • Use stable IDs rather than display names as integration keys
  • Suppress updates that would create loops

Common Oracle Primavera Cloud data objects used in integrations

ObjectTypical UseCommon target systemsMartini handling
WorkspacesOrganizational containers for projects, users, permissions, and related project information.Oracle Fusion Cloud ERP, Oracle Unifier, reporting databases, identity-aware project platformsMartini retrieves stable workspace identifiers, applies permission-aware filtering, and maps organizational context into a canonical project model.
ProjectsConstruction and engineering projects managed in Primavera Cloud.Oracle Fusion Cloud ERP, NetSuite, SAP S/4HANA, Oracle Unifier, data warehousesMartini synchronizes project identifiers and approved attributes, maintains cross-references, and applies field-ownership rules for bidirectional flows.
ActivitiesSchedule activities representing planned project work, dates, status, and related scheduling information.Oracle Primavera P6 EPPM, ERP platforms, reporting databases, analytics endpointsMartini retrieves Activities through paginated REST calls, normalizes dates and statuses, checkpoints progress, and prevents duplicate target updates.
IssuesProject issues requiring tracking, assignment, resolution, or escalation.ServiceNow, Jira, Microsoft Teams, reporting platformsMartini filters Issues by project, priority, or status, maps them to operational work items, and stores source-to-target identifiers.
RisksProject risks and associated risk-management information.ServiceNow, Jira, reporting databases, collaboration platformsMartini applies severity and ownership rules, routes selected Risks to target systems, and records rejected or retryable objects separately.
ResourcesResources assigned to or used by project work.ERP platforms, resource-planning systems, reporting databasesMartini maps stable resource identifiers and attributes, validates organizational relationships, and synchronizes only fields exposed and authorized by the tenant API.

Authentication and security considerations

OAuth-based access

Oracle Primavera Cloud API requests use OAuth-based access tokens. The integration application and Primavera Cloud user permissions determine which workspaces, projects, and functional areas are available.

Least-privilege configuration

Use an integration user with only the workspace, project, and functional permissions required by the workflows. Test with production-equivalent permissions before deployment.

Secure environment configuration

  • Store tenant URLs, OAuth client configuration, scopes, and secrets in Martini secure environment configuration.
  • Do not embed credentials or access tokens in workflow mappings or payloads.
  • Separate development, test, and production credentials and endpoints.

Operational considerations for Oracle Primavera Cloud integrations

Pagination and checkpoints

Project, activity, issue, risk, and resource collections may span multiple pages. Follow the API pagination model and persist progress so partial failures do not require unsafe full reloads.

Incremental synchronization

Use supported timestamps, status filters, or comparison logic to reduce unnecessary reads. Store source identifiers, target identifiers, synchronization times, and useful version or hash values.

Retries and idempotency

Use bounded backoff for transient failures, limit concurrency for large projects, and separate retryable errors from validation and permission failures. Avoid retrying non-idempotent creates without duplicate-prevention controls.

Data ownership and semantics

Define authoritative ownership for schedule dates, activity status, financial attributes, issue status, and risk information. Normalize time zones, calendars, durations, and status values before cross-system updates.

API and tenant changes

Confirm resource-level operations, rate limits, scopes, and field availability against the current Oracle API reference. Use tolerant parsing while explicitly validating required fields and monitor for API-version changes.

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

Centralized orchestration

Martini coordinates authentication, REST calls, pagination, transformations, business rules, target writes, and recovery in reusable workflows rather than scattering logic across scripts.

Controlled data movement

Mappings can preserve stable Primavera Cloud identifiers while translating Projects, Activities, Issues, Risks, and Resources into different enterprise data models. Field ownership and validation rules can be maintained separately from vendor-specific API calls.

Operational resilience

Martini supports scheduled execution, checkpointing, retry handling, logging, and controlled replay. This is important when webhooks are not confirmed and synchronization depends on polling.

Reusable APIs

Martini can expose a controlled REST API over normalized project data, allowing downstream applications to consume a stable interface without directly depending on every Primavera Cloud API detail.

Frequently asked questions

How can Oracle Primavera Cloud be integrated with enterprise systems?

Oracle Primavera Cloud can be integrated primarily through its REST APIs using OAuth-based authentication. Enterprise workflows can retrieve or update supported Workspaces, Projects, Activities, Issues, Risks, and Resources, then transform the data for ERP, reporting, construction, collaboration, or operational platforms. Where general-purpose webhooks are not confirmed, scheduled polling and incremental synchronization are the appropriate approach.

Can Martini integrate with Oracle Primavera Cloud?

Yes. Martini can integrate with Oracle Primavera Cloud by consuming its REST APIs, authenticating with OAuth access tokens, orchestrating scheduled workflows, mapping Primavera Cloud data, and exposing a separate Martini API when controlled access to normalized project data is required.

Do I need a connector to integrate Oracle Primavera Cloud with Martini?

No. A dedicated Oracle Primavera Cloud connector is not required. Martini can use the product's confirmed REST APIs and OAuth authentication, together with workflows, transformations, business rules, and secure environment configuration.

Is there any extra Lonti cost to integrate Oracle Primavera Cloud with Martini?

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

Which Oracle Primavera Cloud integration methods should be used?

REST APIs are the primary confirmed method for new integrations. OAuth-based authentication should be used for API access. GraphQL and current SOAP, general-purpose webhook, bulk, asynchronous, and file or attachment APIs were not confirmed in the supplied research and should not be assumed without tenant-specific verification.

Are Oracle Primavera Cloud webhooks or callbacks available?

A general-purpose webhook facility covering all Primavera Cloud object changes was not confirmed. If Oracle documents a specific event or callback facility for the tenant and required object, Martini can receive and process it; otherwise, scheduled REST polling with timestamps, filters, or stored synchronization state should be used.

How does Martini synchronize and transform Primavera Cloud data?

Martini can retrieve paginated REST responses, select changes using supported timestamps or status filters, map vendor objects into a canonical model, apply validation and ownership rules, and write to target APIs or databases. Stable Workspace, Project, Activity, Issue, Risk, and Resource identifiers should be preserved throughout the flow.

How are errors, retries, duplicates, and API changes handled?

Martini workflows can separate retryable transport or server failures from validation and authorization failures, use bounded exponential backoff, checkpoint progress, and replay failed objects. Idempotent create-or-update logic should use stable source identifiers and cross-reference data. Tolerant parsing and explicit required-field validation help manage schema changes.

Related Martini documentation

REST APIs

Workflows

Data Mapping

Security

Operations

Integrate Oracle Primavera Cloud with Martini

Use Martini to connect Oracle Primavera Cloud REST APIs with enterprise applications, orchestrate reliable synchronization workflows, and expose controlled APIs for project data.

EXPLORE MARTINI
BOOK A DEMO