Ellipse Gradient for Header

Celonis Integration Guide

Connect Celonis process intelligence data, ingestion jobs, analyses, and selected action-driven events with enterprise applications through REST APIs and orchestrated Martini workflows.

Celonis integration options at a glance

Celonis primarily integrates through REST APIs covering platform resources, data ingestion, data models, analyses, action flows, and data jobs. It also supports batch and asynchronous loading through data-push, ingestion, refresh, and job-oriented mechanisms. File-based ingestion is available for relevant data-loading scenarios, while webhook-style callbacks and event triggers are available only for selected Action Flow and integration use cases. Celonis access generally uses OAuth 2.0 client credentials with tenant-specific endpoints and permissions. Martini can consume these APIs, transform operational data into Celonis table or event-log structures, expose authenticated callback endpoints, monitor asynchronous jobs, and coordinate retries and reconciliation.

Integration pointSupported by Celonis?Common use casesHow Martini supports it
REST APIsYesAccess Celonis platform, data, analysis, execution-management, and resource APIs; retrieve or update supported resources and invoke platform functions.Martini can consume Celonis REST endpoints, manage OAuth headers, map JSON payloads, apply rules, and expose downstream APIs.
Bulk / async / batch APIsYesLoad source tables or event data, submit data-push operations, start or monitor data jobs, and refresh data models.Martini can create deterministic batches, call ingestion endpoints, poll job status with backoff, and persist reconciliation details.
Webhooks / outbound callbacksLimitedSelected Action Flow triggers and integration scenarios can call an external endpoint when a configured business condition occurs.Martini can expose an authenticated REST endpoint, validate the callback, retrieve additional data, and process duplicate or failed deliveries.
File / attachment APIsLimitedFile-oriented ingestion can load source data in relevant Celonis data-loading scenarios; a general-purpose document attachment API was not confirmed.Martini can produce CSV, JSON, or other required files and invoke the documented upload or ingestion process after format validation.
AuthenticationYesCelonis API access generally uses OAuth 2.0 client credentials, bearer tokens, tenant-specific endpoints, and resource permissions.Martini can store client credentials as environment secrets, obtain tokens, attach authorization headers, and separate configuration by tenant.
Database / analytics accessLimitedCelonis exposes analytics and process-data access through documented APIs and analytical features, but direct access to managed internal storage was not confirmed.Martini can connect independently to customer databases such as Snowflake, SAP HANA, or SQL Server and send prepared data to Celonis.
GraphQL APIsNot confirmedA broadly applicable public Celonis GraphQL integration API was not confirmed for the reviewed platform use cases.Martini should use the documented Celonis REST and ingestion mechanisms rather than assume GraphQL support.
SOAP APIsNoA current public Celonis SOAP integration API was not confirmed.Martini should not design a new Celonis integration around SOAP; use REST or documented ingestion endpoints instead.

How Celonis exposes data and business events

Celonis REST APIs

Celonis publishes REST APIs for platform, data, analysis, and execution-management resources. The applicable API family, endpoint, permissions, pagination, and payload schema depend on the target resource.

Martini implementation pattern

Martini implementation pattern: Martini obtains an OAuth 2.0 access token, calls the selected Celonis REST endpoint, validates the response, maps JSON into a canonical model, and either writes to another system or exposes a controlled API.

Implementation sequence

Acquire an OAuth 2.0 access token
Call the documented Celonis REST endpoint
Follow pagination or continuation instructions
Validate and transform the JSON response
Apply business rules and write the target result
Record the request outcome and correlation identifier

Celonis batch ingestion and data jobs

Celonis supports data push, ingestion, batch loading, refresh operations, and asynchronous data jobs for loading source tables or process-event data. Payload limits and refresh semantics vary by ingestion path.

Martini implementation pattern

Martini implementation pattern: A scheduled workflow extracts incremental source data, maps it to Celonis tables or event-log structures, submits deterministic batches, monitors the data job, and updates the watermark only after successful completion.

Implementation sequence

Start the scheduled synchronization
Extract changed source data
Validate case identifiers, activities, timestamps, and keys
Create deterministic Celonis batches
Submit the ingestion or data-job request
Monitor the asynchronous job status and reconcile the result

Selected Action Flow callbacks

Celonis supports event-driven automation in selected Action Flow triggers, callbacks, and integration scenarios. Coverage is not universal across objects or state changes, so the required trigger must be verified for each design.

Martini implementation pattern

Martini implementation pattern: Martini exposes an authenticated REST API for the callback, validates the incoming event or identifier, retrieves any missing Celonis or source data, applies business rules, and invokes the operational target.

Implementation sequence

Receive the Celonis callback
Authenticate and validate the callback
Check the event and duplicate-delivery key
Retrieve the complete business context
Apply routing and authorization rules
Update the target system and return a controlled response

Celonis file-based ingestion

Relevant Celonis data-loading scenarios can accept file-oriented source data. This is intended for table or source-data ingestion rather than a general-purpose document attachment service.

Martini implementation pattern

Martini implementation pattern: Martini extracts and transforms source data, generates the required CSV, JSON, or other documented format, stages or uploads it through the selected ingestion process, and monitors the resulting job.

Implementation sequence

Extract the source dataset
Transform rows into the documented file structure
Validate delimiter, encoding, keys, and timestamps
Stage or upload the file
Start or associate the Celonis ingestion job
Capture row counts, job status, and failures

Common Celonis integration patterns

Pattern 1: Load operational process data into Celonis

When to use this pattern

Use this pattern when Celonis needs recurring process and event data from SAP, Salesforce, ServiceNow, or another operational source. It supports incremental extraction, event-log modeling, controlled batches, and asynchronous load monitoring.

Integration direction
Operational system
Martini
Celonis
Example Mapping
Celonis FieldCanonical FieldTarget Field
Source business keycaseIdCase identifier
Source status or transaction typeactivityNameActivity
Modified or event timestampeventTimestampEvent timestamp
Source user or organizationresourceResource
Martini implementation pattern

A scheduler starts the workflow, which reads changed source data using a durable watermark. Martini validates required identifiers and timestamps, maps and enriches events, submits deterministic Celonis batches, monitors the data job, and retries transient failures without advancing the watermark prematurely.

Martini capabilities used
  • workflows
  • scheduled execution
  • API consumption
  • data mapping
  • business rules
  • error handling

Pattern 2: Process Celonis-driven exceptions

When to use this pattern

Use this pattern when a selected Celonis Action Flow or callback identifies an exception requiring action in SAP, Salesforce, ServiceNow, or another operational system. It is appropriate only after confirming the specific Celonis trigger and callback behavior.

Integration direction
Celonis
Martini
ServiceNow
Example Mapping
Celonis FieldCanonical FieldTarget Field
Action Flow identifiereventIdIntegration event ID
Celonis case identifiercaseIdIncident or transaction reference
Exception categoryreasonCodeResolution category
Recommended actionactionTypeUpdate or task type
Martini implementation pattern

Martini exposes an authenticated API, validates the callback and duplicate key, retrieves complete context when the notification contains only an identifier, applies authorization and routing rules, updates the target system, and returns a controlled response with an audit result.

Martini capabilities used
  • API exposure
  • authentication
  • workflows
  • data mapping
  • business rules
  • error handling

Pattern 3: Reconcile Celonis with operational systems

When to use this pattern

Use this pattern when process status, identifiers, or outcomes must be compared between Celonis and an operational system. It produces an exception list rather than blindly overwriting either system.

Integration direction
Celonis
Martini
SAP S/4HANA
Example Mapping
Celonis FieldCanonical FieldTarget Field
Celonis case identifierprocessKeySAP document number
Celonis process statusprocessStatusDocument status
Last successful activitylastActivityMilestone
Analysis timestampobservedAtReconciliation timestamp
Martini implementation pattern

A scheduled workflow retrieves selected Celonis analysis or process data and the corresponding operational records, normalizes keys and statuses, compares them using explicit tolerance rules, sends actionable exceptions to the target, and stores reconciliation results for replay.

Martini capabilities used
  • scheduled workflows
  • API consumption
  • data transformation
  • conditional routing
  • durable state
  • monitoring

Pattern 4: Expose a controlled Celonis data API

When to use this pattern

Use this pattern when multiple internal applications need selected Celonis analysis or process data without receiving Celonis credentials or depending directly on tenant-specific API contracts.

Integration direction
Internal application
Martini
Celonis
Example Mapping
Celonis FieldCanonical FieldTarget Field
Requested process identifierprocessIdCelonis analysis filter
Requested date rangefromDate/toDateCelonis query parameters
Celonis analysis resultprocessMetricsStable internal response
Celonis resource permissionsauthorizationContextAPI access decision
Martini implementation pattern

Martini exposes a stable REST API, authenticates consumers, validates and authorizes requests, calls the appropriate Celonis REST resource, normalizes the response, optionally combines it with other systems, and applies timeout and retry policies.

Martini capabilities used
  • API exposure
  • API consumption
  • authentication and authorization
  • data mapping
  • business rules
  • error handling

Applications commonly integrated with Celonis

Celonis can be connected with operational applications and data platforms that provide process, transaction, event, or master data. The exact objects and ingestion method depend on the Celonis tenant, selected API family, and source-system configuration.

Application Scenario Direction Martini Pattern
SAP S/4HANA Load purchase-to-pay, order-to-cash, and finance process data into Celonis, then return selected process exceptions or actions to SAP. SAP S/4HANA → Martini → Celonis A scheduled Martini workflow extracts incremental SAP data, maps it to Celonis case, activity, timestamp, and business attributes, submits deterministic batches, and monitors the resulting data job.
Salesforce Provide lead-to-cash, opportunity, case, and customer-service data for process analysis and route selected Celonis findings back to Salesforce. Salesforce → Martini → Celonis Martini consumes Salesforce API data, validates identifiers and timestamps, transforms it into Celonis ingestion structures, and exposes an API for controlled action updates.
ServiceNow Analyze incident, request, change, and service-management processes and initiate selected follow-up actions. ServiceNow → Martini → Celonis A scheduled workflow extracts ServiceNow objects, builds Celonis event-log rows, submits batches, and processes selected Celonis callbacks into authenticated ServiceNow updates.
Microsoft Dynamics 365 Analyze sales, customer-service, and finance processes and synchronize selected process metrics or exceptions. Microsoft Dynamics 365 → Martini → Celonis Martini retrieves changed Dynamics data, applies canonical mappings and business validation, loads Celonis in batches, and records job identifiers for reconciliation.
Oracle NetSuite Provide order, fulfillment, procurement, and financial data for process analysis and exception management. Oracle NetSuite → Martini → Celonis Martini extracts NetSuite data through its available APIs, normalizes transaction keys and timestamps, submits Celonis ingestion payloads, and retries transient failures without duplicating batches.
Snowflake Use Snowflake as a source or staging layer for curated process and event data before loading it into Celonis. Snowflake → Martini → Celonis Martini queries incremental Snowflake datasets, converts rows into the required Celonis table or file format, uploads controlled batches, and stores source watermarks.
Google BigQuery Prepare event and transaction datasets for Celonis process analysis or export selected process results for broader analytics. Google BigQuery → Martini → Celonis A scheduled workflow reads partitioned or changed BigQuery data, validates case and event fields, loads Celonis, and records batch and refresh outcomes.
Jira Analyze software delivery, issue-resolution, or change-related processes and synchronize selected exceptions or status updates. Jira → Martini → Celonis Martini consumes Jira issue and transition data, maps issue histories to Celonis activities, applies filtering rules, and sends only validated incremental events.

How to build a Celonis integration in Martini

Objective

Configure the Celonis tenant endpoint and OAuth 2.0 client credentials without embedding secrets in workflows.

Instructions in Martini

  • Store tenant-specific base URLs, client IDs, and secrets in Martini environment configuration.
  • Configure bearer-token acquisition and resource permissions for the selected Celonis API family.
  • Separate development, test, and production credentials.

Objective

Select a scheduled, API-led, or selected Celonis callback trigger based on the synchronization requirement.

Instructions in Martini

  • Use a scheduler for incremental data loads and reconciliation.
  • Use an exposed Martini REST API for supported Celonis callbacks.
  • Confirm that the required Action Flow event is available before committing to an event-driven design.

Objective

Obtain Celonis or source-system data while handling pagination, continuation, and asynchronous job behavior.

Instructions in Martini

  • Retrieve pages until the documented continuation condition is complete.
  • Receive callbacks with authentication and duplicate-delivery checks.
  • Capture Celonis data-job identifiers for later status monitoring.

Objective

Coordinate extraction, validation, transformation, Celonis calls, target updates, and durable state in a maintainable workflow.

Instructions in Martini

  • Separate transport, mapping, business rules, and reconciliation logic.
  • Use bounded concurrency for large loads and polling operations.
  • Persist watermarks, batch identifiers, and correlation identifiers.

Objective

Transform source records into Celonis table or event-log structures and validate the fields required for process analysis.

Instructions in Martini

  • Map case identifiers, activity names, timestamps, resources, and business attributes.
  • Normalize time zones and timestamp formats.
  • Reject or quarantine rows with missing keys, invalid types, or inconsistent event ordering.

Objective

Determine which records, events, exceptions, or callbacks should be sent to a target system or Celonis.

Instructions in Martini

  • Apply tenant, process, status, and authorization rules before writing data.
  • Use stable business keys and documented merge or replacement behavior where available.
  • Keep source and Celonis outcomes distinguishable during reconciliation.

Common Celonis data objects used in integrations

ObjectTypical UseCommon target systemsMartini handling
Data poolsOrganize ingested source data and related loading resources.SAP S/4HANA, Salesforce, Snowflake, data warehousesMartini routes tenant-specific ingestion workflows to the correct data pool and records permissions and load outcomes.
Data jobsLoad, transform, refresh, or monitor source data processing.Martini workflows, operational source systems, monitoring platformsMartini starts or monitors jobs, captures job identifiers, polls with bounded backoff, and reconciles final status.
Data modelsStructure source data for process analysis and execution management.Celonis analyses, process applications, operational data sourcesMartini maps source tables and event-log fields to the documented model schema and validates keys, timestamps, and types.
AnalysesProvide process analysis applications and analytical views built on Celonis data models.Internal portals, reporting applications, operational workflowsMartini retrieves supported analysis data through the applicable API, normalizes the response, and exposes controlled downstream APIs.
Action flowsExecute actions, invoke integrations, or respond to configured business conditions.Salesforce, ServiceNow, SAP S/4HANA, Martini APIsMartini receives selected callbacks, authenticates and validates them, enriches the event, applies rules, and writes the outcome.
PackagesContain reusable Celonis process intelligence or execution-management assets.Celonis environments and deployment processesMartini can orchestrate documented package-related API operations where enabled, while preserving tenant-specific permissions and version information.

Authentication and security considerations

OAuth 2.0 and tenant configuration

Celonis API access generally uses OAuth 2.0 client credentials with client IDs, client secrets, bearer tokens, tenant-specific endpoints, and resource permissions. Configure these values per environment and API family.

Secret handling

Store Celonis credentials and tokens in Martini environment configuration or secrets management. Do not hardcode client secrets or expose bearer tokens in workflow logs.

Authorization and callbacks

  • Confirm application, organization, and resource permissions for data pools, data models, analyses, data jobs, and Action Flows.
  • Authenticate Martini endpoints used for Celonis callbacks and validate signatures, tokens, timestamps, or shared credentials where the selected Celonis mechanism supports them.
  • Protect callback endpoints against replay and duplicate delivery.

Operational considerations for Celonis integrations

Loading and API limits

Respect Celonis and source-system rate limits, pagination rules, payload limits, row counts, compression requirements, and batch semantics. Use bounded concurrency and exponential or documented backoff for transient failures.

Incremental processing

Use timestamps, sequence numbers, source watermarks, or documented incremental-load mechanisms instead of repeatedly sending complete datasets. Persist batch identifiers and advance watermarks only after successful ingestion or job completion.

Process-data quality

  • Validate case identifiers, activity names, timestamps, resources, data types, and required business keys before loading.
  • Normalize time zones and distinguish event time from ingestion time.
  • Use idempotent keys and documented merge or replacement behavior to prevent duplicates after retries.
  • Monitor asynchronous data jobs and distinguish transport success from data-model or validation success.
  • Version mappings and test source-schema changes before production deployment.

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

Orchestration beyond a script

Martini provides a durable workflow layer for authentication, extraction, transformation, validation, Celonis ingestion, job monitoring, and downstream actions. This keeps integration behavior explicit and maintainable as process models and source systems change.

Reusable contracts

Martini can expose controlled APIs over selected Celonis resources, normalize tenant-specific responses, and reuse mapping, authorization, retry, and reconciliation logic across applications.

Operational control

  • Centralize environment configuration and secrets rather than distributing Celonis credentials.
  • Apply consistent business rules, idempotency, error handling, and monitoring.
  • Support scheduled, batch, API-led, and selected callback-driven integration patterns in one platform.

Frequently asked questions

How can Celonis be integrated with enterprise systems?

Celonis can be integrated primarily through its REST APIs, data ingestion and data-push mechanisms, asynchronous data jobs, and file-oriented loading scenarios. Selected Action Flow triggers and callback mechanisms can support event-driven integrations. OAuth 2.0, tenant-specific endpoints, permissions, batching, and job monitoring should be designed for the specific Celonis API family.

Can Martini integrate with Celonis?

Yes. Martini can consume documented Celonis REST APIs, send transformed data to Celonis ingestion or data-push endpoints, monitor data jobs, and expose authenticated REST endpoints for selected Celonis callbacks. A specific API family and tenant configuration must be validated before implementation.

Do I need a connector to integrate Celonis with Martini?

No. A dedicated Celonis connector is not required. Martini can integrate using Celonis REST APIs, OAuth 2.0 authentication, ingestion and data-job endpoints, file-based loading where applicable, and selected callback mechanisms.

Is there any extra Lonti cost to integrate Celonis with Martini?

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

Which Celonis integration methods should be used for a new implementation?

Use the documented Celonis REST API or the specific ingestion, data-push, and data-job API for the target resource. Use batch and asynchronous mechanisms for large process datasets, and use callbacks only when the required Action Flow trigger and delivery behavior are confirmed.

Are Celonis webhooks or callbacks available?

Selected Celonis Action Flow and integration scenarios support event-driven triggers or outbound callbacks, but universal webhook coverage should not be assumed. Confirm the event, payload completeness, authentication method, retry behavior, and duplicate-delivery semantics for the specific feature.

How does synchronization with Celonis work?

Martini can run scheduled incremental loads using timestamps, sequence numbers, or source watermarks, transform data into Celonis table or event-log structures, submit deterministic batches, and monitor asynchronous data jobs. A watermark should advance only after the associated load completes successfully.

How does Martini handle Celonis mapping, failures, and retries?

Martini maps Celonis JSON, table, file, and event-log payloads through workflow transformations and validation rules. Workflows can distinguish authentication, permission, rate-limit, validation, network, and asynchronous job failures, then apply bounded retries and reconciliation using stable keys and job identifiers. Martini can also expose a controlled API façade over selected Celonis data without exposing Celonis credentials to every consumer.

Related Martini documentation

APIs

Workflows

Data

Security

Reliability

Connect Celonis with Martini

Use Martini to build secure, maintainable Celonis integrations for data ingestion, process intelligence, action flows, and enterprise system orchestration.

EXPLORE MARTINI
BOOK A DEMO