Ellipse Gradient for Header

Amperity Integration Guide

Integrate Amperity customer data, audiences, batch operations, and file exchanges with enterprise applications through APIs and orchestrated workflows.

Amperity integration options at a glance

Amperity supports API-based integration for interacting with tenant services and customer data, while batch-oriented ingestion, exports, activation, and file exchange are important for large customer and transaction datasets. Martini can consume documented Amperity REST APIs, transform request and response payloads, orchestrate long-running jobs, and poll for completion on a schedule. File workflows can process supported customer, transaction, product, and audience formats once the tenant-specific contract is confirmed. Operation-specific callbacks may be available, but Amperity should not be treated as providing a universal webhook stream. Credentials and destination configuration remain environment-specific and should be stored securely.

Integration pointSupported by Amperity?Common use casesHow Martini supports it
REST APIsYesInteract with documented Amperity services and tenant data, submit or retrieve customer-related information, coordinate operations, and retrieve audience or activation results.Martini can consume Amperity REST endpoints from workflows, transform payloads, apply business rules, and expose controlled APIs around Amperity operations.
Bulk, asynchronous, and batch processingLimitedProcess large customer and transaction datasets, exports, ingestion operations, and audience activations. Exact job endpoints and controls require tenant-level confirmation.Martini can start a batch operation, persist its job identifier, poll for completion, retrieve results or error files, and route outcomes.
File and attachment exchangeLimitedExchange customer, transaction, product, and audience data through tenant-configured files, storage, or transfer mechanisms.Martini can process JSON, XML, CSV, Excel, and other supported flat files after the Amperity file contract, transport, encryption, and naming rules are confirmed.
Webhooks and outbound callbacksLimitedReceive notifications for selected operations if the relevant Amperity service documents callback support; no universal event stream was confirmed.Martini can receive documented callbacks or use scheduled polling when callbacks are unavailable, while retaining operation identifiers for idempotency.
AuthenticationLimitedAuthenticate API access with tenant-specific credentials or token-based authorization and apply permissions to customer data, audiences, queries, exports, or destinations.Martini can store environment-specific credentials in secrets and apply them to API calls without hard-coding sensitive values in workflows.
Scheduled synchronizationYesPoll job status, retrieve generated results, run incremental synchronization, and coordinate recurring batch or export processes where tenant contracts support them.Martini scheduler-triggered workflows can use watermarks, overlap windows, retries, and persisted job state for reliable synchronization.
Database and analytics accessNot confirmedDirect SQL, JDBC, or database access to Amperity managed data should not be assumed.Martini should use documented Amperity APIs, queries, exports, or destinations; direct database access requires explicit tenant documentation and authorization.

How Amperity exposes data and business events

Amperity REST APIs

Amperity provides API-based integration capabilities for interacting with tenant services and data. API availability, resource names, permissions, and payload contracts should be confirmed in the tenant-specific documentation.

Martini implementation pattern

Martini uses a workflow to authenticate, call the documented Amperity endpoint, validate the response, map the customer, audience, transaction, or operation data, and invoke downstream systems or expose a controlled internal API.

Implementation sequence

Authenticate with tenant-specific Amperity credentials
Call the documented Amperity REST endpoint
Validate the response and correlation identifiers
Map the payload to the canonical model
Apply business rules and consent checks
Write the result to the target system and log the outcome

Amperity batch operations

Batch-oriented ingestion, export, and activation are important for Amperity's large customer and transaction datasets. Exact asynchronous endpoints, job controls, and result formats require tenant-level confirmation.

Martini implementation pattern

Martini starts the documented operation, stores its job identifier outside the individual execution, and uses a separate scheduled workflow to poll status, retrieve results or error files, reconcile counts, and route failures.

Implementation sequence

Start the documented Amperity batch operation
Persist the Amperity job identifier and source batch ID
Schedule status polling with bounded retries
Retrieve results or error details after completion
Reconcile accepted and rejected counts
Deliver successful results and escalate failures

Amperity file exchange

File exchange can support customer, transaction, product, and audience data when configured by the Amperity implementation. Formats, storage, transport, encryption, naming, and schedules must be confirmed before delivery.

Martini implementation pattern

Martini receives or creates the agreed file, validates its structure and control totals, applies transformations and naming rules, delivers it through the supported transport, and records the file and delivery state.

Implementation sequence

Receive or generate the agreed data file
Validate encoding, schema, identifiers, and control totals
Transform records to the Amperity file contract
Deliver the file through the configured mechanism
Record the file name, batch ID, and delivery timestamp
Handle duplicate, partial, or rejected files

Operation-specific callbacks

Amperity may provide callbacks for selected operations, but a general-purpose webhook framework for all customer, transaction, audience, and activation events was not confirmed.

Martini implementation pattern

Where a documented callback exists, Martini exposes or consumes the required endpoint, validates the notification, retrieves authoritative operation state from Amperity, and processes the result. Otherwise, a scheduler performs polling.

Implementation sequence

Receive the documented operation notification
Authenticate and validate the callback payload
Retrieve authoritative operation status
Process the completed result or failure
Persist the operation state and correlation ID
Use scheduled polling when no callback is available

Common Amperity integration patterns

Pattern 1: Enrich CRM customers with unified profiles

When to use this pattern

Use this pattern when Salesforce users need Amperity-resolved customer attributes, purchase history, loyalty information, or audience membership. Stable identifiers and Amperity identity rules should be preserved rather than relying on email alone.

Integration direction
Salesforce
Martini
Amperity
Salesforce
Example Mapping
Amperity FieldCanonical FieldTarget Field
source customer IDcustomer.sourceIdSalesforce External ID
unified customer profilecustomer.profileSalesforce Contact or Account attributes
purchase historycustomer.purchaseSummarySalesforce customer insights
audience membershipcustomer.audienceMembershipSalesforce campaign or segment field
Martini implementation pattern

Martini receives identifiers from Salesforce, queries the documented Amperity API, validates the resolved profile and privacy rules, maps the response, and updates Salesforce. Correlation IDs, caching where appropriate, retry handling, and rejected-record routing prevent repeated or unsafe lookups.

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

Pattern 2: Activate Amperity audiences in marketing platforms

When to use this pattern

Use this pattern when Amperity audiences must be refreshed in Salesforce Marketing Cloud, Braze, Google Ads, or Meta. The workflow should preserve the audience identifier and refresh timestamp and support the target's full or delta contract.

Integration direction
Amperity
Martini
Salesforce Marketing Cloud or Braze
Google Ads or Meta
Example Mapping
Amperity FieldCanonical FieldTarget Field
audience IDaudience.iddestination audience identifier
customer identifiercustomer.matchKeydestination matching key
audience refresh timestampaudience.refreshedAtdestination update timestamp
consent statuscustomer.consentdestination eligibility
Martini implementation pattern

Martini retrieves the audience result, applies consent, suppression, and empty-audience rules, transforms the payload for the selected destination, submits the delivery, and records accepted, rejected, and removed members. Retry and reconciliation logic prevents duplicate activation.

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

Pattern 3: Ingest transaction and product data

When to use this pattern

Use this pattern when Shopify, NetSuite, or another operational source supplies Amperity with purchase history and product context. It is suitable for high-volume API or file-based ingestion when the tenant contract is known.

Integration direction
Shopify or NetSuite
Martini
Amperity
Example Mapping
Amperity FieldCanonical FieldTarget Field
source customer IDcustomer.sourceIdAmperity customer identifier
transaction IDtransaction.idAmperity transaction ID
order timestamptransaction.occurredAtAmperity transaction date
SKUproduct.skuAmperity product SKU
Martini implementation pattern

Martini retrieves or receives source data, validates required fields and totals, normalizes identifiers, transforms the API payload or file, and submits an idempotent batch. It records source batches, file names, counts, and rejection details for reconciliation.

Martini capabilities used
  • workflows
  • file processing
  • data mapping
  • validation
  • error handling

Pattern 4: Orchestrate and monitor Amperity batch jobs

When to use this pattern

Use this pattern for long-running data, audience, export, or activation jobs where a synchronous request would be unreliable. It separates job submission from status polling and downstream delivery.

Integration direction
Martini
Amperity
Martini
Downstream application
Example Mapping
Amperity FieldCanonical FieldTarget Field
Amperity job IDoperation.jobIdworkflow correlation ID
job statusoperation.statusmonitoring state
result fileoperation.resultLocationdownstream delivery input
error detailsoperation.errorsoperational incident
Martini implementation pattern

A Martini workflow starts the operation and persists its state. A scheduled workflow polls with bounded retries and backoff, retrieves results or errors, reconciles counts, delivers successful output, and escalates jobs that exceed the maximum polling period.

Martini capabilities used
  • workflow orchestration
  • scheduler triggers
  • API consumption
  • state management
  • error handling

Applications commonly integrated with Amperity

Amperity is commonly positioned between operational data sources, customer-facing applications, marketing platforms, and activation destinations. The specific native destination or ingestion method must be confirmed for each tenant; Martini can coordinate these exchanges using documented APIs, files, and workflow controls.

Application Scenario Direction Martini Pattern
Salesforce Enrich Accounts, Contacts, or Leads with unified profiles, purchase history, loyalty attributes, or audience membership. Salesforce → Martini → Amperity Receive stable Salesforce identifiers, query documented Amperity APIs for customer data, map resolved attributes, and return or update Salesforce fields with validation, correlation IDs, and retry handling.
Salesforce Marketing Cloud Activate Amperity audiences for email, journey, and campaign execution. Amperity → Martini → Salesforce Marketing Cloud Retrieve an audience result, preserve its identifier and refresh timestamp, transform the audience to the destination contract, and deliver a full or delta update with reconciliation and failure routing.
Braze Send customer audiences and profile attributes to support personalization and lifecycle messaging. Amperity → Martini → Braze Orchestrate audience extraction, apply consent and field rules, map customer identifiers and attributes, and deliver the result while recording activation status and rejected members.
Google Ads Activate customer audiences for advertising and suppression use cases. Amperity → Martini → Google Ads Transform an Amperity audience into the destination format, apply consent and suppression rules, submit the delivery, and track the audience refresh and downstream response.
Meta Activate customer audiences for advertising and exclusion campaigns. Amperity → Martini → Meta Retrieve the audience, validate matching identifiers and consent, map the payload to the destination contract, and use idempotent delivery with operational reconciliation.
Shopify Supply commerce and order data to Amperity for customer analytics and identity resolution. Shopify → Martini → Amperity Retrieve or receive Shopify customer, order, and product data, validate source IDs and totals, transform the payload or file, and deliver it through the documented Amperity ingestion method.
NetSuite Provide order, customer, and product information for customer analytics and segmentation. NetSuite → Martini → Amperity Extract source data, normalize customer and transaction identifiers, reconcile counts and totals, and submit API or file-based batches with duplicate prevention and error handling.
Snowflake Exchange analytical customer, transaction, and product data with a cloud data platform where the tenant architecture supports it. Snowflake → Martini → Amperity Use documented APIs, exports, or destinations rather than assuming direct database access; Martini can transform and route governed datasets while recording batch and watermark state.

How to build a Amperity integration in Martini

Objective

Establish tenant-specific Amperity access and configure the target applications or file transport without embedding credentials in workflows.

Instructions in Martini

  • Confirm the Amperity API, file, or destination contract for the tenant
  • Store API credentials or tokens in environment-specific Martini secrets
  • Configure target-system credentials and permissions separately
  • Confirm scopes, token lifetime, rotation, and data access permissions

Objective

Select an event, API request, file arrival, or schedule that matches the confirmed Amperity integration mechanism.

Instructions in Martini

  • Use an API-triggered workflow for on-demand profile or audience operations
  • Use a scheduler for polling, incremental synchronization, and batch completion
  • Use a documented callback only for the selected operation it supports
  • Define overlap windows and maximum polling periods

Objective

Receive or retrieve authoritative Amperity data while preserving identifiers, cursors, watermarks, and job state.

Instructions in Martini

  • Call documented REST resources or retrieve the agreed file
  • Persist job IDs, source batch IDs, cursors, and timestamps
  • Retrieve authoritative status before processing callback notifications
  • Handle pagination and late-arriving data according to the contract

Objective

Coordinate API calls, file handling, polling, target delivery, and operational state in maintainable Martini workflows.

Instructions in Martini

  • Separate long-running job submission from scheduled status polling
  • Route customer, transaction, product, and audience flows independently
  • Use reusable workflow logic for validation, mapping, and delivery
  • Apply bounded retries and escalation paths

Objective

Transform Amperity concepts and source data into canonical and target models with explicit contract checks.

Instructions in Martini

  • Map unified profiles, identifiers, transactions, products, audiences, and destinations explicitly
  • Validate required fields, types, consent, identifiers, and control totals
  • Preserve source provenance and resolved customer identifiers
  • Version mappings when schemas change

Objective

Enforce identity, privacy, consent, deduplication, and destination-specific rules before writing data.

Instructions in Martini

  • Apply opt-out and suppression behavior before activation
  • Use deterministic file names or idempotency keys
  • Define full replacement versus delta delivery
  • Reject incomplete or ambiguous identity data safely

Common Amperity data objects used in integrations

ObjectTypical UseCommon target systemsMartini handling
Unified customer profilesCustomer 360 data assembled through identity resolution across source systems.Salesforce, Braze, Salesforce Marketing Cloud, analytics platformsMartini retrieves documented profile responses, preserves resolved and source identifiers, validates attributes, and maps them to target models.
Customer identifiersEmail addresses, phone numbers, loyalty IDs, and source-system IDs used for matching and resolution.Salesforce, Shopify, NetSuite, marketing platformsMartini preserves identifier provenance, applies validation and consent rules, and avoids treating a single email address as a universal identity without documented rules.
TransactionsPurchase and order activity used for customer history, segmentation, and analytics.Amperity, Snowflake, marketing and analytics platformsMartini transforms API payloads or files, maintains transaction IDs, reconciles counts and totals, and uses idempotent delivery.
Audience segmentsGroups of customers selected for analysis, activation, personalization, or campaign distribution.Salesforce Marketing Cloud, Braze, Google Ads, MetaMartini retrieves or receives audience results, preserves audience IDs and refresh timestamps, applies consent rules, and performs full or delta delivery.
Product catalog dataProducts, SKUs, categories, and related attributes used for analytics and audience construction.Shopify, NetSuite, Amperity, analytics platformsMartini validates product identifiers and attributes, processes files or API payloads, and routes batches according to the confirmed Amperity contract.
DestinationsConfigured downstream systems or activation endpoints receiving audiences or customer data.Salesforce Marketing Cloud, Braze, Google Ads, MetaMartini coordinates destination-specific mappings and delivery status, but treats destination availability and configuration as tenant-specific.

Authentication and security considerations

Tenant-specific authentication

Amperity authentication can vary by API and deployment. Confirm whether the tenant uses API credentials, API keys, bearer tokens, scopes, and permission settings before implementation.

Secrets and permissions

Martini can store environment-specific credentials in secrets and apply them to API calls without hard-coding sensitive values. Restrict access to customer profiles, audiences, queries, exports, and destinations according to least-privilege requirements.

Privacy and consent

Customer and transaction data may contain personal information. Define permitted fields, consent and opt-out propagation, retention, regional processing, access logging, and downstream deletion or suppression behavior.

Operational considerations for Amperity integrations

Throughput and pagination

Confirm Amperity and destination limits for request rates, payload size, concurrent jobs, audience size, and batch frequency. Validate page size, cursor behavior, ordering, and cursor expiration before implementing incremental retrieval.

Idempotency and reconciliation

Persist customer, source-system, transaction, audience, job, and file identifiers. Use deterministic file names or idempotency keys, reconcile counts and totals, and commit watermarks only after successful processing.

Long-running operations

Do not hold a synchronous workflow open indefinitely. Persist the job state and use a scheduled workflow to poll with bounded retries, backoff, maximum execution periods, and escalation for stalled operations.

Schema and file changes

Use explicit versioned mappings, required-field and type validation, contract tests, and dead-letter handling. For files, define encoding, compression, encryption, manifests, naming, partial-file detection, retention, and duplicate-file behavior.

Observability

Log correlation identifiers rather than sensitive profile data. Track batch and job IDs, audience IDs, records read and rejected, watermarks, retry counts, and failure reasons.

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

Orchestrated integration logic

Martini coordinates Amperity API calls, file exchange, batch submission, status polling, transformation, target delivery, and operational escalation in workflows rather than scattering logic across scripts.

Reusable mappings and rules

Explicit mappings and validation rules make customer, transaction, product, and audience contracts easier to test and change as tenant schemas evolve. Business rules can be reused across API and file-based flows.

Reliable operations

Martini provides a place to implement secrets management, retries, idempotency, reconciliation, logging, and scheduled processing for long-running Amperity operations. This reduces fragile point-to-point behavior without assuming a native connector.

Controlled API access

Martini can expose controlled APIs for applications that need Amperity data, applying authorization, transformations, and tenant-specific rules while keeping downstream consumers independent of internal Amperity details.

Frequently asked questions

How can Amperity be integrated with enterprise systems?

Amperity can be integrated through documented REST APIs, batch and asynchronous operations, configured file exchanges, scheduled synchronization, and operation-specific callbacks where available. The exact resources, file contracts, destinations, and authentication requirements should be confirmed for the tenant.

Can Martini integrate with Amperity?

Yes. Martini can integrate with Amperity by consuming documented Amperity REST APIs, processing supported files, orchestrating batch jobs, polling operation status, and handling selected callbacks when the relevant Amperity service provides them.

Do I need a connector to integrate Amperity with Martini?

No. A dedicated Amperity connector is not required. Martini can use Amperity's confirmed native integration mechanisms, including REST APIs, supported files, batch operations, scheduled workflows, and operation-specific callbacks.

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

Lonti does not charge an additional per-connector or per-vendor fee to integrate Amperity. The integration is subject to the provisioned capacity of the Martini environment. Separate costs may apply from Amperity, cloud infrastructure, downstream applications, or other third-party systems.

Which Amperity integration methods should an enterprise use?

Use REST APIs for documented control-plane operations, targeted profile or audience requests, and job status. Use batch or file exchange for high-volume customer, transaction, and product data where supported. Use scheduled workflows when callbacks are unavailable.

Does Amperity provide webhooks or callbacks for data changes?

A universal webhook stream for all customer, transaction, identity, audience, and activation changes was not confirmed. Amperity may provide notifications for selected operations, so integrations should use documented callbacks only where available and otherwise rely on scheduled API polling or batch exports.

How should synchronization with Amperity be designed?

Use stable documented identifiers, cursors, timestamps, watermarks, or export snapshots; preserve job and source-batch IDs; and apply idempotent updates. An overlap window can help account for late-arriving data and identity-resolution changes.

Can Martini expose an API façade for Amperity?

Yes. Martini can expose a controlled REST API that fronts documented Amperity operations, applies authorization and business rules, transforms requests and responses, and shields consuming applications from tenant-specific API details.

Related Martini documentation

APIs

Workflows

Data

Security

Operations

Integrate Amperity with confidence

Use Martini to connect Amperity APIs, batch operations, files, and selected callbacks with enterprise applications through secure, observable, and maintainable workflows.

EXPLORE MARTINI
BOOK A DEMO