Ellipse Gradient for Header

Xactly Integration Guide

Integrate Xactly Incent with enterprise systems through tenant-specific REST APIs, batch exchanges, files, and controlled compensation workflows.

Xactly integration options at a glance

Xactly Incent integrations primarily use tenant-specific REST APIs for participant, transaction, credit, quota, earnings, and payment data. High-volume compensation processing may use batch or asynchronous interfaces, while selected processes may support structured file imports or exports. Legacy or product-specific SOAP interfaces may exist, but their availability must be confirmed for the customer environment. Authentication can involve OAuth 2.0 or provisioned service credentials, with access controlled by tenant, role, and product permissions. Martini can orchestrate scheduled workflows, consume Xactly APIs, process supported files, map and validate compensation data, and expose controlled APIs for downstream applications.

Integration pointSupported by Xactly?Common use casesHow Martini supports it
REST APIsYesXactly provides developer/API resources for participant, transaction, credit, quota, earnings, payment, and related compensation data, subject to product and tenant entitlements.Martini can consume authenticated Xactly REST APIs, transform payloads, apply business rules, and expose controlled APIs for downstream consumers.
Bulk, asynchronous, and batch APIsLimitedHigh-volume Transactions and participant datasets may use batch, import, asynchronous, or job-based processing. The applicable submission and status model must be confirmed.Martini can submit batches, track job or submission identifiers, poll processing status, reconcile individual outcomes, and retry transient failures.
File import/exportLimitedStructured file exchange may support selected compensation and transaction processes. Formats, delivery methods, validation behavior, and status reporting are product-specific.Martini can receive, validate, transform, and produce supported files, then invoke Xactly or downstream APIs and retain processing results.
SOAP APIsLimitedLegacy or product-specific SOAP interfaces may exist in some Xactly environments, but universal current availability was not confirmed.Where the customer’s Xactly interface catalog confirms SOAP, Martini can consume the service, map XML messages, and handle SOAP-specific errors.
Webhooks and outbound callbacksNot confirmedNo universal Xactly webhook or callback catalog was verified. Event coverage must be confirmed for the specific product and tenant.If supported for a required event, Martini can receive the notification and retrieve the authoritative Xactly resource; otherwise scheduled polling or batch exchange is appropriate.
AuthenticationLimitedXactly integrations may use OAuth 2.0, client credentials, service accounts, or other environment-specific credentials, with access constrained by tenant and role permissions.Martini can store credentials and OAuth configuration as environment-managed secrets and use authenticated API workflows with least-privilege access.
Database accessNot confirmedDirect access to Xactly-managed production databases was not verified. Supported APIs, reports, exports, or files should be used instead.Martini can write integration state to approved external databases when required, but should not rely on direct Xactly database connectivity.

How Xactly exposes data and business events

Xactly REST APIs

Xactly provides developer/API resources for REST-based access to Incent and related product data. Available resources, operations, object names, and permissions depend on the customer’s product edition, tenant, licensing, and API entitlement.

Martini implementation pattern

Martini implementation pattern: Martini authenticates with the customer-approved Xactly method, invokes the required REST resources, handles pagination and response validation, maps Xactly objects into canonical models, and sends results to target applications or exposes them through a controlled Martini API.

Implementation sequence

Authenticate using the tenant-approved Xactly credentials
Retrieve or submit the required Xactly resource
Follow pagination or continuation information
Validate the response and apply business rules
Map the Xactly object to the target model
Write the result and store identifiers or a synchronization watermark

Xactly batch and asynchronous processing

High-volume participant and Transaction processing may use batch, asynchronous, import, or job-oriented interfaces. The applicable payload limits, job model, and status endpoints must be confirmed in the customer’s Xactly API specification.

Martini implementation pattern

Martini implementation pattern: Martini builds validated batches, submits them through the supported Xactly interface, stores submission or job identifiers, polls or retrieves processing results, and separates transient failures from permanent record-level validation errors.

Implementation sequence

Collect eligible records for the processing window
Validate required fields and stable source identifiers
Build a batch within the confirmed payload limits
Submit the batch to Xactly
Store the submission or job identifier
Retrieve processing results and reconcile each record

Xactly file exchange

Selected Xactly processes may support structured file imports or exports for compensation and transaction data. Supported formats, delivery mechanisms, file size limits, and processing status are product-specific and require tenant confirmation.

Martini implementation pattern

Martini implementation pattern: Martini receives or generates the supported file, validates structure and business fields, transforms the content into the required Xactly format, submits or retrieves it through the approved exchange, and preserves file and processing metadata for audit.

Implementation sequence

Receive or generate the approved compensation data file
Validate the file structure and required fields
Transform records to the confirmed Xactly format
Submit or retrieve the file through the supported mechanism
Track file processing status and errors
Store the file reference and reconciliation outcome

Xactly SOAP interfaces

Legacy or product-specific SOAP interfaces may be available in some Xactly environments, but SOAP is not confirmed as a universal current interface. The customer’s interface catalog should be authoritative.

Martini implementation pattern

Martini implementation pattern: Where Xactly confirms a SOAP service, Martini consumes the WSDL-defined operation, maps XML request and response structures, applies service-specific authentication and fault handling, and routes normalized results into the same workflow models used for REST integrations.

Implementation sequence

Confirm the Xactly SOAP service and WSDL
Configure the approved authentication and endpoint
Build the XML request from the canonical model
Invoke the SOAP operation
Handle SOAP faults and transport failures
Map the response into the downstream model

Common Xactly integration patterns

Pattern 1: Import Salesforce transactions into Xactly

When to use this pattern

Use this pattern when Salesforce is the source of closed sales or booking data used for incentive compensation. It supports scheduled incremental processing, validation before submission, and reconciliation after Xactly accepts or rejects the data.

Integration direction
Salesforce
Martini
Xactly
Example Mapping
Xactly FieldCanonical FieldTarget Field
Opportunity.IdsourceTransactionIdTransaction external identifier
Opportunity.AmounttransactionAmountTransaction amount
Opportunity.CloseDatetransactionDateTransaction date
Owner.IdparticipantSourceIdParticipant identifier
Martini implementation pattern

A scheduled Martini workflow retrieves changed Salesforce Opportunities and related sales data, filters eligible records, validates participant and amount fields, maps the records to the confirmed Xactly Transaction schema, and submits them through the supported REST or batch interface. It stores source identifiers and submission outcomes, retries transient failures, and routes permanent validation errors for review.

Martini capabilities used
  • workflows
  • scheduled triggers
  • API consumption
  • data mapping
  • business rules
  • batch orchestration
  • error handling

Pattern 2: Synchronize workforce data to Xactly Participants

When to use this pattern

Use this pattern when Workday, SAP SuccessFactors, or Oracle HCM Cloud is the authoritative source for workers and organizational assignments used in Xactly compensation processing.

Integration direction
Workday
Martini
Xactly
Example Mapping
Xactly FieldCanonical FieldTarget Field
Worker.workerIdemployeeIdParticipant external identifier
Worker.managerIdmanagerSourceIdParticipant manager
Worker.effectiveDateeffectiveFromParticipant effective date
Worker.statusemploymentStatusParticipant active status
Martini implementation pattern

Martini retrieves changed workers using effective-date or modified-time criteria, validates manager and organizational relationships, applies termination and deactivation rules, and performs idempotent creates or updates for Xactly Participants and related structures. Rejected records are retained with correlation details for reconciliation.

Martini capabilities used
  • scheduled workflows
  • API consumption
  • data mapping
  • effective-date rules
  • validation
  • idempotency
  • exception handling

Pattern 3: Distribute approved Xactly payments

When to use this pattern

Use this pattern when payroll or finance systems require approved Xactly Payments or earnings for a defined pay period. The workflow should not treat calculated or submitted results as approved until the relevant Xactly status is confirmed.

Integration direction
Xactly
Martini
Workday
Example Mapping
Xactly FieldCanonical FieldTarget Field
Payment.participantIdworkerIdPayroll worker identifier
Payment.amountapprovedCompensationPayment amount
Payment.payPeriodpayPeriodPayroll period
Payment.statusapprovalStatusPayment approval status
Martini implementation pattern

A Martini workflow retrieves Xactly Payments or earnings filtered by pay period and approval status, maps participant identifiers to the target payroll model, validates totals and required dimensions, and submits only approved results. It records acknowledgements, prevents duplicate delivery, and creates exceptions for missing mappings or rejected downstream writes.

Martini capabilities used
  • API consumption
  • scheduled workflows
  • data mapping
  • business rules
  • validation
  • idempotency
  • reconciliation

Pattern 4: Publish quotas and attainment to Snowflake

When to use this pattern

Use this pattern when analytics, finance, or sales operations need historical Xactly Quotas, Credits, attainment, or payment data for dashboards and period-close analysis.

Integration direction
Xactly
Martini
Snowflake
Example Mapping
Xactly FieldCanonical FieldTarget Field
Quota.participantIdparticipantIdparticipant_id
Quota.periodcompensationPeriodcompensation_period
Quota.amountquotaAmountquota_amount
Credit.amountcreditedAmountcredited_amount
Martini implementation pattern

Martini runs an incremental workflow using the confirmed Xactly filters or batch exports, applies canonical mappings and period rules, validates counts and totals, and writes curated data to Snowflake. A durable watermark and source identifiers support replay, late-arriving corrections, and reconciliation without duplicating prior loads.

Martini capabilities used
  • scheduled workflows
  • API consumption
  • data transformation
  • database integration
  • watermark management
  • validation
  • monitoring

Applications commonly integrated with Xactly

Xactly Incent commonly participates in enterprise data flows involving sales, human resources, finance, payroll, and analytics applications. The exact direction and object mappings depend on the customer’s compensation model, Xactly product edition, and API entitlements.

Application Scenario Direction Martini Pattern
Salesforce Import Opportunities, sales transactions, account information, and seller assignments for commission processing. Salesforce → Martini → Xactly A scheduled Martini workflow retrieves changed Salesforce Opportunities and related sales data, applies eligibility rules, maps source identifiers and amounts to Xactly Transactions, submits the payload through the supported API or import mechanism, and records processing status for reconciliation.
Workday Synchronize workers, managers, organizational structures, and approved compensation results with HR and payroll processes. Workday → Martini → Xactly Martini retrieves effective-dated worker changes, validates manager and organizational relationships, maps them to Xactly Participants and related structures, and separately distributes approved Xactly Payments or earnings where the target payroll process requires them.
SAP SuccessFactors Provide employee and organizational data used to maintain Xactly Participants and positions. SAP SuccessFactors → Martini → Xactly A scheduled workflow retrieves changed employee and organization data, applies effective-date and termination rules, performs idempotent upserts, and routes rejected mappings to an exception process.
SAP S/4HANA Supply order, billing, customer, product, or finance data used as the source for incentive Transactions. SAP S/4HANA → Martini → Xactly Martini retrieves eligible sales or billing events from SAP S/4HANA, normalizes currencies and dates, validates participant and product references, submits Xactly Transactions in batches, and reconciles accepted and rejected results.
NetSuite Exchange sales, customer, invoice, or payment-related information and distribute approved compensation results to finance processes. NetSuite → Martini → Xactly Martini orchestrates source-data retrieval and Xactly submission, then retrieves approved Payments or earnings and maps them into NetSuite finance objects with pay-period and participant validation.
Snowflake Centralize Xactly transaction, credit, quota, attainment, and payment data for analytics and reconciliation. Xactly → Martini → Snowflake A scheduled Martini workflow retrieves incremental Xactly data, applies canonical mappings and watermark logic, validates batch totals, and writes curated compensation data to Snowflake through the available database or ingestion interface.
Oracle HCM Cloud Synchronize worker and organizational data and support downstream payroll or compensation reporting. Oracle HCM Cloud → Martini → Xactly Martini retrieves changed workers and organizational assignments, maps effective-dated attributes to Xactly Participants, validates required relationships, and publishes approved compensation results to the appropriate downstream process.
ServiceNow Route compensation-processing exceptions, data-quality issues, or operational incidents through service-management workflows. Xactly → Martini → ServiceNow Martini creates ServiceNow incidents or tasks for permanent Xactly validation failures and operational exceptions, includes correlation and batch identifiers, and can update status when the exception is resolved.

How to build a Xactly integration in Martini

Objective

Establish access to the customer’s Xactly product and environment using the authentication method documented for the tenant.

Instructions in Martini

  • Confirm the Xactly product, tenant, base URL, API entitlement, and environment.
  • Configure OAuth 2.0 or approved service credentials as environment-managed Martini secrets.
  • Use a least-privilege integration identity with only the required object and operation permissions.
  • Keep development, test, and production configuration separate.

Objective

Select a trigger that matches the confirmed Xactly interface and the business latency requirement.

Instructions in Martini

  • Use a scheduler for polling, incremental synchronization, or batch submissions.
  • Use an API-triggered workflow when another application initiates the exchange.
  • Use a webhook or callback trigger only if the customer’s Xactly product explicitly supports the required event.
  • Define the polling interval, processing window, and watermark strategy.

Objective

Acquire Xactly or source-system data while accounting for pagination, batch status, and late-arriving changes.

Instructions in Martini

  • Retrieve pages or continuation tokens using the confirmed Xactly API behavior.
  • Track submission or job identifiers for asynchronous and batch processing.
  • Use modified-time, effective-date, or processing-status filters where available.
  • Preserve source identifiers, correlation IDs, and compensation-period context.

Objective

Coordinate source retrieval, Xactly calls, validation, target writes, and reconciliation in a maintainable Martini workflow.

Instructions in Martini

  • Separate transport, transformation, business rules, and persistence concerns.
  • Use reusable services or workflow components for common authentication and response handling.
  • Branch between transient failures, permanent validation errors, and business exceptions.
  • Keep batch-level and record-level outcomes distinct.

Objective

Convert Xactly Participants, Transactions, Credits, Quotas, Payments, or related objects into the target application’s model.

Instructions in Martini

  • Define canonical identifiers for participants, transactions, periods, plans, and source records.
  • Normalize dates, currencies, decimal precision, signs, and effective dates.
  • Map only fields confirmed by the tenant schema and preserve source references.
  • Validate required dimensions before submitting or writing data.

Objective

Ensure that only eligible, complete, and appropriately approved compensation data is processed.

Instructions in Martini

  • Check participant, position, territory, product, currency, and amount requirements.
  • Apply transaction eligibility and payment approval rules before downstream delivery.
  • Handle inactive participants, plan changes, corrections, and late-arriving transactions explicitly.
  • Route records that require business review to an exception process.

Common Xactly data objects used in integrations

ObjectTypical UseCommon target systemsMartini handling
ParticipantsEmployees, sales representatives, partners, or other individuals eligible for incentive compensation.Workday, SAP SuccessFactors, Oracle HCM Cloud, Salesforce, payroll platformsMartini retrieves or receives participant changes, validates identifiers and effective dates, maps organizational relationships, and performs controlled creates or updates through the supported Xactly interface.
Compensation plansRules and structures that determine how participants earn commissions or incentives.Salesforce, HR systems, finance platforms, reporting storesMartini can retrieve plan-related data where exposed, apply plan and effective-date business rules, and preserve version or period context during synchronization.
TransactionsSales or business events imported into Xactly for compensation processing.Salesforce, SAP S/4HANA, NetSuite, data warehousesMartini extracts eligible source events, validates required dimensions, maps stable source identifiers, submits batches or API requests, and reconciles accepted, rejected, and finalized results.
CreditsCredited sales amounts or credit allocations assigned to participants or positions.Snowflake, reporting platforms, finance applicationsMartini retrieves credits incrementally where supported, normalizes participant and period identifiers, and publishes validated results for reporting or reconciliation.
QuotasPerformance targets used to measure attainment and calculate incentive outcomes.Salesforce, Snowflake, reporting applications, planning systemsMartini synchronizes quota data using effective dates and period keys, validates participant or territory relationships, and exposes or stores the results for downstream reporting.
PaymentsCalculated or approved compensation amounts paid to participants.Workday, payroll platforms, SAP, NetSuite, finance systemsMartini retrieves approved results, validates pay-period and worker mappings, transfers permitted fields, records acknowledgements, and routes exceptions for review.

Authentication and security considerations

Tenant-specific authentication

Xactly authentication is product- and environment-specific. Confirm whether the provisioned interface uses OAuth 2.0, client credentials, service accounts, or another approved method, including scopes, token behavior, tenant identifiers, and endpoint URLs.

Least-privilege access

Use a dedicated Xactly integration identity with only the roles and permissions required for the relevant Participants, Transactions, Credits, Quotas, Payments, or related objects.

Martini secrets

Store Xactly credentials, OAuth client data, tokens, and environment-specific configuration in Martini-managed secrets or secure environment configuration rather than in workflows or mappings.

Compensation data protection

  • Limit compensation and employee data to authorized workflows and target systems.
  • Avoid writing payment amounts or personally identifiable information to verbose logs.
  • Preserve correlation identifiers and audit metadata without exposing unnecessary sensitive fields.

Operational considerations for Xactly integrations

Pagination and incremental processing

Confirm whether Xactly endpoints use pages, offsets, cursors, or continuation tokens. Use stable sorting and persist modified-time, effective-date, or processing-status watermarks where supported.

Batch volume and rate behavior

Confirm payload limits, concurrency restrictions, import-job limits, and asynchronous processing behavior before processing high-volume Transactions near period close.

Idempotency and reconciliation

Use stable source identifiers or confirmed external identifiers to prevent duplicate Transactions. Reconcile submitted, accepted, rejected, and finalized results rather than treating an accepted batch as proof of individual success.

Retries and errors

  • Retry transient transport and rate-limit failures with controlled backoff.
  • Do not automatically retry permanent validation or business-rule rejections.
  • Route unresolved records to an exception or review workflow.

Schema and testing

Xactly compensation models can vary by customer and may change between plans or periods. Test mappings in a non-production environment, monitor API lifecycle changes, and keep optional fields aligned with the tenant schema.

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

Orchestration across systems

Martini coordinates Xactly API calls, HR synchronization, sales transaction imports, payroll delivery, file processing, and analytics publication in workflows that are easier to govern than isolated scripts.

Reusable mapping and business logic

Mappings, validations, effective-date rules, approval checks, and reconciliation logic can be structured as reusable integration assets rather than duplicated across point-to-point interfaces.

Operational resilience

Martini supports scheduled and API-triggered workflows with explicit handling for pagination, batch status, retries, exceptions, and monitoring. This is important when compensation processing involves high volumes and period-close controls.

Controlled API exposure

Martini can expose a secured API façade for approved Xactly data, allowing applications to consume normalized results without receiving Xactly credentials or depending directly on tenant-specific implementation details.

Frequently asked questions

How can Xactly be integrated with enterprise systems?

Xactly can be integrated through its tenant-specific REST APIs, and selected environments may also provide batch, asynchronous, file, or legacy SOAP interfaces. Common flows synchronize Participants and organizational data into Xactly, submit Transactions, and distribute approved Credits, Quotas, earnings, or Payments to downstream systems.

Can Martini integrate with Xactly?

Yes. Martini can integrate with Xactly by consuming the supported Xactly REST APIs, orchestrating scheduled or API-triggered workflows, processing confirmed batch or file exchanges, and exposing controlled APIs for Xactly data. Exact resources and authentication depend on the customer’s product, tenant, licensing, and API entitlement.

Do I need a connector to integrate Xactly with Martini?

No. A dedicated Xactly connector is not required. Martini can use Xactly’s confirmed native integration mechanisms, including REST APIs, supported batch or file exchanges, tenant-approved authentication, and callbacks only where the customer’s Xactly product explicitly provides them.

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

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

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

REST APIs are the primary mechanism to investigate for new integrations. Batch or asynchronous interfaces may be appropriate for high-volume Transactions, while supported files can suit selected processes. SOAP should be considered only when the customer’s Xactly interface catalog confirms a required legacy or product-specific service.

Does Xactly provide webhooks or event callbacks?

No universal Xactly webhook or callback catalog was confirmed. Event coverage must be verified for the specific product and tenant. Where callbacks are unavailable, Martini can use scheduled polling, incremental queries, or batch exports.

How should Xactly data synchronization work?

Use stable source identifiers, incremental or effective-date filters where available, durable watermarks, and explicit processing states. For Transactions and batch submissions, distinguish submitted, accepted, rejected, and finalized outcomes so that retries do not create duplicates and corrections can be reconciled.

Can Martini expose an API façade for Xactly data?

Yes. Martini can expose a controlled REST API that retrieves or serves approved Xactly Participants, Credits, Quotas, attainment, earnings, or Payments. The façade can apply authorization, field filtering, transformation, business rules, and error handling without exposing Xactly credentials or tenant-specific details to every consumer.

Related Martini documentation

API Integration

Workflows

Security

Operations

Plan your Xactly integration with Martini

Use Martini to connect Xactly Incent with sales, HR, payroll, finance, and analytics systems through maintainable workflows, APIs, mappings, and controlled operational processes.

EXPLORE MARTINI
BOOK A DEMO