.png)
Tealium Integration Guide
Connect Tealium Customer Data Hub events, audiences, visitor data, and configurations with enterprise applications through REST APIs, event ingestion, and selected outbound HTTP actions.
Tealium integration options at a glance
Tealium provides REST-based APIs and server-side event-ingestion endpoints for Customer Data Hub administration, configuration, event processing, audience operations, and visitor data. Tealium also supports selected outbound HTTP connector actions for configured audience, visitor, or behavioral conditions, although callback coverage depends on the product, connector, trigger, and action. Account- and profile-scoped API keys or tokens protect access. Martini can consume Tealium REST APIs, send normalized event payloads, expose an API for selected callbacks, orchestrate enrichment and reconciliation workflows, and apply validation, retries, deduplication, and environment-specific configuration.
| Integration point | Supported by Tealium? | Common use cases | How Martini supports it |
|---|---|---|---|
| REST APIs | Yes | Tealium REST APIs support administrative operations, configuration, audience and visitor operations, event ingestion, and other Customer Data Hub capabilities. Exact endpoints vary by product. | Martini can consume Tealium REST endpoints, map request and response data, expose reusable APIs, and orchestrate multi-system workflows. |
| Event ingestion | Yes | Collect and server-side ingestion mechanisms accept event attributes, visitor identifiers, account and profile context, data-source identifiers, timestamps, and configured consent information. | Martini can receive application events, validate and normalize them, add environment-specific identifiers, and submit them to Tealium ingestion endpoints. |
| Webhooks / outbound callbacks | Limited | Tealium supports selected outbound HTTP connector actions or notifications for configured audience, visitor, or behavioral conditions. Coverage depends on connector and action configuration. | Martini can expose a REST endpoint, authenticate and validate incoming requests, deduplicate callbacks, and route them to downstream workflows. |
| Audience and visitor activation | Yes | AudienceStream can activate audience membership, visitor attributes, badges, and behavioral conditions through configured connectors and actions. | Martini can receive or retrieve activation data, enrich it with business-system information, apply rules, and forward a normalized payload. |
| Batch and asynchronous processing | Limited | Tealium supports asynchronous event processing and connector execution, but a general-purpose bulk API was not confirmed. | Martini can use scheduler triggers, controlled batching where the endpoint permits it, retries, and checkpoint logic without assuming a Tealium bulk API. |
| Data-access and export capabilities | Limited | Tealium provides data-access and export-oriented capabilities for selected data sets and destinations. Direct database access to Tealium storage was not confirmed. | Martini can consume documented export or destination interfaces and write transformed data to a warehouse or other target system. |
| Authentication | Yes | Tealium uses account- and profile-scoped API keys or tokens depending on the product and endpoint, with permissions or scopes governing operations. | Martini stores credentials in secrets or environment configuration and applies endpoint-specific authorization headers and account configuration. |
| File / attachment APIs | Not confirmed | Tealium is primarily API-, event-, audience-, and connector-oriented; a general-purpose file or attachment API was not confirmed. | Martini can handle files for adjacent systems when required, but the Tealium integration should not assume a native file exchange surface. |
How Tealium exposes data and business events
Tealium REST APIs
Tealium exposes REST-based APIs for administrative operations, configuration, event ingestion, audience and visitor operations, and other Customer Data Hub capabilities. The exact API surface and resource paths depend on the Tealium product and endpoint.
Martini implementation pattern
Martini implementation pattern: a workflow stores account, profile, data-source, and credential configuration in environment settings, calls the required Tealium REST endpoint, validates the response, transforms data, and routes it to the next system or persistence layer.
Implementation sequence
Tealium event ingestion
Tealium Collect and server-side event-processing mechanisms accept event payloads with event attributes, visitor identifiers, account and profile context, data-source identifiers, timestamps, and configured privacy information.
Martini implementation pattern
Martini implementation pattern: an API or workflow trigger receives application activity, validates identity and consent fields, maps the payload to Tealium's expected event structure, and submits it to the documented ingestion endpoint.
Implementation sequence
Tealium outbound HTTP actions
Tealium supports selected outbound HTTP connector actions or notifications when configured audience, visitor, or behavioral conditions occur. This is configuration-dependent and is not universal webhook coverage for every Tealium event.
Martini implementation pattern
Martini implementation pattern: a Martini REST API receives the configured callback, authenticates and validates the request, checks for duplicates, enriches the payload, and invokes downstream APIs or workflows.
Implementation sequence
Tealium data access and exports
Tealium provides data-access and export-oriented capabilities for selected data sets and destinations. Direct database access to Tealium-managed storage was not confirmed.
Martini implementation pattern
Martini implementation pattern: a scheduled workflow retrieves data through a documented Tealium export or destination interface, transforms it into the target model, writes it to a warehouse or application, and persists a watermark for incremental processing.
Implementation sequence
Common Tealium integration patterns
Pattern 1: Send application events to Tealium
When to use this pattern
Use this pattern when website, commerce, CRM, or support activity must be collected by Tealium for audience building, behavioral analysis, or downstream activation. It centralizes validation and identity handling before event submission.
Integration direction
Example Mapping
| Tealium Field | Canonical Field | Target Field |
|---|---|---|
| event_name | event.type | event attribute |
| customer_id | identity.customerId | visitor identifier |
| occurred_at | event.timestamp | event timestamp |
| source_system | event.source | data-source context |
Martini implementation pattern
A Martini API or workflow trigger receives the source event, validates required identifiers and consent, maps the payload into Tealium's event structure, and submits it to the documented ingestion endpoint. The workflow applies deterministic event IDs, retries transient failures, and routes invalid payloads to an error process.
Martini capabilities used
- APIs
- workflows
- data mapping
- business rules
- secrets management
- error handling
Pattern 2: Activate Tealium audiences in Salesforce
When to use this pattern
Use this pattern when audience entry or exit should update Salesforce campaign membership, account context, or another approved customer object. It is suitable for selected Tealium connector actions or scheduled reconciliation.
Integration direction
Example Mapping
| Tealium Field | Canonical Field | Target Field |
|---|---|---|
| audience_id | audience.id | Campaign.Id |
| visitor_id | customer.externalId | Contact.External_Id__c |
| membership_status | audience.membershipStatus | CampaignMember.Status |
| event_timestamp | activation.occurredAt | Last_Activation__c |
Martini implementation pattern
Martini receives a configured Tealium HTTP action or retrieves applicable audience data, validates the audience and identity, enriches missing Salesforce context, and calls Salesforce APIs. Idempotency keys prevent duplicate updates, while authorization and validation failures are separated from retryable network errors.
Martini capabilities used
- REST APIs
- REST API exposure
- workflow orchestration
- data mapping
- enrichment
- deduplication
- retry handling
Pattern 3: Enrich Tealium activations with business data
When to use this pattern
Use this pattern when Tealium audience or visitor activity must be enriched with account tier, renewal status, region, product ownership, or support status before activation in another system.
Integration direction
Example Mapping
| Tealium Field | Canonical Field | Target Field |
|---|---|---|
| visitor_id | customer.externalId | Account.External_Id__c |
| audience_membership | customer.segment | ServiceNow customer segment |
| account_tier | customer.accountTier | priority or routing attribute |
| support_status | customer.supportStatus | task context |
Martini implementation pattern
A Martini workflow receives a selected Tealium activation, queries Salesforce or another system of record, applies privacy and eligibility rules, and sends only the required enriched fields to the target API. The workflow records source and target identifiers so repeat callbacks do not create duplicate actions.
Martini capabilities used
- workflow orchestration
- API consumption
- data enrichment
- business rules
- privacy filtering
- error handling
Pattern 4: Reconcile Tealium audiences and customer data
When to use this pattern
Use this pattern for periodic validation of audience memberships, visitor attributes, or activation results when event delivery may be asynchronous or when operational teams need a repeatable reconciliation process.
Integration direction
Example Mapping
| Tealium Field | Canonical Field | Target Field |
|---|---|---|
| audience_id | segment.id | segment identifier |
| visitor_id | customer.externalId | customer key |
| membership_status | segment.status | membership state |
| updated_at | source.updatedAt | last synchronized time |
Martini implementation pattern
A scheduler-triggered Martini workflow retrieves supported Tealium data and corresponding target data, compares state using a checkpoint or watermark, and applies only required changes. Pagination, controlled concurrency, retry backoff, and an exception report make the process suitable for recurring reconciliation.
Martini capabilities used
- scheduled workflows
- API consumption
- checkpointing
- mapping and transformation
- comparison rules
- monitoring
- retry handling
Applications commonly integrated with Tealium
Tealium commonly participates in customer-data collection, audience activation, enrichment, advertising, analytics, and engagement architectures. The applications below represent practical integration targets; exact object, action, and field coverage should be verified for the selected Tealium product, destination, and API.
| Application | Scenario | Direction | Martini Pattern |
|---|---|---|---|
| Salesforce | Synchronize account, lead, campaign, opportunity, and customer context with Tealium audiences and visitor profiles. | Salesforce → Martini → Tealium | Martini consumes Salesforce APIs or receives application events, maps customer and behavioral attributes into Tealium event structures, and submits them through the documented ingestion endpoint. A reverse workflow can receive selected Tealium audience actions and update Salesforce campaign or customer data with validation and deduplication. |
| Adobe Experience Platform | Exchange customer, identity, and audience information across customer-data and activation services. | Adobe Experience Platform → Martini → Tealium | Martini normalizes identity and audience payloads between the platforms, applies consent and field-selection rules, and calls the relevant APIs or configured Tealium destination mechanism. Checkpointed workflows can reconcile changes without assuming direct database access. |
| Google Ads | Activate Tealium audiences and support conversion or customer-event flows for advertising operations. | Tealium → Martini → Google Ads | Martini receives selected Tealium audience activation data or retrieves applicable data, validates consent and identifiers, then calls Google Ads APIs or a configured destination interface. Failed activations can be retried separately from invalid audience or authorization errors. |
| Meta Ads | Send audience segments or conversion events to Meta advertising services. | Tealium → Martini → Meta Ads | A Martini workflow accepts configured Tealium activation actions, maps audience and event fields to the Meta interface, filters sensitive attributes, and records an idempotency key before submission. Destination responses are logged for operational review. |
| Snowflake | Export customer, event, and audience data for analytics, modeling, and reporting. | Tealium → Martini → Snowflake | Martini retrieves or receives data through Tealium's documented export, data-access, or destination mechanism, transforms event and visitor attributes into warehouse-ready structures, and writes them through the Snowflake interface. The workflow stores a watermark for incremental processing. |
| ServiceNow | Use customer and behavioral signals to create service tasks, update customer context, or support routing decisions. | Tealium → Martini → ServiceNow | Martini receives a selected Tealium HTTP connector action, validates and enriches the payload, then calls ServiceNow APIs to create or update the appropriate task or customer context. Business rules prevent duplicate tasks and route permanent failures for review. |
| Shopify | Send commerce events, orders, and customer activity to Tealium for audience building and activation. | Shopify → Martini → Tealium | Martini consumes Shopify events or APIs, maps order and customer attributes to Tealium event and identity fields, applies consent rules, and submits the normalized payload to Tealium ingestion. Scheduled reconciliation can identify missed events. |
| Braze | Synchronize customer attributes, behavioral events, and audiences for lifecycle messaging and engagement. | Tealium → Martini → Braze | Martini transforms Tealium audience or visitor activation data into Braze API payloads, enriches records when required, and applies audience eligibility and consent rules. Retries and deduplication are handled at the workflow boundary. |
How to build a Tealium integration in Martini
Objective
Configure the Tealium account, profile, data-source identifiers, endpoint settings, and credentials without embedding environment-specific secrets in workflow logic.
Instructions in Martini
- Create environment configuration for account, profile, data-source, and endpoint values
- Store API keys or tokens in Martini secrets
- Confirm the Tealium credential has the required account and profile permissions
- Use the endpoint-specific authorization format documented by Tealium
Objective
Select an API, application event, Tealium HTTP action, or scheduler trigger that matches the required integration direction and latency.
Instructions in Martini
- Use an API trigger for application event ingestion
- Expose a Martini REST API for selected Tealium callbacks
- Use a scheduler for reconciliation and export workflows
- Document whether the flow is real-time, asynchronous, or periodic
Objective
Acquire Tealium events, audiences, visitors, attributes, configuration data, or export data through the confirmed interface.
Instructions in Martini
- Validate incoming payload structure and source identity
- Call the documented Tealium REST or export endpoint where retrieval is required
- Handle pagination or continuation requirements confirmed for the endpoint
- Capture source identifiers and timestamps
Objective
Coordinate validation, enrichment, transformation, target calls, checkpoints, and exception handling as one maintainable Martini workflow.
Instructions in Martini
- Route events according to source, audience, or business condition
- Call Salesforce, ServiceNow, warehouse, advertising, or engagement APIs when required
- Separate transient failures from permanent validation and authorization errors
- Persist processing state for recurring synchronization
Objective
Convert Tealium event, visitor, audience, and attribute structures into canonical and target-specific models.
Instructions in Martini
- Define required event and visitor identifiers
- Normalize timestamps, data types, nulls, and attribute names
- Filter fields according to consent and data-minimization rules
- Create deterministic event or idempotency keys
Objective
Ensure only eligible, authorized, and non-duplicate data is sent to Tealium or downstream systems.
Instructions in Martini
- Check audience membership and activation conditions
- Apply identity-resolution and consent rules
- Prevent duplicate updates and repeated downstream tasks
- Reject unsupported or incomplete payloads with an actionable error
Common Tealium data objects used in integrations
| Object | Typical Use | Common target systems | Martini handling |
|---|---|---|---|
| Accounts | Top-level customer containers that own profiles, users, permissions, and configuration. | Identity administration, configuration repositories, governance systems | Martini keeps account identifiers in environment configuration and uses account-scoped credentials and permissions when calling Tealium APIs. |
| Profiles | Tealium environments or data configurations containing tags, extensions, data sources, audiences, and connectors. | Configuration management, deployment processes, customer-data platforms | Martini parameterizes profile identifiers, validates profile-specific mappings, and separates non-production and production workflows. |
| Events | Customer or behavioral activity containing attributes, visitor identifiers, timestamps, and source context. | Tealium ingestion, CRM, commerce, analytics, engagement platforms | Martini validates, enriches, transforms, and submits events while applying consent, identity, deduplication, and retry rules. |
| Visitors | AudienceStream customer or visitor profiles containing known attributes, behavioral attributes, badges, and audience memberships. | CRM, customer-data platforms, service platforms, analytics warehouses | Martini retrieves or receives visitor-related data where supported, minimizes fields, maps attributes, and synchronizes approved values. |
| Audiences | Segments defined from visitor attributes and behavioral conditions for activation or analysis. | Salesforce, Google Ads, Meta Ads, Braze, service platforms | Martini processes selected audience activations, enriches memberships, maps them to target objects, and records processing state. |
| Attributes | Event and visitor data points, including enrichments and behavioral counters. | CRM, advertising, analytics, marketing, data warehouse systems | Martini applies canonical mappings, data-type validation, consent filtering, and target-specific transformations. |
Authentication and security considerations
Account and profile access
Tealium credentials are commonly scoped to an account and profile, with permissions determining which resources and operations are available. Account, profile, and data-source identifiers should be environment-specific configuration rather than hard-coded workflow values.
Secrets and authorization
Store Tealium API keys or tokens in Martini secrets or secure environment configuration. The exact authorization header and credential format depend on the Tealium product and endpoint, so each API should be configured from its current requirements.
Privacy and identity
- Define the authoritative visitor or customer identifier.
- Apply consent, regional privacy, retention, and deletion requirements.
- Minimize visitor and behavioral attributes sent to downstream systems.
- Protect sensitive identifiers and use hashing where the integration requires it.
Operational considerations for Tealium integrations
Limits and pagination
Check limits for Tealium APIs, ingestion endpoints, connectors, and downstream destinations. For collection APIs, confirm page size, cursor or offset behavior, updated-since filters, and continuation rules before implementing checkpoints.
Reliability and idempotency
Use stable event, action, transaction, or source identifiers when available. Martini workflows can apply controlled concurrency, retry backoff, checkpointing, and deduplication while separating transient failures from invalid schemas and insufficient permissions.
Schema and configuration change
Tealium profiles, attributes, audiences, connectors, and actions may change independently of Martini workflows. Version mappings, test against a non-production profile, and monitor response bodies and request identifiers where available.
Testing and monitoring
Test event schemas, identity resolution, consent behavior, audience entry and exit, callback redelivery, and target-side failure handling. Monitor workflow logs and maintain an operational route for failed payloads and reconciliation exceptions.
Why use Martini instead of scripts or point-to-point integrations?
Reusable integration workflows
Scripts often combine authentication, mapping, retries, and target-specific logic in one codebase. Martini separates these concerns into reusable workflows, APIs, configuration, mappings, and business rules that can be promoted across environments.
Controlled orchestration
Martini can receive application events, consume Tealium APIs, expose callback endpoints, enrich data from enterprise systems, and route results to multiple targets in a single governed flow.
Operational resilience
Validation, error handling, deduplication, checkpoints, and monitoring can be designed into the integration rather than added as separate operational scripts. This supports maintainable event-driven and scheduled synchronization.
Frequently asked questions
Tealium can be integrated through its REST APIs, Collect and server-side event-ingestion mechanisms, selected outbound HTTP connector actions, and documented data-access or export capabilities. Enterprise workflows typically send normalized events to Tealium, receive configured audience activations, or reconcile Tealium data with CRM, advertising, warehouse, and engagement platforms.
Yes. Martini can consume Tealium REST APIs, submit event payloads to documented Tealium ingestion endpoints, expose a REST API for selected Tealium HTTP callbacks, and orchestrate enrichment, synchronization, validation, retries, and downstream API calls.
No. A dedicated Tealium connector is not required. Martini can integrate using Tealium's confirmed REST APIs, event-ingestion endpoints, account- and profile-scoped authentication, and selected outbound HTTP callback mechanisms.
Lonti does not charge an additional per-connector or per-vendor fee to integrate Tealium. The integration is subject to the provisioned capacity of the Martini environment. Separate costs may apply from Tealium, cloud infrastructure, downstream applications, or other third-party services depending on subscriptions, usage, and deployment model.
REST APIs and documented event-ingestion endpoints are the primary methods for new integrations. Selected outbound HTTP connector actions can support activation callbacks, while data-access or export mechanisms can support specific synchronization needs. A general-purpose bulk API, GraphQL API, SOAP API, or file API was not confirmed.
Tealium supports selected outbound HTTP connector actions or notifications for configured audience, visitor, or behavioral conditions. Coverage depends on the product, connector, trigger, action, and available fields; it should not be described as universal webhook coverage for every Tealium event.
Synchronization can be event-driven through Tealium ingestion or selected activation callbacks, or scheduled through REST and export-oriented interfaces. Martini can use checkpoints, pagination where supported, identity mapping, consent filtering, comparison rules, and idempotency keys to reconcile audiences, visitors, events, and attributes.
Martini maps Tealium Events, Visitors, Audiences, Attributes, and related identifiers into canonical and target-specific models. Workflows can normalize data types and timestamps, enrich data from systems such as Salesforce or ServiceNow, apply business rules, and filter fields according to consent and privacy requirements.
Martini can separate transient network or service failures from permanent validation and authorization errors, retry transient failures with controlled backoff, and route unrecoverable payloads for review. Stable event or action identifiers, deterministic keys, and persisted deduplication state help prevent duplicate downstream updates.
Yes. Martini can expose a REST API that accepts application events or selected Tealium HTTP connector callbacks, validates and normalizes the payload, applies business rules, and forwards it to Tealium or downstream systems. This provides a controlled integration boundary without requiring every client to implement Tealium-specific details.
Related Martini documentation
APIs
Workflows
Build a Tealium integration with Martini
Use Martini to connect Tealium APIs, event ingestion, and selected outbound HTTP actions with the enterprise systems that depend on customer, audience, and behavioral data.