.png)
Iterable Integration Guide
Connect Iterable with enterprise systems through REST APIs, bulk operations, scheduled workflows, and selected webhook notifications.
Iterable integration options at a glance
Iterable’s primary integration interface is its versioned REST API for Users, Events, Catalog Items, Campaigns, Templates, Lists, subscriptions, and related resources. Selected user and catalog operations support bulk or asynchronous processing. Iterable also provides webhook-style outbound notifications for selected events, although coverage is not universal across every object or state change. API-key authentication uses the Api-Key header, with permissions determined by project and key type. Martini can consume these APIs, expose endpoints for supported webhook notifications, schedule synchronization workflows, transform payloads, apply consent and identity rules, and manage retries, pagination, throttling, and partial bulk failures.
| Integration point | Supported by Iterable? | Common use cases | How Martini supports it |
|---|---|---|---|
| REST APIs | Yes | Create and update Users, send Events, manage Catalog Items, and retrieve Campaigns, Templates, Lists, subscriptions, and related project data. | Martini can consume Iterable REST endpoints from workflows, map request and response data, apply business rules, and expose reusable integration APIs. |
| Webhooks / outbound callbacks | Limited | Deliver selected Iterable events and platform notifications to external HTTPS endpoints. Coverage is not universal across objects or state changes. | Martini can expose a REST endpoint or consume webhook requests through a workflow, validate the sender, apply idempotency, and acknowledge requests promptly. |
| Bulk / async / batch APIs | Yes | Process larger User or Catalog Item synchronizations through bulk-oriented operations, including accepted, queued, or partially failed requests. | Martini can submit batches, persist job or result references where available, inspect item-level failures, and retry safe transient failures. |
| Authentication | Yes | Authenticate general REST API requests with API keys passed through the Api-Key HTTP header. Key type and permissions depend on the operation and project. | Martini can store API keys in secrets or environment configuration and apply them to outbound API requests without embedding credentials in workflows. |
| Events APIs | Yes | Send behavioral or transactional activity such as purchases, signups, product views, renewals, and other application events. | Martini can normalize event names, identifiers, timestamps, values, and properties before calling Iterable event endpoints. |
| File / attachment APIs | Limited | Support selected messaging and data-import file behaviors, but not general-purpose file or attachment exchange across all use cases. | Martini can implement a confirmed endpoint-specific file flow, while treating unsupported or ambiguous file synchronization as a design constraint. |
| SDKs | Limited | Support selected application, mobile, in-app, and event-collection scenarios. Server-to-server synchronization is generally better suited to the REST API. | Martini can orchestrate server-side integrations around API calls; application teams can use Iterable SDKs where client-side collection or messaging is required. |
| GraphQL APIs | Not confirmed | No official general-purpose Iterable GraphQL interface was identified in the supplied research. | Martini integrations should use the confirmed Iterable REST APIs and selected webhook mechanisms instead of assuming GraphQL availability. |
How Iterable exposes data and business events
Iterable REST APIs
Iterable’s versioned REST API is the principal server-to-server integration interface. It covers Users, Events, Catalog Items, Campaigns, Templates, Lists, subscriptions, and other project resources, with ordinary and selected bulk operations.
Martini implementation pattern
Martini implementation pattern: a workflow authenticates with an Iterable API key stored as a secret, calls the relevant endpoint, validates the response, transforms data for downstream systems, and persists checkpoints or business identifiers for recovery.
Implementation sequence
Iterable Events APIs
Iterable Events APIs accept behavioral and transactional activity, including purchases, signups, product views, renewals, and application events. Event naming and user identity must be defined consistently.
Martini implementation pattern
Martini implementation pattern: the workflow receives an upstream event, normalizes the event name, user identifier, timestamp, monetary values, and properties, then submits the Iterable event and records the source event key for deduplication.
Implementation sequence
Iterable Webhooks
Iterable supports webhook-style outbound delivery for selected events and notifications. This is a limited notification mechanism rather than universal change-data capture for every Iterable object or state change.
Martini implementation pattern
Martini implementation pattern: Martini exposes a REST API endpoint, validates the inbound request and available authentication details, applies replay protection and idempotency, acknowledges quickly, and routes longer processing into a workflow for downstream updates.
Implementation sequence
Iterable Bulk and asynchronous operations
Iterable provides bulk-oriented REST operations for selected domains, particularly Users and Catalog Items. Requests may be synchronous, accepted for later processing, or partially unsuccessful.
Martini implementation pattern
Martini implementation pattern: Martini partitions source data into appropriate batches, submits the supported bulk request, stores any job or result reference, retrieves status where required, and separates item-level failures from transport failures.
Implementation sequence
Common Iterable integration patterns
Pattern 1: Synchronize CRM audiences to Iterable Users
When to use this pattern
Use this pattern when Salesforce, HubSpot, or another customer system owns profile and audience data that must be reflected in Iterable. It is appropriate for scheduled incremental synchronization with explicit identity, consent, subscription, and field-ownership rules.
Integration direction
Example Mapping
| Iterable Field | Canonical Field | Target Field |
|---|---|---|
| Contact.Email | user.email | |
| Contact.FirstName | user.firstName | dataFields.firstName |
| Contact.MarketingConsent | consent.marketing | subscription or consent fields |
Martini implementation pattern
A scheduled Martini workflow reads changed CRM records, resolves the Iterable user key, maps profile and consent fields, applies suppression and ownership rules, and calls the Iterable Users REST endpoint. It persists a high-water mark, throttles requests, retries transient failures, and routes invalid profiles to an exception path.
Martini capabilities used
- scheduled workflows
- API consumption
- data mapping
- business rules
- secrets management
- error handling
Pattern 2: Send commerce activity as Iterable Events
When to use this pattern
Use this pattern when Shopify, NetSuite, or another commerce source produces orders, fulfillment changes, abandoned carts, product views, or subscription renewals that should drive Iterable messaging.
Integration direction
Example Mapping
| Iterable Field | Canonical Field | Target Field |
|---|---|---|
| Order.id | event.orderId | dataFields.orderId |
| Order.totalPrice | event.amount | dataFields.totalPrice |
| Customer.email | user.email | |
| Order.createdAt | event.occurredAt | createdAt |
Martini implementation pattern
Martini receives or retrieves the commerce event, normalizes identifiers and timestamps, maps product and monetary properties, applies event naming and consent rules, and submits the Iterable Event. Stable source event identifiers support deduplication, while retry logic distinguishes safe transport retries from permanent validation errors.
Martini capabilities used
- workflow triggers
- REST API consumption
- data transformation
- validation
- idempotency
- retry handling
Pattern 3: Route Iterable webhook notifications to operational systems
When to use this pattern
Use this pattern when selected Iterable webhook notifications must update a CRM, operational database, warehouse, support platform, or downstream workflow. Confirm that the required notification type is supported before designing the flow around it.
Integration direction
Example Mapping
| Iterable Field | Canonical Field | Target Field |
|---|---|---|
| webhook.userEmail | customer.email | Contact.Email |
| webhook.eventType | engagement.type | Engagement.Type |
| webhook.timestamp | engagement.occurredAt | Engagement.ActivityDate |
Martini implementation pattern
Martini exposes a controlled REST endpoint for the supported Iterable notification, authenticates and validates the request, checks replay keys, and returns a timely response. A workflow then transforms the payload, applies routing rules, writes the downstream update, and records failures for controlled replay.
Martini capabilities used
- REST API creation
- webhook consumption
- workflow orchestration
- data mapping
- business rules
- error handling
Pattern 4: Synchronize product data to Iterable Catalog Items
When to use this pattern
Use this pattern when a commerce platform, PIM, NetSuite, or internal database owns product or content data used for personalization and campaign targeting in Iterable.
Integration direction
Example Mapping
| Iterable Field | Canonical Field | Target Field |
|---|---|---|
| Product.id | catalog.externalId | Catalog Item id |
| Product.title | catalog.name | Catalog Item name |
| Product.price | catalog.price | Catalog Item price |
| Product.available | catalog.availability | Catalog Item availability |
Martini implementation pattern
A scheduled or event-driven Martini workflow retrieves changed products, validates required catalog attributes, maps product identifiers and personalization fields, and submits individual or supported bulk Catalog Item updates. It tracks batch results, retries transient failures, and routes schema or validation errors separately.
Martini capabilities used
- scheduler triggers
- workflow orchestration
- bulk API consumption
- mapping and transformation
- validation
- monitoring and recovery
Applications commonly integrated with Iterable
Iterable is commonly connected to customer, commerce, analytics, and operational platforms to coordinate audience data, behavioral events, product information, and engagement outcomes. The exact direction and ownership of profile, consent, and subscription data should be defined for each implementation.
| Application | Scenario | Direction | Martini Pattern |
|---|---|---|---|
| Salesforce | Synchronize Contacts, Leads, audiences, consent information, and engagement outcomes between the CRM and Iterable. | Salesforce → Martini → Iterable | A scheduled Martini workflow retrieves changed Salesforce records, maps identity and consent fields to Iterable Users, submits REST updates, and routes validation failures for review. A separate inbound flow can route selected Iterable engagement notifications back to Salesforce. |
| Segment | Route behavioral events and user traits through a centralized customer-data collection layer into Iterable. | Segment → Martini → Iterable | Martini receives or consumes normalized Segment payloads, validates user identifiers and event names, transforms timestamps and properties, and calls Iterable Events or user endpoints with controlled retries. |
| Shopify | Send customer, product, order, and browsing activity to Iterable for lifecycle and commerce messaging. | Shopify → Martini → Iterable | Martini consumes Shopify events or APIs, normalizes customer and product identifiers, maps commerce activity into Iterable Events and Catalog Items, and applies deduplication and retry rules. |
| Snowflake | Combine Iterable engagement and customer data with warehouse analytics, attribution, segmentation, and reporting. | Iterable → Martini → Snowflake | Martini retrieves available Iterable data through documented APIs or approved export mechanisms, transforms it into warehouse-ready structures, and writes batches to Snowflake while recording checkpoints and rejected rows. |
| Zendesk | Coordinate marketing communication with support status, customer attributes, and service interactions. | Zendesk → Martini → Iterable | A Martini workflow reads relevant Zendesk changes, applies consent and audience rules, maps customer attributes or events, and sends approved updates to Iterable. Selected Iterable notifications can be routed back to operational records. |
| NetSuite | Combine order, subscription, or customer information with Iterable lifecycle campaigns. | NetSuite → Martini → Iterable | Martini retrieves changed NetSuite customer or transaction data, maps identifiers and event values to Iterable Users or Events, submits REST requests, and separates permanent validation errors from retryable failures. |
| HubSpot | Synchronize marketing contacts, lifecycle stages, and engagement data where HubSpot and Iterable coexist. | HubSpot → Martini → Iterable | Martini orchestrates scheduled or event-driven flows between HubSpot and Iterable, with explicit ownership rules for contact identity, consent, subscription preferences, and campaign attributes. |
| ServiceNow | Use service workflows to trigger customer or employee communications and route selected engagement outcomes into operational processes. | ServiceNow → Martini → Iterable | Martini consumes relevant ServiceNow API data, applies audience and privacy rules, sends Iterable Events or User updates, and can route supported Iterable webhook notifications back into ServiceNow workflows. |
How to build a Iterable integration in Martini
Objective
Establish the Iterable connection using a project-appropriate API key and keep credentials outside workflow definitions.
Instructions in Martini
- Store the Iterable API key in Martini secrets or environment configuration.
- Use separate keys for development, testing, and production.
- Apply the minimum permissions required by the selected endpoints.
- Configure the target system credentials using the same secure pattern.
Objective
Select a schedule, inbound API request, source-system event, or supported Iterable webhook notification based on the synchronization requirement.
Instructions in Martini
- Use a scheduler for incremental Users or Catalog Items synchronization.
- Use an API or event trigger for near-real-time commerce activity.
- Expose a Martini REST endpoint for supported Iterable webhook notifications.
- Define a persisted cursor, timestamp, or last-processed identifier where applicable.
Objective
Read source records or receive the Iterable payload while handling pagination, accepted bulk requests, and endpoint-specific response behavior.
Instructions in Martini
- Treat list and search responses as paginated unless documented otherwise.
- Use bulk operations for supported large User or Catalog Item workloads.
- Persist pagination markers, job identifiers, or high-water marks.
- Separate source retrieval failures from data validation failures.
Objective
Coordinate API calls, transformations, routing, enrichment, and state management in a maintainable Martini workflow.
Instructions in Martini
- Call the appropriate Iterable REST endpoint or downstream API.
- Apply conditional routing for consent, suppression, ownership, and object type.
- Use reusable workflow logic for common authentication, validation, and error paths.
- Keep lengthy webhook processing asynchronous when appropriate.
Objective
Convert source payloads into Iterable Users, Events, Catalog Items, Campaigns, Templates, or Lists while preserving business meaning.
Instructions in Martini
- Normalize email addresses, identifiers, timestamps, and numeric values.
- Map consent and subscription categories explicitly.
- Use controlled event names and versioned mappings.
- Validate required and nested fields before making API requests.
Objective
Prevent unintended profile changes, duplicate actions, invalid audience membership, and accidental resubscription.
Instructions in Martini
- Define the system of record for identity, consent, subscriptions, and profile attributes.
- Use stable external identifiers and source event keys.
- Apply suppression and privacy rules before sending data.
- Route permanent authorization and validation errors without indefinite retries.
Common Iterable data objects used in integrations
| Object | Typical Use | Common target systems | Martini handling |
|---|---|---|---|
| Users | Store profiles identified by email address or another configured identifier, including attributes, consent, subscriptions, and associated activity. | Salesforce, HubSpot, Zendesk, Shopify, NetSuite | Martini maps identity, profile, consent, and subscription fields, applies ownership rules, and sends create or update requests with validation and deduplication. |
| Events | Represent behavioral or transactional activity such as purchases, signups, product views, renewals, and application events. | Shopify, Segment, NetSuite, Salesforce, Snowflake | Martini normalizes event names, timestamps, identifiers, monetary values, and properties before submitting REST requests and recording source event keys. |
| Catalog Items | Represent products, content, or other items used for personalization and campaign targeting. | Shopify, NetSuite, product information systems, internal databases | Martini maps item identifiers, names, URLs, prices, availability, categories, and custom attributes, using individual or supported bulk updates. |
| Campaigns | Represent marketing campaigns used to deliver messages across supported channels and retrieve campaign-related information. | Salesforce, Snowflake, customer analytics platforms | Martini retrieves relevant campaign data, maps campaign identifiers and statuses, and routes selected information to downstream reporting or CRM workflows. |
| Templates | Provide reusable message content for email and other supported messaging channels. | Snowflake, Salesforce, content or governance repositories | Martini can retrieve or coordinate template metadata through REST endpoints and apply validation or reporting rules without assuming direct content ownership. |
| Lists | Group Users for segmentation, subscription management, and campaign targeting. | Salesforce, HubSpot, Snowflake, customer data platforms | Martini synchronizes list membership where required, applies consent and suppression rules, and records rejected or conflicting membership updates. |
Authentication and security considerations
API-key authentication
Iterable’s standard REST API authentication uses API keys passed in the Api-Key HTTP header. Server-side, user, and management key types may have different scope and permissions.
Secret management
Store Iterable keys in Martini secrets or environment configuration rather than workflow definitions. Use separate credentials for development, testing, and production.
Least privilege and privacy
- Use the minimum permissions required for each project and operation.
- Protect webhook endpoints with the authentication and validation options supported by the selected Iterable feature.
- Minimize personal data and define consent, retention, deletion, and regional processing requirements.
Operational considerations for Iterable integrations
Throttling and pagination
Confirm endpoint-specific rate limits and pagination behavior. Use controlled concurrency, preserve cursors or page markers, and apply exponential backoff for retryable 429 and 5xx responses.
Bulk processing
Use supported bulk operations for larger User and Catalog Item workloads. Track accepted or queued requests, job references, and item-level failures rather than treating acceptance as complete success.
Identity and consent
Define whether email, Iterable user ID, or another identifier is authoritative. Map subscription categories, suppression, and unsubscribe behavior explicitly, and prevent downstream systems from unintentionally resubscribing users.
Reliability and schema control
Use idempotency keys or application-level deduplication for events and webhooks. Version mappings, validate event and catalog schemas, test representative payloads, and monitor latency, errors, throttling, and webhook delivery failures.
Why use Martini instead of scripts or point-to-point integrations?
Orchestration instead of isolated scripts
Martini centralizes Iterable API calls, source-system retrieval, transformations, business rules, and downstream updates in maintainable workflows rather than scattering logic across scripts.
Reusable integration assets
Teams can build reusable API and workflow logic for authentication, pagination, validation, consent handling, retries, and exception routing while adapting mappings for each application.
Operational control
Martini supports scheduled, event-driven, API-led, and asynchronous integration patterns. This makes it easier to persist checkpoints, handle partial bulk failures, protect secrets, and monitor recovery paths as integrations grow.
Frequently asked questions
Iterable can be integrated through its versioned REST APIs for Users, Events, Catalog Items, Campaigns, Templates, Lists, subscriptions, and related resources. Selected user and catalog operations support bulk processing, and Iterable provides webhook-style notifications for selected events and platform notifications. API keys passed in the Api-Key header are the primary general-purpose authentication method.
Yes. Martini can integrate with Iterable by consuming its REST APIs, sending Users and Events, synchronizing Catalog Items, coordinating other documented resources, and receiving supported Iterable webhook notifications through a Martini REST API and workflow. No native Martini Iterable connector is documented in the supplied materials.
No. A dedicated Iterable connector is not required. Martini can use Iterable’s confirmed native REST APIs, bulk operations, API-key authentication, and selected webhook notifications, with workflows handling orchestration, mapping, validation, retries, and downstream delivery.
Lonti does not charge an additional per-connector or per-vendor fee to integrate Iterable. The integration is subject to the provisioned capacity of the Martini environment. Separate costs may apply from Iterable, cloud infrastructure, or other third-party systems depending on subscription, usage, and deployment model.
The recommended general interface is Iterable’s versioned REST API, authenticated with an API key in the Api-Key header. Use Events APIs for behavioral and transactional activity, bulk operations for supported larger User or Catalog Item workloads, and selected webhooks when the required notification type is confirmed. No general-purpose Iterable GraphQL or SOAP API was identified.
Yes, for supported Iterable webhook events and notifications. Martini can expose a REST endpoint, validate the request and available authentication details, apply replay protection and idempotency, acknowledge promptly, and process the notification through a workflow. Webhook coverage is selected rather than universal, so the required event must be confirmed.
Martini can use scheduled polling, source-system events, Iterable Events, and supported webhook notifications depending on the object and direction. Workflows map source data to Iterable Users, Events, Catalog Items, Campaigns, Templates, or Lists, normalize identifiers and timestamps, apply consent and ownership rules, and persist cursors or high-water marks for incremental processing.
Martini workflows can control concurrency, detect throttling and server failures, apply exponential backoff, and retry operations that are safe to repeat. Stable identifiers, source event keys, persisted webhook identifiers, and application-level deduplication help prevent duplicate actions. Permanent validation or authorization failures should be routed to an exception path rather than retried indefinitely.
Related Martini documentation
Workflows
Connect Iterable with your enterprise systems
Use Martini to build reliable Iterable integrations that combine REST APIs, selected webhook notifications, scheduled synchronization, data mapping, and operational error handling.