Real-time audiences

Real-Time Audiences allow Hightouch to evaluate audience membership continuously based on real-time events—like product views, purchases, or session activity. When users enter or exit the audience, Hightouch can sync them to your marketing tools in seconds. This supports fast-changing campaigns like same-session personalization, behavioral triggers, and immediate suppression.

Learning objectives

After reading this article, you’ll know how to:

• Connect and evaluate audiences based on real-time events

• Enable and configure real-time syncs

• Understand the evaluation and sync model used

• Decide when real-time audiences are the right approach

Overview

Real-Time Audiences use an in-memory evaluation engine to determine audience membership as events arrive. Instead of querying the warehouse on a schedule, Hightouch caches your audience filters and evaluates incoming data—like checkout_started, page_view, or order_completed—in real time.

This is different from batch audiences, which re-run on a fixed interval and rely entirely on warehouse data.

When to use real-time audiences

Use real-time evaluation when your campaign logic depends on session activity or very recent user behavior.

Examples:

• Suppress a user from a campaign as soon as they make a purchase

• Show a product recommendation if someone browsed a category but didn’t convert

• Send a push notification if a user abandons checkout within the last 2 minutes

How it works

Real-Time Audiences rely on a hybrid model:

• Audience filter logic is cached in memory

• Events are evaluated as they arrive

• Traits (like LTV, loyalty_tier, or channel) are joined from the warehouse

• When a user qualifies or exits, Hightouch triggers a real-time sync

Supported destinations

You can sync real-time audiences to destinations that support real-time delivery:

• Facebook Custom Audiences

• Google Ads Customer Match

• Braze

• Iterable

• Segment

• Amplitude

• Webhooks

Set up a real-time audience

Step 1: Connect an event stream

Before you can evaluate real-time audiences, Hightouch must receive event data.

• Set up Hightouch Events →

• Migrate from legacy streams →

Step 2: Create a real-time event model

To evaluate real-time events in an audience, you first need to add a related real-time event to your parent model in the schema.

1. Go to Customer Studio > Schema

2. Locate or create a new parent model (usually Users)

3. Click the plus (+) icon next to the parent model

4. Select Create a related realtime event

5. In the Select event source screen:

   • Choose the event source from the dropdown (e.g. Snowplow, Rudderstack, or Hightouch Events)
   • Enter an event type (e.g. track, page, order_completed)
   • Define event properties by adding columns and optional aliases
   • Set the timestamp column (used to filter by recency)

6. Click Continue

7. In the Configuration step:

   • Give your model a name (e.g. Checkout started events)
   • Optionally, add a description
   • Confirm the timestamp column
   • Map the relationship back to the parent model by selecting a foreign key (e.g. user_id)

8. Click Create realtime event to save the model

Step 3: Create or update a saved audience

1. Go to Customer Studio > Audiences

2. Create or open an audience

3. Make sure to choose the parent model connected to the real-time event model

Step 4: Add a real-time event condition

1. In the audience builder, click Add filter

2. Choose Event and select your real-time event model

3. Add event conditions (e.g. "performed within last 5 minutes")

4. Click Continue

5. Finalize audience settings and click Finish

Step 5: Choose your integration method

Once your real-time audience is set up, you can deliver audience updates using one of two methods:

Option 1: Event-driven sync

Receive real-time entry/exit events through a destination integration.

1. In your audience, go to the Syncs tab

2. Click Add Sync

3. Select a Destination

4. Under Sync frequency, select Real-time

5. Select the identifier (e.g., user_id, email)

6. Choose removal behavior:

   • Remove from audience
   • Do nothing *Archive (if supported)

7. Click Create sync

Option 2: Real-time API pull

Use the Hightouch Personalization API to query audience membership in real time. This is ideal for same-session personalization, where your website, app, or backend needs to instantly decide which experience to show a user.

How it works:

• Your app makes a high-speed API call at the moment of interaction
• Hightouch returns whether the user is in a specific audience
• You decide how to personalize based on audience membership (e.g. promo eligibility, suppression, banner targeting)

Example use cases:

• Suppress a discount banner if the user already purchased
• Recommend products to users in a "High intent + Viewed product" audience
• Show different landing pages based on lifecycle stage

Example request:

GET /api/v1/audiences/{audience_id}/memberships/{user_id}
Authorization: Bearer <API_KEY>

Response:

{
  "isMember": true
}

Step 6: Publish and monitor

1. Click Publish

2. Hightouch will begin evaluating users and delivering updates in real time

3. Monitor performance via Sync logs or your API response logic

Example: Suppression use case

Goal: Hide a promo banner if a user just made a purchase
Audience filters:

• Event: order_completed in the last 5 minutes
• Trait: LTV > 300
• Property: channel = web

Sync:

• Real-time webhook to your personalization platform
• Uses user_id to remove the user from the audience instantly

Result:
The user sees the banner, completes a purchase, and is removed from the campaign audience in real time—before they reload the page. This prevents the promo from showing again during the same session.

Best practices

• Use for session-based, event-triggered, or real-time decisioning campaigns
• Keep event filters narrow and recent (e.g. last few minutes) for fast evaluation
• Use traits like LTV, loyalty_tier, or last_seen to enrich logic—without overcomplicating
• Monitor delivery with sync logs or API responses, and set up alerts for failures

What’s next?

• Sync audiences on a schedule →

• Create traits for real-time logic →

• Use subsets for opt-out handling →

• Trigger flows in journeys →