.png)
Criteo Integration Guide
Connect Criteo Marketing Solutions and Retail Media REST APIs with enterprise workflows using OAuth 2.0, scheduled synchronization, reporting, and data transformation.
Criteo integration options at a glance
Criteo primarily integrates through REST APIs for its Marketing Solutions and Retail Media products, with access governed by OAuth 2.0 scopes, account permissions, and product availability. Martini can obtain and renew bearer tokens, call Criteo endpoints, paginate through Advertisers, Campaigns, Ad sets, Audiences, Retailers, and reports, and transform JSON payloads for downstream systems. Reporting and selected data operations may be asynchronous or bulk-oriented, so workflows can submit requests, poll status, and retrieve completed results. A universal Criteo webhook framework was not confirmed; scheduled Martini workflows can instead poll for changes and report completion. File-oriented processes are resource-specific rather than general-purpose.
| Integration point | Supported by Criteo? | Common use cases | How Martini supports it |
|---|---|---|---|
| REST APIs | Yes | List Advertisers, Campaigns, Ad sets, Retailers, and Audiences; manage supported campaign or audience operations; request reports; and submit enabled conversion or transaction data. | Martini can consume Criteo REST endpoints, handle JSON requests and responses, paginate collections, map fields, and expose normalized internal APIs. |
| Authentication | Yes | Criteo APIs use OAuth 2.0 bearer access tokens with client credentials, scopes, and account-level permissions. | Martini can obtain and renew tokens in reusable workflow logic and store client credentials, scopes, and account identifiers in protected environment configuration. |
| Bulk / async / batch APIs | Limited | Reporting and selected data operations may use asynchronous report generation, bulk uploads, or endpoint-specific batch behavior. | Martini can submit an operation, retain its identifier, poll status with bounded retries, retrieve results, and handle item-level failures where returned. |
| Scheduled synchronization | Yes | Scheduled polling can retrieve campaign, audience, and reporting changes when a relevant outbound callback is unavailable. | Martini scheduler-triggered workflows can run incrementally, partition date ranges, checkpoint progress, and route failures for retry. |
| File / attachment APIs | Limited | Selected reporting or catalog processes may involve file-oriented exchange, but a general-purpose attachment API was not confirmed. | Martini can process supported file payloads when a specific Criteo resource requires them, while keeping the implementation resource-specific. |
| Webhooks / outbound callbacks | Not confirmed | A universal Criteo webhook or callback framework for campaign, audience, and reporting events was not confirmed. | Martini should use scheduled polling for required changes; Martini APIs can receive events from other systems and then invoke Criteo APIs. |
| Database / analytics access | No | Criteo does not expose a general customer-facing operational database connection; analytics access is provided through APIs and reporting resources. | Martini can transform Criteo report data and write it to supported databases or analytics platforms without requiring direct Criteo database access. |
| GraphQL APIs | Not confirmed | No official Criteo GraphQL API was confirmed for the reviewed integration surfaces. | Martini integrations should consume the documented Criteo REST APIs rather than assume GraphQL availability. |
| SOAP APIs | Not confirmed | No official Criteo SOAP API was confirmed for the reviewed integration surfaces. | Martini integrations should use Criteo REST endpoints rather than assume SOAP availability. |
How Criteo exposes data and business events
Criteo REST APIs
REST is Criteo’s principal documented integration mechanism across its Marketing Solutions and Retail Media surfaces. Available resources depend on the product, account type, permissions, and API version.
Martini implementation pattern
Martini implementation pattern: Martini obtains an OAuth 2.0 bearer token, calls the required Criteo endpoint, handles pagination and response validation, maps the JSON payload to an internal model, and writes or exposes the result to downstream applications.
Implementation sequence
Criteo asynchronous reporting
Criteo reporting operations may require a request to be submitted before the report is generated and retrieved. The exact behavior is endpoint-specific.
Martini implementation pattern
Martini implementation pattern: A workflow submits a report definition and time window, stores the returned operation identifier, polls status with timeout and retry controls, retrieves the completed report, and loads normalized metrics into a data platform.
Implementation sequence
Criteo OAuth 2.0
Criteo APIs use OAuth 2.0 bearer access tokens. Client credentials, scopes, and account permissions determine which advertisers, retailers, campaigns, audiences, and reports are available.
Martini implementation pattern
Martini implementation pattern: A reusable authentication workflow reads protected environment configuration, requests a token, renews it when required, and supplies the bearer token to subsequent Criteo REST requests without embedding secrets in workflow logic.
Implementation sequence
Scheduled Criteo synchronization
A universal Criteo webhook mechanism was not confirmed. Scheduled polling is therefore the dependable general pattern for retrieving campaign, audience, and reporting changes.
Martini implementation pattern
Martini implementation pattern: A scheduler-triggered workflow reads its last successful checkpoint, retrieves the relevant Criteo resources or report window, applies idempotency and late-arriving-data rules, and records the next checkpoint after successful processing.
Implementation sequence
Criteo audience and conversion operations
Criteo supports selected audience, conversion, or transaction workflows subject to product availability, account authorization, data requirements, and privacy controls.
Martini implementation pattern
Martini implementation pattern: Martini receives approved source data, validates consent and stable identifiers, transforms the payload for the enabled Criteo operation, submits it, and records response-level outcomes for reconciliation.
Implementation sequence
Common Criteo integration patterns
Pattern 1: Synchronize Criteo performance data to a warehouse
When to use this pattern
Use this pattern when marketing, finance, or analytics teams need a governed history of Criteo Campaigns, Ad sets, and Reports in Snowflake, Databricks, or another data platform. It supports partitioned date windows, late-arriving conversions, and reconciliation.
Integration direction
Example Mapping
| Criteo Field | Canonical Field | Target Field |
|---|---|---|
| campaignId | campaign.externalId | campaign_id |
| adSetId | adGroup.externalId | ad_set_id |
| spend | performance.spend | spend |
| conversions | performance.conversions | conversions |
Martini implementation pattern
A scheduled Martini workflow authenticates with Criteo, retrieves Advertisers and Campaigns, submits report requests for bounded windows, polls asynchronous operations, normalizes metrics, and writes warehouse rows using deterministic keys. It applies account time-zone and currency rules, preserves report metadata, and retries throttled or transient failures without duplicating completed loads.
Martini capabilities used
- workflows
- API consumption
- scheduling
- data mapping
- business rules
- error handling
- database integration
Pattern 2: Send commerce conversions to Criteo
When to use this pattern
Use this pattern when a commerce platform needs to submit order or transaction data to Criteo for supported measurement or advertising use cases. Availability depends on the Criteo product and account permissions.
Integration direction
Example Mapping
| Criteo Field | Canonical Field | Target Field |
|---|---|---|
| orderId | transaction.externalId | transaction_id |
| customerConsent | privacy.consentStatus | consent |
| totalPrice | transaction.value | conversion_value |
| createdAt | transaction.timestamp | event_time |
Martini implementation pattern
Martini receives or retrieves commerce transactions, validates consent and required fields, applies product-specific business rules, and submits eligible conversion data to Criteo. A stable transaction identifier and processing ledger prevent duplicate submissions; item-level failures are retained for selective retry and reconciliation.
Martini capabilities used
- API consumption
- API triggers
- data mapping
- validation
- business rules
- idempotency
- error handling
Pattern 3: Synchronize customer Audiences
When to use this pattern
Use this pattern when an organization needs to publish eligible, consented customer segments from Salesforce, a customer data platform, or a commerce system to Criteo. Audience operations must be enabled for the relevant account and product.
Integration direction
Example Mapping
| Criteo Field | Canonical Field | Target Field |
|---|---|---|
| contactId | audienceMember.externalId | member_id |
| audienceMember.normalizedIdentifier | identifier | |
| consentStatus | audienceMember.consent | consent |
| segmentName | audience.name | audience_name |
Martini implementation pattern
A Martini workflow retrieves approved audience members, applies consent and purpose checks, performs the required normalization or hashing, maps membership changes, and submits the supported Criteo Audience operation. It stores batch identifiers and upload results, distinguishes accepted from rejected members, and avoids resubmitting successful batches.
Martini capabilities used
- workflows
- API consumption
- mapping and transformation
- validation
- privacy rules
- batch processing
- retry handling
Pattern 4: Synchronize Retail Media product data
When to use this pattern
Use this pattern for Criteo Retail Media accounts that expose the applicable Product or Catalog operations. It is appropriate when a commerce system needs to exchange selected product attributes and identifiers with Criteo.
Integration direction
Example Mapping
| Criteo Field | Canonical Field | Target Field |
|---|---|---|
| sku | product.externalId | product_id |
| name | product.title | title |
| price | product.price | price |
| updatedAt | product.modifiedAt | updated_at |
Martini implementation pattern
Martini retrieves changed products from the commerce platform, validates required identifiers and attributes, maps them to the enabled Criteo Retail Media resource, and submits updates. The workflow records per-product results, retries transient failures, and uses a checkpoint so successful products are not unnecessarily resubmitted.
Martini capabilities used
- scheduled workflows
- API consumption
- data mapping
- schema validation
- business rules
- checkpointing
- error handling
Applications commonly integrated with Criteo
Criteo can be connected to commerce, CRM, finance, advertising, and analytics applications through its documented REST APIs. The exact flow depends on the Criteo product, account permissions, and enabled resources.
| Application | Scenario | Direction | Martini Pattern |
|---|---|---|---|
| Shopify | Exchange product, order, consent, and conversion information for commerce advertising and measurement. | Shopify → Martini → Criteo | Martini receives or retrieves Shopify data, validates consent and transaction identifiers, maps it to the applicable Criteo audience, conversion, or product format, and records submission outcomes with retry and duplicate controls. |
| Salesforce | Synchronize eligible customer or audience data and connect campaign or conversion outcomes with CRM processes. | Salesforce → Martini → Criteo | A Martini workflow retrieves approved Salesforce data, applies privacy and business rules, transforms the payload for Criteo, and can route Criteo reporting data back to Salesforce or a shared data platform. |
| Adobe Commerce | Send product, order, and conversion information to support commerce media and campaign measurement. | Adobe Commerce → Martini → Criteo | Martini polls or receives Adobe Commerce data, normalizes identifiers and timestamps, submits supported Criteo operations, and maintains an idempotent processing ledger. |
| NetSuite | Reconcile advertising spend, order revenue, and campaign performance with finance and ERP data. | Criteo → Martini → NetSuite | Martini requests Criteo reports, polls asynchronous operations, maps spend and performance metrics to NetSuite structures, and routes failed or incomplete loads for reconciliation. |
| Snowflake | Centralize Criteo campaign, ad set, audience, and report data for analytics and attribution. | Criteo → Martini → Snowflake | Scheduled Martini workflows retrieve partitioned Criteo reports, normalize dimensions and metrics, apply deterministic warehouse keys, and load Snowflake with late-arriving-data handling. |
| Databricks | Combine Criteo performance and conversion data with customer, product, and machine-learning datasets. | Criteo → Martini → Databricks | Martini extracts Criteo data, transforms it into the organization’s canonical analytics model, validates schema and date boundaries, and writes approved datasets to Databricks. |
| Google Ads | Consolidate paid-media performance and attribution reporting across advertising platforms. | Criteo → Martini → Google Ads | Martini retrieves and normalizes Criteo and Google Ads metrics into a shared reporting model; this is a multi-platform reporting flow rather than an assumed direct Criteo synchronization. |
| Amazon Ads | Combine Criteo and Amazon advertising metrics for unified reporting, budget analysis, and attribution. | Criteo → Martini → Amazon Ads | Separate API workflows retrieve platform metrics, Martini applies common dimensions and currency or time-zone rules, and a downstream reporting system receives the consolidated result. |
How to build a Criteo integration in Martini
Objective
Establish the Criteo API connection using OAuth 2.0 and environment-specific configuration.
Instructions in Martini
- Store the client identifier, client secret, scopes, account identifiers, and endpoint configuration as protected environment values.
- Create reusable authentication logic to request and renew bearer access tokens.
- Confirm that the OAuth client is authorized for the required Criteo product and accounts.
Objective
Select a trigger that reflects whether the integration is polling, reporting, or receiving source events from another system.
Instructions in Martini
- Use a scheduler for campaign, audience, catalog, or report synchronization.
- Use a Martini API when another application submits conversion or audience data.
- Do not assume Criteo provides a universal webhook for the required event.
Objective
Call the relevant Criteo REST resources and obtain complete, authorized datasets.
Instructions in Martini
- Retrieve Advertisers, Campaigns, Ad sets, Audiences, Retailers, or Reports as required.
- Implement pagination for collection endpoints.
- For asynchronous reports, store the operation identifier and poll with bounded attempts.
Objective
Coordinate authentication, API calls, transformations, business rules, and target-system writes in a maintainable workflow.
Instructions in Martini
- Separate token acquisition, resource retrieval, report polling, transformation, and persistence into clear workflow stages.
- Use reusable logic for common Criteo request and response handling.
- Preserve account, report-window, and operation context throughout the workflow.
Objective
Convert Criteo JSON payloads and source-system data into a canonical model while enforcing data quality and privacy rules.
Instructions in Martini
- Map Criteo identifiers, dimensions, metrics, statuses, dates, currencies, and account relationships.
- Validate required fields, consent status, time zones, and product-specific constraints.
- Use deterministic keys for Reports, Audiences, conversions, and product updates.
Objective
Control which records and operations are eligible for submission or loading.
Instructions in Martini
- Apply account, campaign, audience, consent, reporting-window, and environment rules.
- Handle late-arriving conversions and partial results explicitly.
- Ensure successful items are not resubmitted when a bulk or batch operation partially fails.
Common Criteo data objects used in integrations
| Object | Typical Use | Common target systems | Martini handling |
|---|---|---|---|
| Advertisers | Identify organizations or advertising accounts that own campaigns and performance data. | Data warehouses, CRM platforms, analytics systems | Martini retrieves Advertisers through REST APIs, maps account identifiers and permissions, and stores them in a canonical advertising-account model. |
| Campaigns | Represent advertising campaigns with targeting, budget, scheduling, and delivery configuration. | Analytics platforms, finance systems, internal campaign tools | Martini synchronizes Campaigns with pagination, applies account and status rules, and preserves external identifiers for reconciliation. |
| Ad sets | Group targeting and delivery settings within Campaigns. | Data warehouses, reporting systems, campaign operations platforms | Martini maps Ad sets to a canonical campaign hierarchy and handles incremental retrieval and schema validation. |
| Audiences | Represent customer or user segments for targeting, suppression, or measurement. | CRM platforms, customer data platforms, commerce systems | Martini validates consent and normalization requirements, transforms audience membership data, submits supported operations, and records upload status. |
| Retailers | Represent commerce businesses or retail media accounts operating retail media programs. | Commerce platforms, data warehouses, retail media reporting systems | Martini retrieves Retailers where authorized, maps account relationships, and uses the result to scope downstream Retail Media workflows. |
| Reports | Provide performance datasets containing dimensions and metrics such as spend, impressions, clicks, conversions, and revenue. | Snowflake, Databricks, NetSuite, BI and analytics platforms | Martini submits report requests, polls asynchronous status, retrieves results, normalizes date and currency fields, and loads them with duplicate prevention. |
Authentication and security considerations
OAuth 2.0 and account permissions
Criteo APIs use OAuth 2.0 bearer access tokens. Access depends on the client credentials, scopes, product permissions, and account relationships for advertisers or retailers.
Protecting credentials
Martini should store client identifiers, client secrets, scopes, and account configuration in protected environment settings. Tokens and secrets should not be embedded in workflows or written to logs.
Privacy and consent
Audience and conversion workflows may process personal or pseudonymous data. Validate consent, hashing or normalization requirements, retention rules, regional restrictions, and permitted purposes before sending data to Criteo.
Operational considerations for Criteo integrations
Throttling and pagination
Plan for request quotas, HTTP 429 responses, retry headers, bounded exponential backoff, and controlled concurrency. Collection endpoints may require pagination until no further page is available.
Asynchronous reports
Store report or operation identifiers, poll with timeouts and retry limits, and route failed or expired operations to an error path. Limit concurrent report polling.
Dates and reconciliation
Retain reporting windows, account time zones, attribution windows, currency, and response metadata. Account for reporting refresh delays and late-arriving conversions.
Idempotency and partial failure
Use stable external identifiers and deterministic keys for audience uploads, conversion submissions, product updates, and report loads. Capture item-level failures so successful items are not resubmitted.
Schema and version changes
Criteo resources and fields can differ by product and API version. Validate response schemas, monitor deprecation notices, and test changes before production deployment.
Why use Martini instead of scripts or point-to-point integrations?
Reusable integration logic
Martini separates OAuth authentication, Criteo API calls, report polling, mappings, business rules, and error handling into maintainable workflows and reusable implementation assets.
Reliable orchestration
Instead of maintaining isolated scripts, teams can coordinate scheduled synchronization, asynchronous report processing, retries, checkpoints, and target-system writes in a governed integration flow.
Controlled data contracts
Martini can normalize Criteo JSON into canonical models, expose a controlled internal REST API, and apply validation, privacy, idempotency, and account-scoping rules before data reaches other applications.
Operational visibility
Centralized workflow behavior makes failures, throttling, partial results, and schema changes easier to monitor and troubleshoot than point-to-point scripts.
Frequently asked questions
Criteo is integrated primarily through REST APIs for its Marketing Solutions and Retail Media products. Enterprise workflows can authenticate with OAuth 2.0, retrieve Campaigns, Ad sets, Audiences, Retailers, and Reports, submit supported audience or conversion operations, and poll asynchronous report requests. Available resources depend on the Criteo product, account permissions, and API version.
Yes. Martini can integrate with Criteo by consuming its documented REST APIs, handling OAuth 2.0 authentication, orchestrating scheduled synchronization and asynchronous reporting, mapping JSON data, and writing results to enterprise applications or data platforms. No native Martini Criteo connector is documented in the supplied sources.
No. A dedicated Criteo connector is not required. Martini can use Criteo’s confirmed native integration mechanisms, primarily REST APIs and OAuth 2.0, with scheduled polling for changes and report completion where a general webhook mechanism is not available.
Lonti does not charge an additional per-connector or per-vendor fee to integrate Criteo. The integration is subject to the provisioned capacity of the Martini environment. Separate costs may apply from Criteo, cloud infrastructure, or other third-party systems depending on subscription, usage, and deployment model.
REST APIs should be treated as the primary method for Criteo Marketing Solutions and Retail Media integrations. OAuth 2.0 is used for authentication, while reporting and selected data operations may be asynchronous or bulk-oriented. No official Criteo GraphQL or SOAP API was confirmed, and file-oriented processes should be treated as resource-specific.
A universal Criteo webhook or outbound callback framework was not confirmed. Integrations should generally use scheduled polling for campaign, audience, and reporting changes and status polling for asynchronous operations. A specific callback should only be used after it is verified for the applicable Criteo product and account.
Martini can run scheduled workflows that authenticate, retrieve paginated resources or bounded report windows, transform the data, and write it to a target system. Report workflows can submit a request, poll until completion, and load the result. Checkpoints, deterministic keys, time-zone rules, and late-arriving-data handling help maintain reliable synchronization.
Martini can validate payloads, detect throttling such as HTTP 429 responses, apply bounded exponential backoff, and route failed operations to controlled error paths. Stable external identifiers and a processing ledger support idempotent report loads, audience submissions, conversion operations, and product updates. Partial failures can be retained at item level for selective retry.
Related Martini documentation
Criteo APIs
Workflows
Reliability
Connect Criteo with your enterprise systems
Use Martini to build governed Criteo integrations for campaign data, audiences, conversions, retail media products, and asynchronous reporting.