Event streaming

Audience	How you’ll use this article
Marketing teams	Understand the end-to-end event streaming workflow and how event data powers real-time activation, personalization, and experimentation.
Data teams	Learn how streamed events are filtered, mapped, validated, and delivered to downstream tools alongside warehouse-based workflows.
Engineering teams	Follow the recommended implementation path, from source setup and validation to configuring event streaming syncs and monitoring delivery.

What you’ll learn

By the end of this article, you’ll be able to:

Decide when to use event streaming
Understand how event streaming works
Set up an event streaming sync
Configure event types and filters
Map event and user data to a destination
Monitor delivery and troubleshoot errors
Set up alerting

Event streaming lets you send events collected by Hightouch directly to destinations in real-time, without going through the warehouse. Events stream in seconds, which is useful for latency-sensitive use cases where timing matters such as: triggering messages, updating consent, or powering real-time personalization.

Event streaming is a type of Event Sync that takes events from an Event Source and syncs them to an Event Destination in real-time.

When to use event streaming

Use event streaming when your workflow depends on something that just happened.

Examples:

Post-purchase workflow to send upsell offers to users immediately following a purchase
Ad impression measurements so you can immediately pause ads that surpass their budget
Other time-sensitive emails or messages sent to users after significant events like a demo request, new user sign up, and missed call follow-up
Update users’ consent or contact status immediately after a change

When to use reverse ETL instead

Reverse ETL is a better fit when timing is less critical and context matters more than immediacy.

Use reverse ETL when you need:

Warehouse-enriched or aggregated data
(joins across tables, LTV, days since last purchase, ML scores)
Audiences built from historical behavior
(for example, users who purchased 3+ times in the last 90 days)
Ongoing monitoring and governance at scale
(shared models and metrics used across many workflows)

For example, reverse ETL works better for:

Conversion events that benefit from complete identity and revenue context
Audience membership that should change over time, not from a single event
Features or scores computed from many events (churn risk, power users, high-value cohorts)

→ Learn more about Reverse ETL syncs.

How event streaming works

With event streaming, events flow through Hightouch and are forwarded to destinations in near real time.

At a high level, each streamed event follows this path:

The event is received from an event source (SDK, HTTP API, streaming source, or webhook).
(Optional) Contracts validate the event’s structure, naming, and required fields.
(Optional) An Event Function transforms or enriches the payload.
Filters decide whether the event should be forwarded for a given event type.
Field mappings shape event and user data to match the destination schema.
The event is delivered to the destination, with automatic retries on failures.

This flow happens per event, rather than on a schedule. For warehouse-based, batch processing, use event storage and reverse ETL instead of event streaming.

Optional validation and transformation

You can optionally add additional controls to this flow:

Data contracts
Validate event structure, naming, and required fields before events are delivered.
→ See Managing contracts
Event functions
Modify or enrich events in-flight before they are sent to the destination.
→ See Functions overview

These steps are optional and are commonly introduced as your event implementation grows.

Set up event streaming

Prerequisites

Before you begin, make sure you have:

An event source that’s already set up and receiving events
A destination where you want to forward those events

Step 1: Create a new event sync

Go to Event Collection → Event Syncs
Click Add sync

Step 2: Select an event source

Choose the source that emits the events you want to stream.

If you don’t see the expected source, confirm that events are being received:

Go to Event Collection → Event Sources
Select the source
Open the Debugger tab
Trigger the event in your app or site and verify it appears in the debugger

Step 3: Select an event destination

Event syncs can either store events or forward events, depending on your use case:

Event storage destinations write events to your warehouse
Event forwarding destinations send events to downstream tools in real time

Select a destination under Event forwarding.

Use the Docs link in the UI to review destination-specific requirements.

Step 4: Name and create the sync

Enter a clear, descriptive name for the sync, then create it.

Once created, you’ll be taken to the sync’s detail page.

Configure streamed events

Event configuration happens inside the sync, not during creation.

Set in:
Event Collection → Event Syncs → [Select sync] → Configuration

Event types

Each destination supports one or more standard event types (for example, a purchase event) and a custom event type.

We recommend always configuring the custom event type so you don’t unintentionally drop events.

Referencing fields

In event filters and field mappings, you can reference fields on the event payload to filter on and match to fields in the destination object. Keep in mind:

Reference nested fields using dot notation, for example properties.price or event.
If a destination expects a specific data type, use Liquid templates to cast or format values, for example {{ row['properties'].price | cast : 'number'}}.
If a field name contains a period (.) or backslash (``), escape it with a backslash.
You do not need to escape spaces.
The event property refers to the event’s name for track events.
The type property refers to the SDK and API event type (track, identify, page, screen, group).

Use the Debugger in your event source to inspect real payloads while designing filters and mappings.

Event filters

Event filters determine which incoming events are sent as each event type.

For example, when configuring a purchase event, you might filter for only purchase-related events.

Field mappings

Field mappings control what data is sent to the destination and where it appears.

Mappings are configured per event type and grouped by purpose in the UI.

Set in:
Event Collection → Event Syncs → [Select sync] → Configuration → [Select event type]

Map required event fields

This section maps core event data to fields required by the destination.

Required fields (such as items, total, currency, or timestamp) must be mapped before the sync can run successfully. If required fields are missing or mis-typed, the destination may reject events.

Sync additional user fields (optional)

This section lets you send user-level data along with each event, such as email or subscription status.

Use this when:

The destination updates user profiles based on events
You want events to enrich user data in real time

Sync custom event fields (optional)

This section controls which event-specific details are included beyond required fields.

For custom events, we recommend sending the entire properties object so downstream tools receive full context.

Choosing source values

When mapping fields or creating filters, you choose where each value comes from.

You can use:

Field – Pull a value directly from the event payload (for example, properties.total)
Static value – Send the same value for every event
Template – Format or transform values
Create an array – Combine one or more fields into an array

These options let you adapt your data to match what the destination expects without changing how events are tracked.

(Advanced) Edit JSON mode

Within a sync's Configuration tab, you also have the option to modify the underlying sync configuration directly. This mode is intended for advanced use cases where the standard UI does not provide enough flexibility.

Use Edit JSON mode when you need to: