Skip to Content
PersonalizationRealtime Syncs

Realtime Syncs

A realtime sync pushes one person to one destination the moment an event shows their answer has changed. It is the push side of the realtime plane: where the Membership API waits to be asked, a realtime sync tells a destination on its own.

Experimental — in active development. Sending is live: a sync you create starts delivering as events arrive. The destination catalogue is still short — webhook, Braze, Zapier, HTTP Request, Azure Functions, Google Cloud Functions, MoEngage, Rudderstack, mParticle and Pendo — and grows a few destination types at a time.

An event arrives, the person's answer is worked out again, it is compared with what the sync last sent, and the destination is told

Why this exists

A realtime audience used to have exactly one way out: you read it, per person, at the moment you needed the answer. It could not be sent to a destination on a schedule — membership is re-evaluated on every read and can flip either way within seconds, so there is no stable list to push.

That is still true of a scheduled sync, and the product still refuses one. What changed is that “no schedule” no longer means “no destination”. A realtime sync does not push a list at all: it pushes a change, one person at a time, as it happens.

What you need first

  • A realtime audience — one whose definition contains at least one realtime event condition. A sync on any other audience is refused, and the audience picker leaves those out.
  • A destination that can receive one. This is a shorter list than the destination catalogue you use for scheduled syncs: each destination type needs a way to add and remove one person at a time, and today that is webhook and Braze. The picker shows you only the destinations it can actually reach. See Destinations for what each one receives.
  • The realtime plane enabled for your workspace. It is the same switch that gives you realtime audiences — if you have those, you have this.

The two modes

Every sync makes one of two promises to its destination, chosen when you create it and changeable afterwards.

Under entry only a departure is not sent; under entry and exit both are sent
ModeWhat the destination is told
Send people as they joinThe destination hears as soon as an event shows someone qualifies, and nothing else.
Send people as they join and as they leaveThe destination also hears when an event shows someone no longer qualifies.

Under as they join, the destination keeps everyone it was told about. It is never told that someone left, so its list only ever grows — it holds a superset of the audience, and nothing in Zeotap will trim it. Choose this mode when the destination’s own rules decide when someone leaves it, and the other mode when the destination is meant to match the audience.

Departures are not lost under as they join — they are recorded and counted, they are simply not sent. The sync page shows them under Not sent, which is how you explain a destination that still holds somebody.

The one boundary

Someone is only sent when an event arrives for them. If their answer changes while nothing is happening on their side, the destination hears about it at their next event.

This is the whole model, and it is worth reading twice, because it is the one thing that behaves differently from a scheduled sync. A scheduled sync re-reads everybody on a timer; a realtime sync only ever looks at the person an event just arrived for. So:

  • Someone who qualifies because of something they did is sent within seconds.
  • Someone whose answer changes for a reason that produced no event of theirs — a warehouse rebuild moving them, an edit to the audience, two identities being linked — is sent at their next event, whenever that is.
  • Someone who never sends another event is never sent again.

Creating one

  1. Open the audience and go to its Realtime syncs tab. (A realtime audience has this tab where a scheduled audience has Syncs — an audience has one or the other, never both.) Or open Activate in the left navigation, select Realtime Syncs, and select Create realtime sync.
  2. Choose Create realtime sync. The flow has four steps, the same as creating a scheduled sync; starting from an audience skips the first.
  3. Select audience. Pick the realtime audience whose people are sent. You can search by name or description.
  4. Select destination. Pick the destination from the searchable list. Only destinations that can receive a realtime sync are listed; if the list is empty, add a destination of one of the types listed on this page first. A destination this audience already sends to is shown but cannot be picked, because an audience has at most one realtime sync to each destination.
  5. What to send. Fill in the destination’s own settings, if it has any — a Braze destination asks for the attribute or event it should write; see Braze. Then, optionally, add attributes the destination should be told about each person. Destinations with no settings still show this step, so the attributes are always one click away.
  6. Configure & save. Give it a name — it defaults to the audience and the destination, which is what tells two syncs on the same audience apart — and pick what the destination is told: the two modes above. There is deliberately no default: this is a promise to a third party, and it is yours to make. Preview a delivery at the bottom shows the request a person would produce before anyone receives one.

The sync starts active. People are sent from that moment on; nobody already in the audience is sent retrospectively, because nothing has happened to them yet.

Destinations

Each destination type in the realtime catalogue receives a change in its own shape. Ten are available today. Five of them — Webhook, Zapier, HTTP Request, Azure Functions and Google Cloud Functions — receive the same fixed payload, described under What arrives at a webhook, so one endpoint written against it works behind any of them. Four more — MoEngage, Rudderstack, mParticle and Pendo — set a yes/no attribute on the person, described under Destinations that set a yes/no attribute.

DestinationWhat a change becomesWhat you configure on the sync
WebhookOne POST carrying the fixed payload belowNothing — the URL, method, headers and sign-in (an authorization header, an API key, or OAuth2 client credentials) are on the destination
BrazeOne POST /users/track that records audience membership on the person, sends a custom event, or bothWhich of those, and their names
ZapierOne POST of the fixed payload to the Zap’s Catch HookNothing — the hook URL is on the destination
HTTP RequestOne request of the fixed payload, with the destination’s method and headersNothing — the URL, method, headers and credentials are on the destination
Azure FunctionsOne request of the fixed payload to the function URLNothing — the function URL, method and key are on the destination
Google Cloud FunctionsOne request of the fixed payload to the function URLNothing — the function URL, method, headers and token are on the destination
MoEngageOne Track User call that sets a yes/no user attribute on the personThe attribute’s name, and whether to create people MoEngage does not know
RudderstackOne identify that sets a yes/no trait on the personThe trait’s name
mParticleOne event batch that sets a yes/no user attribute on the personThe attribute’s name, and which mParticle identity the destination key is
PendoOne custom-field update that sets a yes/no visitor fieldThe field’s name
SegmentOne identify that sets a yes/no trait on the personThe trait’s name
Customer.ioOne update of the person that sets a yes/no attributeThe attribute’s name, and whether to create people Customer.io does not know
CleverTapOne profile upload that sets a yes/no profile propertyThe property’s name

Braze

Braze has no way to add one person to a segment or remove them: segments are filters. So a realtime sync records membership on the person, in an array attribute that lists the audiences they are in: the audience is added when they join and removed when they leave, and you build your Braze segment as audiences includes VIP. It is the same array a scheduled Braze audience sync writes, so a realtime and a scheduled sync of one audience agree. Adding or removing the same value twice is the same as doing it once, so a repeated change does no harm. Leaving never deletes the Braze profile: the removal sends only the person’s identity and the change to the array, so it touches none of their other attributes and never creates a profile for someone Braze does not know.

A campaign or Canvas that should fire the moment somebody joins wants an event, not a filter. The sync’s What Braze receives setting offers membership (the default), a custom event, or both:

SettingWhat it does
What Braze receivesMembership, a custom event each time someone joins or leaves, or both
Audience membership attributeThe array attribute listing the audiences a person is in. audiences unless you change it. Up to 255 characters, not starting with $, and not one of Braze’s own profile fields such as email
Audience membership valueThe value added and removed for this audience. The audience’s name unless you set one — set a fixed value if you may rename the audience, and use the same value as any scheduled sync of it
Event name when someone joins / leavesThe custom events sent, when events are on. audience_entered and audience_exited unless you change them
People Braze does not know yetOff, a person with no Braze profile is left alone and the change still counts as sent. On, Braze creates a profile for them when they join, carrying only this membership or event. Leaving never creates a profile

A sync created before membership arrays, with a Custom attribute name, keeps setting that attribute to true and false so the segments built on it keep working. Its settings page shows Audience membership attribute empty; that does not mean it writes audiences. To move it to the array, type the attribute name there (audiences, or the one your scheduled syncs use) and save.

When Braze answers that a limit is used up, deliveries to that Braze destination wait for the reset (at most a minute) before sending more, on scheduled and realtime syncs alike, instead of each earning a refusal of its own.

The event carries audience_id, audience_name and sync_id as its properties, so a campaign can tell which audience fired it.

Events can repeat; membership cannot. A change is sent at least once, and Braze has no way to recognise a repeated event, so a crash at the wrong moment can send a join event twice. Membership is safe under a repeat. If a campaign must never fire twice for one join, trigger it on membership changing rather than on the event.

Attributes you map on the sync land on the person’s Braze profile as custom attributes, beside the membership, when they join (and in event-only mode, every time). The membership attribute, the person’s external_id and the create-profile setting always win over a mapped field of the same name. A leave sends no mapped attributes, the same as a scheduled sync.

The destination itself is the same Braze connection your scheduled syncs use — the REST endpoint and API key — configured once. The person is named to Braze by their external_id, which is the audience’s destination key; a person known only by a device id is never sent, as with every destination.

If Braze accepts the request but refuses the person — an attribute name it will not take, for instance — the change is recorded under Recent failures with Braze’s own message, and it is not retried, because asking again would get the same answer.

Zapier

A realtime sync to Zapier sends one POST of the fixed payload to the destination’s Webhooks by Zapier Catch Hook URL each time someone joins or leaves. Zapier keeps no people of its own: the Zap behind the hook decides what joining and leaving mean, by reading type (audience.entered or audience.exited), user_id and any attributes you map. The person is named by user_id, the audience’s destination key.

There is nothing to configure on the sync. The destination holds the hook URL, which must start with https://hooks.zapier.com/; the URL is the secret, so no key is sent.

  • A success means Zapier accepted the request, not that the Zap ran. Zapier answers 200 before running the Zap, including for a payload the Zap then ignores, and a later Zap step that fails is not reported back. Check the Zap’s history in Zapier.
  • A Zap that is turned off or deleted answers 404. The change is recorded under Recent failures and not retried; after five in a row the sync pauses. Turn the Zap on and resume the sync.
  • Catch Hook is a premium Zapier feature, available on the Professional plan and above.
  • Under heavy load Zapier may accept a request and run the Zap several minutes later.

HTTP Request

A realtime sync to an HTTP Request destination sends one request of the fixed payload to the destination’s URL each time someone joins or leaves, with the destination’s method and custom headers. It is the webhook with the HTTP Request destination’s settings; there is nothing to configure on the sync.

Destination settingWhat a realtime sync does with it
Endpoint URLSends to it
HTTP MethodPOST, PUT or PATCH. A destination set to DELETE is refused when you create the sync, because every change, joining included, would go out as a DELETE carrying a body
Content TypeJSON. A destination set to form encoding is refused when you create the sync: the payload is nested and has no form rendering
Batch ModeIgnored. A realtime sync always sends one person per request
Custom HeadersSent with every request
Authorization header / API keySent as Authorization and X-Api-Key

If the destination is changed to DELETE or form encoding after the sync was created, each change is refused and recorded under Recent failures until the destination is changed back.

Azure Functions

A realtime sync to Azure Functions sends one request of the fixed payload to the destination’s HTTP-triggered function each time someone joins or leaves, with the destination’s method (POST, PUT or PATCH). Your function decides what joining and leaving mean. There is nothing to configure on the sync.

Destination authenticationWhat is sent
Function KeyThe key in the x-functions-key header
API KeyThe key in the x-functions-key header
Bearer TokenAuthorization: Bearer <token>
NoneNo credential, for a function with anonymous access

A realtime sync sends a function key in the x-functions-key header rather than the code query parameter a scheduled sync uses; Azure treats the two the same, and the header keeps the key out of the URL. An Azure (Entra) access token usually expires after 60 to 90 minutes, after which every change fails with 401 and the sync pauses, so prefer a function key.

Google Cloud Functions

A realtime sync to Google Cloud Functions sends one request of the fixed payload to the destination’s function URL each time someone joins or leaves, with the destination’s method (POST, PUT or PATCH) and any custom headers set on it. Your function decides what joining and leaving mean. There is nothing to configure on the sync.

Destination authenticationWhat is sent
Bearer TokenAuthorization: Bearer <token>
API KeyThe key in the X-Api-Key header
NoneNo credential, for a public function
Service AccountAuthorization: Bearer <ID token>, a Google ID token created from the service account for the function URL and renewed before it expires

Use a service account for a function that requires IAM authentication. Such a function needs a Google ID token, which expires about an hour after it is created, so a token pasted into the destination as a bearer token stops working within the hour. With a service account the token is created and renewed for you. Bearer tokens and API keys suit a public function that checks them in its own code.

Destinations that set a yes/no attribute

MoEngage, Rudderstack, mParticle, Pendo, Segment, Customer.io and CleverTap build their segments as filters over a person’s attributes, the way Braze does, so none of them has a call that adds one person to a list. A realtime sync to any of them works the same way: it sets one attribute per sync to true when the person joins and to false when they leave, and you build the segment on that attribute being true. Setting the same value twice is the same as setting it once, so a repeated change does no harm.

What they share:

  • You name the attribute, and it is the only required setting. Use a different name for each sync; two syncs writing one attribute would overwrite each other.
  • The person is named by the audience’s destination key, sent as it is. A person known only by a device id is never sent, as with every destination.
  • Joining sends the attribute set to true, plus any attributes you map on the sync, beside it. The attribute itself and the person’s id always win over a mapped field of the same name.
  • Leaving sends only the attribute set to false. It touches none of the person’s other attributes and never deletes or unsubscribes them.
  • People the destination does not know yet. Where the destination’s API can update a person without creating one, a leave never creates anybody, and a join creates somebody only if you turn that on (MoEngage and Customer.io offer the choice). Where it cannot — Rudderstack, Segment, CleverTap, and mParticle unless your input says otherwise — a leave for someone the destination has never seen creates a profile holding only the attribute set to false. That profile is in no segment built on the attribute being true.

A failure that asking again would not fix — a key the destination refuses, an attribute name it will not take — is recorded under Recent failures with the destination’s own message, and not retried.

MoEngage

SettingWhat it does
MoEngage user attributeThe user attribute set to true on join and false on leave. It cannot be id or _id, or start with moe_, which MoEngage reserves
People MoEngage does not know yetOff (the default), a join for a person MoEngage has no user for is left alone. On, MoEngage creates the user when they join. Leaving never creates a user

The person is matched by customer_id, which is the audience’s destination key. The change is MoEngage’s Track User call to the data center your MoEngage destination names (DC-01 to DC-06), signed with its Workspace ID and Data API key — the same destination your scheduled syncs use. Mapped attributes named id or _id, or with no name, are left out, because MoEngage would refuse the whole update for them. So are mapped attributes starting with moe_, which MoEngage keeps for its own, except the standard ones Track User lets you write: moe_unsubscribe, moe_sms_subscription, moe_wa_subscription, moe_email_optin_status, moe_em_unsub_categories, moe_spam, moe_hard_bounce and moe_sub_w, which are sent like any other mapped attribute. The attribute the sync itself sets is always one of your own, so it cannot be one of those.

MoEngage accepts the call and processes it shortly after, so a segment sees the change within moments rather than instantly. A join it skipped because the person is unknown, with the setting off, is not reported back: that is the outcome the setting asks for. Realtime and scheduled syncs to one MoEngage workspace share MoEngage’s limit of 10,000 user updates a minute.

Rudderstack

SettingWhat it does
Trait nameThe trait set to true on join and false on leave

Each change is an identify call for the person’s userId (the audience’s destination key) to your data plane URL, with the trait under context.traits — so every destination and warehouse connected to that Rudderstack source receives it like any trait your own apps send. It is authenticated with the source’s write key, which is the only credential it needs: a data plane URL with a username or password in it (https://user:pass@host) is refused, both when you create the sync and when a change is sent, because the URL is shown wherever the sync is previewed. An identify for a user Rudderstack has not seen is ordinary for Rudderstack, which routes events rather than keeping profiles, so there is no setting for unknown people. Each message carries a messageId that is the same if a change is ever sent twice, so a downstream warehouse can drop the repeat.

mParticle

SettingWhat it does
User attributeThe user attribute set to true on join and false on leave
What the destination key is in mParticleThe mParticle user identity the destination key is sent as: Customer ID, Email address, Mobile number, Other, or Other ID 2 to 4. It has no default, because only you know what the audience’s key holds; the key is sent as it is, without hashing

Each change is one server-to-server event batch to the mParticle pod your destination names, in its environment (production or development), carrying the user attribute and no events. Each batch carries a source_request_id that is the same if a change is ever sent twice, and mParticle drops the repeat.

mParticle answers “accepted” without saying what it did with the batch. Whether an unknown identity creates a profile is your mParticle input’s profile protection setting, not a sync setting: by default mParticle creates one, and with Only Update it discards the batch. A batch discarded that way, or blocked by a data plan, is not visible to Zeotap and is counted as sent.

Pendo

SettingWhat it does
Pendo custom fieldA boolean visitor custom field, set to true on join and false on leave

Create the field first, under Settings > Metadata in Pendo, as a boolean custom field: a realtime sync never creates one. The person is matched by Pendo visitor id, which must be the audience’s destination key — the same id your Pendo snippet sends. The integration key on your Pendo destination must have write access.

Pendo never creates a visitor here. A change for a visitor Pendo does not know is accepted and does nothing, and it counts as sent: Pendo only learns about visitors from its own snippet, and a visitor with no first visit is in no segment anyway. A change Pendo refuses for another reason — a field that does not exist, for instance — is recorded under Recent failures with Pendo’s message. Pendo says values uploaded to it can take up to 15 minutes to show in the app.

Attributes you map on the sync are written to Pendo custom fields of the same name, so each one must exist in Pendo too. Pendo refuses the whole change when any field is missing, so one mapped attribute with no matching field fails every delivery until the field is created or the mapping removed.

Segment

SettingWhat it does
Trait nameThe trait set to true on join and false on leave. It cannot be one of Segment’s reserved traits, such as email, firstName or createdAt

Each change is an identify call for the person’s userId (the audience’s destination key) to the data center your Segment destination names (United States or European Union), with the trait under traits, authenticated with the source’s write key. Every destination, warehouse and Unify profile connected to that Segment source receives it like any trait your own apps send — the same way Segment’s own audiences mark people joining and leaving. Mapped attributes are sent as they are, reserved traits included, so a mapped email reaches Segment as the person’s email.

Segment routes events rather than keeping a list of known people, so there is no setting for unknown people: an identify for a user Segment has not seen is ordinary, and a leave for one creates a profile holding only the trait set to false. Each message carries a messageId that is the same if a change is ever sent twice, and Segment drops the repeat.

Segment answers success to every call except an oversized or malformed one, so some refusals are invisible to Zeotap and count as sent. The one to watch for is a write key from the other region: a key from a European Union workspace sent to the United States data center, or the reverse, is accepted and the data never arrives. If changes do not show up, check the source’s Debugger in Segment and that the destination’s data center matches the workspace’s region.

Customer.io

SettingWhat it does
Customer.io attributeThe person attribute set to true on join and false on leave. It cannot start with _ or cio_, or be id, email, anonymous_id, created_at, timezone or unsubscribed
People Customer.io does not know yetOff (the default), a join for a person Customer.io has no profile for is left alone. On, Customer.io creates the person when they join. Leaving never creates a person

Each change updates the person named by the audience’s destination key — which Customer.io reads as their ID, their email address or, starting with cio_, their Customer.io ID, depending on how your workspace identifies people — in the region your Customer.io destination names (US or EU), signed with its Site ID and Track API key. Build the segment on the attribute being true. Mapped attributes named id, email, anonymous_id or unsubscribed, or starting with _ or cio_, are left out, so a realtime sync never changes who a person is or whether they are subscribed; created_at and timezone are sent like any other mapped attribute. A realtime sync never deletes a person, whatever your scheduled syncs to the same destination do.

Customer.io answers success before it applies a change, and reports a change it could not apply — an update for a person it does not know, with the setting off, or an attribute it refused — only in the workspace’s Activity Logs as a failed attribute change. Such a change counts as sent here. For a person it does not know, that is the outcome the setting asks for.

CleverTap

SettingWhat it does
CleverTap profile propertyA custom profile property set to true on join and false on leave. Up to 120 characters, with none of the punctuation CleverTap refuses in a name (such as ., :, $ or #). It cannot be one of CleverTap’s standard or identity fields such as Email or identity, or start with MSG- or category-, which CleverTap uses for subscriptions

The person is matched by identity, which is the audience’s destination key. Each change uploads one profile to the region your CleverTap destination names, signed with its Account ID and Passcode — the same destination your scheduled syncs use. Mapped attributes are written to the profile beside the property, CleverTap’s standard fields included; mapped identity, objectId, FBID and GPID are left out, so a mapping cannot point the change at somebody else. CleverTap refuses the whole profile when a standard field is not in its format — an email address it does not accept, for instance — so the property is not set either; map standard fields only when they already hold values CleverTap takes.

CleverTap creates a profile for an identity it has not seen, and has no way to update only people it knows, so a leave for someone CleverTap has never seen creates a profile holding only the property set to false. A profile CleverTap refuses — a mapped email that is not valid, for instance — is recorded under Recent failures with CleverTap’s code and message, and not retried; a server error on CleverTap’s side is retried. CleverTap allows 15 uploads at once per account, shared with your scheduled syncs to it.

What arrives at a webhook

One POST per change, to the URL on the destination, with the destination’s own method and headers. The fields below are fixed — every sync sends them, in the same shape — so one consumer can be written against one contract and used by every sync you ever create. A sync can carry an attributes object alongside them, which is the one part you configure; see Attributes and mapping.

{ "type": "audience.entered", "sync_id": "b1f0…", "audience": { "id": "9c2e…", "name": "High-intent browsers" }, "user_id": "u_123", "anonymous_id": null, "occurred_at": "2026-09-08T10:30:00Z", "sequence": 1756900000123456 }
FieldWhat it is
typeaudience.entered or audience.exited
sync_idThe sync that sent it — how a shared endpoint tells two syncs apart
audienceThe audience’s id and its name at the moment of the change
user_idWho it is about. Always present: this is the identifier the destination knows them by
anonymous_idThe device the triggering event came from, when there was one. Usually null, and never what the change is keyed on
occurred_atWhen the event that caused the change happened — not when it was sent
sequenceMicroseconds, at the moment of sending

The header X-Zeotap-Event repeats type, so a proxy or a routing rule can act on it without reading the body.

Two things your endpoint should do:

  • Answer quickly, and answer honestly. Any 2xx is success. A 4xx means “do not send this again” and stops the retries; a 5xx, a 408 or a 429 means “try again” and it will be retried. A destination that fails repeatedly pauses its own sync.
  • Tolerate a repeat. A change is sent at least once, so a crash at the wrong moment can produce a duplicate. Adding somebody who is already there, or removing somebody who has already gone, is the shape every destination in the catalogue is expected to handle — and if you need to spot one, compare sequence: a lower one than you have already processed for that person is a stale repeat.

Attributes and mapping

A change can say more than that somebody joined or left. Alongside the fixed fields, a sync can carry attributes about the person — their tier, their lifetime value, the hashed email an ad platform matches on — read from a Store and shaped by a field mapping.

Nothing is added unless you ask for it. A sync with no mapping sends the body above and no attributes key at all, so an endpoint written against the fixed contract keeps receiving byte-identical traffic. A mapping that runs and produces nothing sends "attributes": {}, which is a different statement: the mapping ran, and there was nothing to say.

A change is read against the Store by user_id, the result is run through the mapping, and the payload is delivered; a miss either delivers without the attributes or sends nothing at all

Attributes are as fresh as the Store, not as fresh as the event

Read this before you configure anything.

Membership is realtime: the change that reaches your endpoint was worked out from an event that arrived seconds ago. The attributes riding with it were not. They come from a Store, and a Store is populated by feeds that refresh on their own schedules — usually hours apart. If somebody’s tier changed in your warehouse ten minutes ago and the feed carrying it runs nightly, the delivery going out now carries last night’s tier.

So attributes suit values that move more slowly than the feed does: a plan, a loyalty tier, a hashed email, a lifetime value you are bucketing anyway. They do not suit a value the triggering event itself just changed. If the destination needs a value as of the event, read it from the Profile API when the change arrives, rather than trusting what rode along with it.

One read per change

Per change, after the mode has been applied and before the delivery:

  1. One lookup in the Store, by the destination key — the same user_id the change is keyed on. One key, and no fallbacks: a change carries exactly one thing the destination knows the person by, so there is nothing to fall back to.
  2. The mapping runs over the change and whatever the lookup returned.
  3. The result is delivered as attributes.

The cost is one lookup and one mapping per change. Repeats are served from memory for the cache interval you set, so somebody whose events arrive in a burst is looked up once. Nothing is read for a change that will not be delivered: under as they join, a departure is dropped before the Store is touched.

Because the lookup is by the destination key and nothing else, the Store has to hold the same people the audience does. In practice that means the Store is fed from the audience’s parent model, or from a model that is one-to-one with it. A Store fed from somewhere else holds different rows entirely — accounts, say, where the audience holds people — so nobody in the audience could be found in it, and every delivery for the life of the sync would go out without its attributes.

You do not have to work this out yourself: the Store picker shows every Store you have and greys out the ones that cannot be read for this audience, each with the reason. A sync configured that way through the API is refused when you save it.

What a mapping can read

SourcePaths
The personuser_id
The audienceaudience.id, audience.name
The change itselftransition.kind, transition.occurred_at, transition.sequence
The Storestore.<attribute>, one for each attribute you selected
System values and constantsThe sync, the audience, the destination, the workspace, the environment, the current timestamp — and any fixed literal you want stamped on every change

Only the Store attributes you selected are readable, so store.plan is available exactly when you picked plan. Naming anything else — a Store field you did not select, or transition.type in place of transition.kind — is refused when you save, rather than becoming a destination field that is silently never populated.

The vocabulary is the one you already use on a scheduled sync: casts, field transforms such as Uppercase and SHA-256, concatenation, templates and coalesce. A transform means the same thing here as it does there, and SHA-256 produces the same digest on both, so a destination matching on a hashed email matches the same way whichever surface sent it.

A mapping needs no Store. Constants and system values alone are a valid payload, and that is how “send the audience name with every change” is expressed: a mapping, no Store, no lookup.

A mapping that fails while a change is being sent is not a miss, and it is not retried. A mapping is deterministic over one change, so the same person redelivered would fail the same way; it goes straight to Recent failures rather than burning its attempts first.

A worked example. A Store holding plan, email and ltv per customer, and this mapping:

Destination fieldValue
tierstore.plan, through Uppercase
hashed_emailstore.email, lowercased and then SHA-256
ltvstore.ltv
audienceSystem value — Audience name

For u1, whose entry is { "plan": "gold", "email": "U1@Example.com", "ltv": 1200 }, the delivery is:

{ "type": "audience.entered", "sync_id": "b1f0…", "audience": { "id": "9c2e…", "name": "High-intent browsers" }, "user_id": "u1", "anonymous_id": null, "occurred_at": "2026-09-08T10:30:00Z", "sequence": 1756900000123456, "attributes": { "tier": "GOLD", "hashed_email": "6228d577ed8b4c57b0388fbef9d63caed2ca3c1cca39bc8db1253cf22f80beae", "ltv": 1200, "audience": "High-intent browsers" } }

When the Store has nothing for them

A miss is an entry the Store does not hold, a Store that cannot be reached, or a lookup that runs past its timeout. Those are one outcome rather than three, because there is nothing you could do differently about any of them.

You choose what a miss does.

SettingWhat happens
Deliver without the attributes (default)The change goes out with whatever the mapping could produce without the Store. Fallback values you set on an attribute still apply
Send nothing at allThe change is not delivered. The destination is never told about that person

Delivering anyway is the default for the reason it is the default on event enrichment: a stale serving layer should not become a delivery outage. Choose Send nothing at all only where a change without its attributes is genuinely worse than no change — a required partner identifier, or an attribute your consent handling depends on.

A change skipped this way leaves no record. Nothing is written for that person: Deliveries will not show them, the failures behind the Failed figure will not show them, and the destination is simply never told. The counter below is the whole trace.

Three counts on the sync’s Activity are what make any of this visible (the API serves them as enriched, store_miss and skipped_on_miss):

CountWhat it means
With attributesThe Store had an entry, and the attributes went out with the change
Sent without attributesThe Store had nothing, and the change went out without them
Not sent, no attributesThe Store had nothing, and the change was not delivered

With attributes is the denominator, and without it neither of the others means very much. Three misses in four changes is a Store feed that has stopped; three in thirty thousand is a feed catching up on people who joined since its last refresh. If misses track your total while With attributes sits at zero, start at the Store’s Refreshes tab.

Matching on a hashed identifier

Some destinations never accept your own id for a person. They match on a digest of an email address or a phone number instead, and an audience reaches them as a list of hashes; Meta Custom Audiences and Google Customer Match are that shape. None of the destinations available today works this way — each takes your own id for the person — but the rule below is already enforced, so a sync to the first such destination is either right at the moment you save it or refused.

A sync to a destination of that kind has to be told which identifier it is sending: either the mapping produces one of the identifier fields that destination accepts, or the sync names the identifier kind outright in the destination’s own settings. With neither, the sync is refused when you save it — rather than failing once per person, later, on a queue.

Hashing rules are the same here as everywhere else, and the usual mistake is hashing the value as stored: lowercase and trim an email before SHA-256, or the digest will not be the one the platform is matching against. Match Keys & Identifier Hashing has the normalisation each platform expects.

Setting it up

Attributes is a step when you create a sync, and a card on the sync’s page afterwards. It holds:

SettingWhat it does
StoreThe Store to read. Stores that do not hold this audience’s people are shown greyed out, with the reason
AttributesThe Store fields to read, and a fallback value for any of them, used when the Store holds no such field for that person. The same field cannot be selected twice
When there is no matchDeliver without the attributes, or Send nothing at all
Lookup timeoutHow long one lookup may take: between 50 ms and 2000 ms, 250 ms by default
CacheHow long a lookup is remembered in memory, 60 seconds by default. A miss is remembered too — an id the Store does not hold is the most repeated lookup there is — but an unreachable Store never is, so one bad second does not become a bad minute
MappingThe destination fields to send, and where each value comes from. Choosing a Store field decides what is read; this decides what is sent — a field selected above and left out here is fetched on every change and reaches nobody, so the step says so while you are still looking at it

Anything that would otherwise save cleanly and then fail quietly, one person at a time, is refused at this point instead: a Store that is not yours or does not exist; a Store that does not hold this audience’s people; an attribute no feed writes into that Store (the message names it and lists what the Store can supply); two attributes landing on one name; a mapping naming something the change will not carry; a timeout outside the range above.

That last one is not cosmetic. Below 50 ms a healthy lookup times out on ordinary jitter, every person takes the miss path, and under Send nothing at all you have a sync that silently delivers nothing at all.

How fast

These are targets, not guarantees. They describe the path when everything is healthy; nothing in the product promises them, and nothing alerts on them.

FromToTarget
The event arriving at Zeotapaudience.entered at your endpointa few seconds
The event that disqualifies someoneaudience.exited at your endpoint (entry_and_exit only)a few seconds

What actually sets the number is your destination: a change spends the queue and the evaluation in single-digit seconds and then waits on your endpoint’s own response. A slow endpoint is the whole latency.

Two things are deliberately not fast, because they are not late — they are waiting for an event:

  • Somebody whose answer changed while nothing happened to them is sent at their next event, whenever that is. That is the boundary above, not a delay.
  • A brand-new or freshly edited condition sends nobody until the tracked history covers the period it asks about. The sync page says when that is.

Seeing all of them

Open Activate in the left navigation and select Realtime Syncs. It sits under Syncs, which lists the scheduled syncs, and appears in workspaces with realtime audiences.

Realtime Syncs lists every realtime sync in the workspace, with its audience, its destination, what it sends, and its state. A paused sync shows why it was paused. Three columns show the last 24 hours for each sync: how many people Joined, how many Left, and how many could not be sent (Failed). A sync that only sends people as they join shows — under Left. Select a column heading to sort by it, so sorting by Failed puts the syncs that need attention first.

Use Status above the table to show only some syncs: Active, Paused, or Failed (24h), the syncs that could not send someone in the last 24 hours, including ones that are still active. Select more than one to see the syncs that match any of them, and select Clear all to show every sync again. Selecting a folder or searching narrows the list the same way.

Select a sync to open its own page. The audience’s Realtime syncs tab shows the same columns for that audience’s syncs.

Watching one

The sync’s own page has three tabs, and each answers a different question.

TabThe questionWhat it shows
OverviewIs it moving?Activity — how many people joined, left, could not be sent, are not identified yet, and are waiting on data, over the last hour and the last day, with a chart of the last 24 hours. Select any of the four figures to open what sits behind it: the deliveries that ran out of attempts under Failed, the two stuck counts under Waiting, and — for a sync that reads a Store — how many were enriched, missed and skipped under Joined
DeliveriesWhat did we send this person?Every change this sync acted on for one identifier, newest first, and whether each one was actually sent
PlaygroundWhat would we send this person?A dry run through this sync’s own steps for one identifier — the Store read, the mapped attributes and the exact request — without sending it

Beside the Activity figures is a Configuration column: the audience, the destination, what this sync sends, its destination settings and its attributes, including how fresh those attributes are. Close it with the control in its heading if you want the chart to have the full width.

Two readings worth knowing:

  • Not identified yet counts people the sync could not name to a destination. A person known only by an anonymous device id has no identifier to send under; once an identify event links that device to a user_id, their next event sends them under it.
  • Sending from partial history until …, when it appears, means a condition in the audience looks further back than this workspace has been tracking it. People are still sent — from what has been recorded so far — and the time given is when the full stretch is covered. Until then, somebody who would qualify only on activity older than the tracking joins later rather than now. The count can only be short, never long, so nobody is sent who should not be.
  • Waiting on data counts people the sync could not answer for at all. That happens when a condition in the audience refers to something nothing is recording yet — usually an event declared moments ago, or one whose declaration was removed. It normally clears within a minute or two by itself; if it does not, the condition is pointing at something that no longer exists, and the audience needs editing.

Editing the audience

Changing which realtime event conditions an audience uses — adding one, removing one, or changing how far back one looks — starts the sync’s memory over. Nobody is sent as a departure because of the edit, and everyone who still qualifies is sent again as a join at their next event. Destinations treat that as adding somebody who is already there, so it is safe.

An edit can leave people behind in the destination. Someone who qualified under the old conditions and does not qualify under the new ones is never sent as a departure, because the sync no longer has a record of them to compare against. Under join and leave, this is the one case where the destination can hold somebody the audience no longer does. If that matters, remove them in the destination.

Any other edit — changing an and to an or, editing a condition that is not a realtime event, renaming the audience — leaves the memory alone, so departures are sent as usual.

When a destination’s authorisation expires

Some destinations sign in with OAuth: a webhook set up with the OAuth2 client credentials method, for example. The platform fetches the access token for the sync and replaces it before it expires. You do nothing.

If the provider stops accepting the destination’s credentials (they were revoked, rotated elsewhere, or the client was disabled), the sync does not fail person by person. This happens instead:

  1. At once. The destination is marked Re-authenticate and the workspace’s admins are emailed, once. The sync stays active. Its page shows Degraded: N updates not delivered since the time it began.
  2. While it lasts. Changes for this sync are not sent and not queued. Each person is put right at their next event after the destination works again. Someone who joined and left in that time needs nothing and is sent nothing. Someone who changed and then does nothing more stays as they were at the destination until their next event.
  3. After an hour, or 1,000 changes not delivered. The sync is flagged, and its Failures list says when it will be paused. An alert rule using the Sign-in outage trigger is notified at this point.
  4. After 24 hours, or 10,000 changes not delivered. The sync pauses itself, with the reason.

These are the defaults. To flag or pause sooner or later in your workspace, set them under Settings → Realtime syncs → Sign-in outages, in the Destination & alerts section. Each of the four numbers can be changed on its own, and a field left empty keeps its default. The pause can’t come before the flag.

To fix it, reconnect the destination: save working credentials on it. The destination returns to Connected, and any sync that paused itself for this reason resumes on its own. A sync you paused yourself stays paused.

A destination that receives nothing for a long time is still checked once a day, so you hear about a dead authorisation before the next person needs it.

Pausing, resuming and deleting

Pause stops the sending and leaves everything else alone. On Resume, each person’s next event is compared against what was recorded before the pause, so nobody is sent twice and nobody is missed except while it was paused.

A sync can also pause itself, after repeated delivery failures. It says so, with the reason. Fix the destination, then resume.

Deleting a sync does not take anyone out of the destination. It stops the sending. Whoever has already been sent stays where they are, and removing them is done in the destination.

After you delete a sync, you return to Realtime Syncs.

What this is not

  • Not a scheduled sync. There is no schedule and no run history — a realtime sync sends one person at a time and keeps no runs. If you want a list in a destination, keep the audience free of realtime event conditions and sync it on a schedule.
  • Not a backfill. Creating a sync sends nobody. People arrive as their events do.
  • Not a replacement for the Membership API. A sync tells a destination what an event showed; the Membership API answers what is true right now. For someone the sync has not re-evaluated since their answer changed, the two can disagree — and the sync’s contract is what an event showed.

What is not sent

The fixed payload, plus whatever you mapped, is the whole of it. In particular:

  • No attributes you did not map. A change carries the person’s values only where you configured a Store read and a mapping, and what it carries is as fresh as the Store rather than as fresh as the event — see Attributes and mapping. For a value as of the event, read the Profile API when the change arrives.
  • Nobody who has only a device id. A person known only by an anonymous id is counted under Not identified yet and sent to nobody, because there is no identifier a destination could act on. They are sent under their user_id at their next event after an identify.
  • No exits under entry_only. They are recorded — the sync knows — and the person lookup shows them as not sent.
  • Nobody, while a condition has nothing behind it. If a condition refers to something nothing is recording, the sync sends nothing at all for that audience and counts it under Waiting on data. A condition that is merely younger than it looks back does not stop anything — see Sending from partial history until … above.
  • Nothing on delete. Deleting a sync removes nobody from the destination.
  • No per-sync feed of every delivery. The three views on the sync page are what is kept: hourly counts, one person’s history, and the failures that ran out of attempts.

Next steps

Last updated on