.png)
Braze Integration Guide
Integrate Braze with enterprise systems through REST APIs, selected campaign webhooks, batch user operations, and supported data exports.
Braze integration options at a glance
Braze’s primary server-to-server integration method is its REST API, which supports user profiles, custom events, purchases, segments, campaigns, Canvases, catalogs, subscription groups, messaging, and selected exports. The /users/track endpoint supports batch submission of attributes, events, and purchases, while larger retrieval operations may be asynchronous or paginated. Braze also supports webhook messaging from selected campaigns and Canvases, and data-export products such as Currents for engagement and behavioral data. Martini can consume these APIs, expose endpoints for supported webhook requests, schedule reconciliation workflows, transform payloads, and apply validation, retry, rate-limit, and idempotency controls.
| Integration point | Supported by Braze? | Common use cases | How Martini supports it |
|---|---|---|---|
| REST APIs | Yes | Create and update user profiles, record custom events and purchases, manage subscription groups, retrieve campaigns, Canvases, segments, catalogs, analytics, and selected exports. | Martini can consume Braze REST endpoints, map request and response data, expose reusable APIs, and orchestrate multi-system workflows. |
| Webhooks / outbound callbacks | Limited | Braze campaigns and Canvases can send HTTP webhook messages containing profile or campaign context to an external endpoint. | Martini can expose a REST API or webhook-receiving workflow, validate the request, enrich it, and route it to downstream systems. This is not a universal event stream for every Braze object. |
| Bulk / async / batch APIs | Limited | The /users/track endpoint accepts batches of attributes, custom events, and purchases; export operations may be asynchronous or return large result sets. | Martini can batch compatible requests, respect endpoint-specific limits, persist export job or continuation state, and retry transient failures. |
| Data export and analytics | Limited | Braze Currents and related export or warehouse capabilities provide engagement and behavioral data for analytics destinations. | Martini can transform exported data, apply business rules, forward it to operational systems, and support reconciliation. This is export access rather than direct database access. |
| Authentication | Yes | Braze REST requests use workspace-specific API keys in a Bearer authorization header, with permissions assigned to API operations and data-center-specific hosts. | Martini stores API keys, cluster hosts, and destination credentials in protected environment configuration and references them from workflows. |
| File / attachment APIs | Not confirmed | Braze does not provide a verified general-purpose file or attachment API for arbitrary business documents; media URLs and hosted assets are distinct from file transfer. | Martini can use another system’s file, object-storage, or REST interface and pass supported URLs or metadata to Braze. |
| GraphQL APIs | Not confirmed | No public Braze GraphQL API was confirmed in the supplied research; Braze’s documented server-to-server model is REST-based. | Martini should use the confirmed Braze REST API rather than assume GraphQL availability. |
| SOAP APIs | No | Braze’s documented server-to-server integration model is REST-based, with no supported SOAP API identified. | Martini should consume Braze REST endpoints or supported webhook and export mechanisms instead. |
How Braze exposes data and business events
Braze REST APIs
Braze REST APIs are the primary server-to-server integration mechanism. They cover user profiles, custom events, purchases, segments, campaigns, Canvases, catalogs, subscription groups, messaging operations, analytics, and selected exports. Availability and permissions vary by workspace and API product area.
Martini implementation pattern
Martini implementation pattern: Martini stores the Braze cluster host and API key as protected configuration, invokes the required REST endpoint, validates responses, maps Braze objects to canonical models, and routes successful and failed operations according to workflow rules.
Implementation sequence
Braze Webhook Messaging
Braze campaigns and Canvases can send webhook messages to an external HTTP endpoint with user profile or campaign context. This capability is selected-use-case messaging rather than a universal webhook stream for all Braze objects.
Martini implementation pattern
Martini implementation pattern: Martini exposes a REST API or webhook-receiving workflow for the agreed Braze campaign request, authenticates and validates the request, enriches it when necessary, and routes the result to enterprise applications or internal services.
Implementation sequence
Braze Batch and Export Operations
The /users/track endpoint accepts batches of user attributes, custom events, and purchases. User and other export operations may be asynchronous or return paginated or large result sets, with limits that vary by endpoint.
Martini implementation pattern
Martini implementation pattern: Martini groups compatible changes, submits bounded batches, tracks export jobs or continuation state, and performs scheduled reconciliation without assuming that one response contains the complete dataset.
Implementation sequence
Braze Currents and Data Exports
Braze Currents and related export or warehouse capabilities provide engagement and behavioral data for supported destinations. These products provide export access rather than direct access to Braze’s internal operational database.
Martini implementation pattern
Martini implementation pattern: Martini consumes exported data from the configured delivery path or destination, validates event structure, maps engagement records to a canonical model, and forwards selected records to analytics or operational systems.
Implementation sequence
Common Braze integration patterns
Pattern 1: Synchronize customer profiles and purchases to Braze
When to use this pattern
Use this pattern when Salesforce, Shopify, or another source system owns customer and transaction data that must support Braze personalization and lifecycle messaging. The workflow sends only eligible changes where possible and preserves stable identity and transaction timestamps.
Integration direction
Example Mapping
| Braze Field | Canonical Field | Target Field |
|---|---|---|
| customer.id | customer.externalId | external_id |
| customer.email | customer.email | |
| customer.lifecycleStatus | customer.lifecycleStatus | custom_attributes.lifecycle_status |
| order.total | purchase.amount | purchases.price |
Martini implementation pattern
A scheduled or event-triggered Martini workflow retrieves changed customers and orders, resolves the Braze external ID, separates profile updates from purchases, validates required values, and submits compatible changes through /users/track. The workflow records source identifiers, applies bounded retries for transient failures, and sends invalid or repeatedly failed data to reconciliation handling.
Martini capabilities used
- workflows
- API consumption
- scheduled workflows
- data mapping
- validation
- business rules
- error handling
Pattern 2: Send product and order events to Braze
When to use this pattern
Use this pattern when an application, commerce platform, or ERP generates product views, registrations, fulfillment changes, subscription events, or purchases that should influence Braze campaigns and Canvases.
Integration direction
Example Mapping
| Braze Field | Canonical Field | Target Field |
|---|---|---|
| order.id | transaction.sourceId | purchase.product_id or event.properties.order_id |
| order.createdAt | event.occurredAt | time |
| order.currency | purchase.currency | currency |
| order.status | order.lifecycleStatus | custom_event.order_status |
Martini implementation pattern
Martini receives or retrieves source events, normalizes event names and timestamps, resolves the user identity, and transforms each event or purchase into the Braze request model. It batches compatible submissions, applies rules for event eligibility and consent, and uses deterministic source identifiers and retry controls to reduce duplicate delivery.
Martini capabilities used
- API consumption
- webhook consumption
- data mapping
- JSON handling
- business rules
- batch orchestration
- error handling
Pattern 3: Route Braze campaign webhooks to enterprise applications
When to use this pattern
Use this pattern when a Braze campaign or Canvas must initiate a selected downstream action, such as creating a Salesforce task, notifying an internal service, or starting a support process. It applies only to Braze webhook messaging use cases.
Integration direction
Example Mapping
| Braze Field | Canonical Field | Target Field |
|---|---|---|
| braze.user.external_id | customer.externalId | Account.External_Id__c |
| braze.user.email | customer.email | Contact.Email |
| braze.campaign_id | engagement.campaignId | Task.Description or ticket.metadata.campaign_id |
| braze.canvas_step | journey.step | Task.Subject or ticket.custom_field |
Martini implementation pattern
Martini exposes a secured REST endpoint, validates the webhook structure, acknowledges promptly, and performs enrichment and downstream writes in a workflow. Business rules determine whether to create, update, or ignore the target action. Correlation IDs, idempotency keys, and retry or dead-letter handling support reliable delivery.
Martini capabilities used
- API creation
- webhook consumption
- authentication
- validation
- workflow orchestration
- business rules
- error handling
Pattern 4: Reconcile Braze engagement exports with analytics data
When to use this pattern
Use this pattern when Currents or another supported Braze export must be combined with CRM, transaction, or support data for reporting, operational alerts, or downstream activation.
Integration direction
Example Mapping
| Braze Field | Canonical Field | Target Field |
|---|---|---|
| campaign_id | engagement.campaignId | braze_campaign_id |
| user_id | customer.externalId | customer_external_id |
| event_type | engagement.eventType | engagement_type |
| time | engagement.occurredAt | occurred_at |
Martini implementation pattern
Martini consumes the supported export delivery, validates partitions and schemas, normalizes engagement events, and writes the result to Snowflake, Amazon S3, or another configured destination. Checkpoints, duplicate detection, schema validation, and reconciliation reports handle late, repeated, or incomplete exports.
Martini capabilities used
- scheduled workflows
- data transformation
- file or payload processing
- mapping
- validation
- database or API integration
- monitoring
Applications commonly integrated with Braze
Braze is commonly positioned alongside customer-data, commerce, CRM, support, and analytics platforms. Martini can coordinate these systems when profile, behavioral, transaction, audience, or engagement data needs transformation, validation, routing, or reconciliation.
| Application | Scenario | Direction | Martini Pattern |
|---|---|---|---|
| Salesforce | Synchronize customer profiles, lifecycle attributes, campaign audiences, sales activity, and selected engagement outcomes. | Salesforce → Martini → Braze | A scheduled or event-triggered workflow reads changed Salesforce data, maps stable customer identifiers and attributes to Braze users, and submits updates through the REST API. A separate Braze webhook workflow can route selected campaign outcomes back to Salesforce with validation and retry handling. |
| Segment | Forward customer traits and behavioral events to Braze while applying enterprise-specific transformation and governance. | Segment → Martini → Braze | Martini receives or retrieves Segment payloads, normalizes identity and event fields, validates required values, and submits custom events, attributes, or purchases to Braze in suitable batches. |
| Shopify | Send customer, product, order, and purchase activity to Braze for commerce lifecycle messaging and customer engagement. | Shopify → Martini → Braze | A workflow consumes Shopify changes or scheduled extracts, resolves the Braze external ID, maps order and product data into purchases or custom events, and submits batches through /users/track. Braze campaign webhooks can be routed through Martini for selected downstream actions. |
| Snowflake | Combine Braze engagement and behavioral data with enterprise customer and transaction data for analytics and selected activation workflows. | Braze → Martini → Snowflake | Martini transforms Currents or supported export data into the warehouse model, preserves event timestamps and source identifiers, and can retrieve selected audience or profile data from Snowflake for controlled updates to Braze. |
| Amazon S3 | Retain exported Braze event data or intermediate integration files for processing, retention, and downstream analytics. | Braze → Martini → Amazon S3 | Martini processes supported Braze export deliveries or metadata, validates file content where applicable, and routes normalized data to S3 or other enterprise destinations. S3 data can also be read by scheduled workflows for reconciliation or activation. |
| Zendesk | Combine support activity and customer engagement data, such as sending support status to Braze or creating support follow-up actions from selected journeys. | Zendesk → Martini → Braze | Martini consumes Zendesk API data or Braze webhook requests, applies identity resolution and business rules, then updates Braze profiles or routes selected campaign actions to Zendesk through its API. |
How to build a Braze integration in Martini
Objective
Configure Braze’s workspace-specific REST API host, API key, permissions, and destination credentials without embedding secrets in workflows or source-controlled mappings.
Instructions in Martini
- Store API keys and cluster hosts in protected Martini secrets or environment configuration.
- Confirm the Braze workspace, data center, endpoint permissions, and target environment.
- Use the appropriate authentication model for REST APIs, Currents, or other Braze products.
Objective
Select an event-driven, webhook-driven, API-led, or scheduled trigger based on the synchronization requirement and the Braze capability being used.
Instructions in Martini
- Use a source application event when near-real-time processing is required.
- Expose a Martini REST API for selected Braze campaign or Canvas webhook messages.
- Use scheduled workflows for exports, reconciliation, and incremental synchronization.
Objective
Acquire Braze or source-system data while handling batches, pagination, asynchronous exports, and continuation state.
Instructions in Martini
- Call the required Braze REST endpoint or receive a supported webhook request.
- Persist export job identifiers, cursors, page state, or source checkpoints where applicable.
- Avoid assuming that a single response contains all users, campaigns, segments, or catalog items.
Objective
Coordinate validation, enrichment, transformation, business rules, target writes, and response handling in a maintainable Martini workflow.
Instructions in Martini
- Separate profile updates, custom events, purchases, campaign actions, and export processing where operationally useful.
- Use reusable workflow logic for identity resolution, correlation, and error routing.
- Keep webhook acknowledgements fast when longer downstream processing is required.
Objective
Convert source payloads into Braze user, event, purchase, segment, campaign, Canvas, or catalog representations while preserving business meaning.
Instructions in Martini
- Map stable external IDs and define handling for aliases, anonymous users, and identity changes.
- Normalize field names, data types, event names, timestamps, nulls, and missing values.
- Use bounded batches for compatible /users/track requests.
Objective
Enforce consent, eligibility, routing, deduplication, and schema rules before data is submitted or forwarded.
Instructions in Martini
- Validate required identifiers, campaign context, event timestamps, and permitted attribute values.
- Apply subscription and privacy rules before sending engagement or profile data.
- Use deterministic source identifiers and distinguish transient errors from validation or authorization errors.
Common Braze data objects used in integrations
| Object | Typical Use | Common target systems | Martini handling |
|---|---|---|---|
| Users / user profiles | Store customer identity, attributes, custom data, subscription state, events, and purchases. | Salesforce, Shopify, Segment, Snowflake, Zendesk | Martini resolves stable external IDs or aliases, validates profile fields, maps changed attributes, and submits updates through Braze REST APIs. |
| Custom events | Capture behavioral activity such as product views, registrations, purchases, and application-specific actions. | Segment, Shopify, Salesforce, analytics platforms | Martini normalizes event names and timestamps, preserves source identifiers, applies validation, and sends events directly or in /users/track batches. |
| Purchases | Represent transactions with product identifiers, currency, price, quantity, and purchase time. | Shopify, Salesforce, ERP platforms, Snowflake | Martini converts source order lines and transaction data into Braze purchase payloads and applies duplicate and timestamp controls. |
| Segments | Define audiences using attributes, events, purchases, engagement, and subscription state. | Salesforce, Snowflake, advertising or analytics platforms | Martini retrieves or reconciles segment information through permitted REST operations and maps audience membership to downstream models. |
| Campaigns | Manage messaging programs across email, push, in-app messages, content cards, SMS, WhatsApp, and webhook messages. | Salesforce, Zendesk, internal services, analytics platforms | Martini retrieves campaign data, routes selected campaign results, and receives supported campaign webhook messages through exposed APIs. |
| Canvases | Orchestrate multi-step customer journeys with messages, delays, audience rules, and branching logic. | Salesforce, Zendesk, internal services, analytics platforms | Martini can retrieve Canvas information and process selected Canvas webhook messages, while keeping longer downstream work in asynchronous workflows. |
Authentication and security considerations
Workspace-specific API keys
Braze REST requests use a workspace-specific API key in the Authorization Bearer header. The API host is also data-center or cluster specific, so the host and credential should be configured per environment.
Secrets and permissions
Store Braze API keys and destination credentials in Martini secrets or protected environment configuration. Use the narrowest Braze API-key permissions needed for each workflow, and do not place secrets in mappings, request bodies, source control, or logs.
Webhook protection
For Braze campaign or Canvas webhook messages, secure the Martini endpoint using an agreed authentication mechanism, validate the request structure, and consider gateway or network controls. Log correlation data without exposing API keys or unnecessary personal information.
Operational considerations for Braze integrations
Rate limits and batching
Braze applies endpoint-specific limits. Use bounded concurrency, documented batch sizes, /users/track where appropriate, and exponential backoff for transient responses.
Pagination and exports
List and export operations may be paginated, asynchronous, or large. Persist continuation state and export identifiers rather than assuming one response is complete.
Identity and idempotency
Define the authoritative customer identifier, anonymous-to-known identity behavior, and handling for aliases and merges. Preserve source event IDs and timestamps to support deterministic processing and reconciliation.
Schema and privacy
Govern custom attributes, events, catalog fields, subscription state, and deletion workflows. Validate types and required values, distinguish null from missing data, and account for downstream copies in analytics stores.
Monitoring and testing
Record endpoint, workspace, source identifier, response status, retry count, and final disposition without recording secrets. Test representative profiles, events, purchases, webhook payloads, rate-limit responses, and schema changes before production deployment.
Why use Martini instead of scripts or point-to-point integrations?
Orchestration beyond a script
Martini provides a maintainable workflow layer for coordinating Braze with CRM, commerce, support, analytics, databases, and internal APIs. Integration logic can include triggers, enrichment, mapping, validation, business rules, retries, and reconciliation instead of being embedded in one-off scripts.
Controlled API and webhook boundaries
Martini can consume Braze REST APIs and expose controlled REST endpoints for supported Braze webhook messages. This allows enterprise authentication, canonical models, consistent error handling, and reusable integration assets around Braze capabilities.
Operational reliability
Scheduled workflows, bounded batching, checkpoints, correlation IDs, monitoring, and environment-specific secrets support reliable synchronization across Braze workspaces and data centers. The result is easier to test, troubleshoot, and evolve than multiple point-to-point implementations.
Frequently asked questions
Braze can be integrated primarily through its REST APIs for user profiles, custom events, purchases, segments, campaigns, Canvases, catalogs, subscription groups, messaging, and selected exports. Braze also supports webhook messaging from selected campaigns and Canvases, batch operations such as /users/track, and data-export products such as Currents. The exact endpoints and permissions depend on the Braze workspace and enabled products.
Yes. Martini can integrate with Braze by consuming its REST APIs, submitting user attributes, custom events, and purchases, receiving supported campaign or Canvas webhook messages through a Martini API, and processing supported export data. No native Martini Braze connector is verified in the supplied research context.
No. A dedicated Braze connector is not required. Martini can use Braze’s confirmed native integration mechanisms, including REST APIs, workspace-specific API-key authentication, selected webhook messaging, batch user operations, and supported data exports.
Lonti does not charge an additional per-connector or per-vendor fee to integrate Braze. The integration is subject to the provisioned capacity of the Martini environment. Separate costs may apply from Braze, cloud infrastructure, or other third-party systems based on subscription, usage, and deployment model.
Use Braze REST APIs for server-to-server profile, event, purchase, campaign, Canvas, segment, catalog, subscription, messaging, and retrieval operations. Use /users/track for compatible batches, selected campaign or Canvas webhooks for outbound requests, and Currents or supported exports for engagement and behavioral data. A public Braze GraphQL API was not confirmed, and SOAP is not supported in the supplied research.
Braze supports webhook messaging for selected campaign and Canvas use cases. This capability is not a universal webhook stream for every user, event, campaign, or analytics object. For broad behavioral and engagement export, Currents or another supported export mechanism is generally more appropriate. Martini can expose an endpoint to receive the supported webhook requests.
Synchronization commonly uses event-driven workflows for changes and scheduled workflows for incremental reconciliation or exports. Martini maps source identities to Braze external IDs or aliases, submits attributes, custom events, and purchases through REST APIs, handles pagination and asynchronous exports, and preserves checkpoints, timestamps, and source identifiers.
Martini can validate payloads, distinguish transient rate-limit or network failures from permanent validation and authorization errors, and apply bounded retries with backoff. Workflows can use stable external IDs, source event identifiers, checkpoints, correlation IDs, and reconciliation stores to reduce duplicate submissions and support replay. API keys and sensitive profile data should be excluded from logs.
Yes. Martini can expose a REST API that provides a controlled enterprise-facing façade over selected Braze operations. The façade can enforce authentication, validation, canonical data models, business rules, rate-limit protection, and consistent error handling before invoking Braze REST APIs.
Related Martini documentation
Workflows
Connect Braze with your enterprise systems
Use Martini to integrate Braze REST APIs, selected webhook messaging, batch operations, and supported data exports into governed enterprise workflows.