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.
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.
| Mode | What the destination is told |
|---|---|
| Send people as they join | The destination hears as soon as an event shows someone qualifies, and nothing else. |
| Send people as they join and as they leave | The 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
- 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.
- Choose Create realtime sync. The flow has four steps, the same as creating a scheduled sync; starting from an audience skips the first.
- Select audience. Pick the realtime audience whose people are sent. You can search by name or description.
- 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.
- 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.
- 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.
| Destination | What a change becomes | What you configure on the sync |
|---|---|---|
| Webhook | One POST carrying the fixed payload below | Nothing — the URL, method, headers and sign-in (an authorization header, an API key, or OAuth2 client credentials) are on the destination |
| Braze | One POST /users/track that records audience membership on the person, sends a custom event, or both | Which of those, and their names |
| Zapier | One POST of the fixed payload to the Zap’s Catch Hook | Nothing — the hook URL is on the destination |
| HTTP Request | One request of the fixed payload, with the destination’s method and headers | Nothing — the URL, method, headers and credentials are on the destination |
| Azure Functions | One request of the fixed payload to the function URL | Nothing — the function URL, method and key are on the destination |
| Google Cloud Functions | One request of the fixed payload to the function URL | Nothing — the function URL, method, headers and token are on the destination |
| MoEngage | One Track User call that sets a yes/no user attribute on the person | The attribute’s name, and whether to create people MoEngage does not know |
| Rudderstack | One identify that sets a yes/no trait on the person | The trait’s name |
| mParticle | One event batch that sets a yes/no user attribute on the person | The attribute’s name, and which mParticle identity the destination key is |
| Pendo | One custom-field update that sets a yes/no visitor field | The field’s name |
| Segment | One identify that sets a yes/no trait on the person | The trait’s name |
| Customer.io | One update of the person that sets a yes/no attribute | The attribute’s name, and whether to create people Customer.io does not know |
| CleverTap | One profile upload that sets a yes/no profile property | The 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:
| Setting | What it does |
|---|---|
| What Braze receives | Membership, a custom event each time someone joins or leaves, or both |
| Audience membership attribute | The 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 value | The 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 / leaves | The custom events sent, when events are on. audience_entered and audience_exited unless you change them |
| People Braze does not know yet | Off, 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
200before 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 setting | What a realtime sync does with it |
|---|---|
| Endpoint URL | Sends to it |
| HTTP Method | POST, 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 Type | JSON. A destination set to form encoding is refused when you create the sync: the payload is nested and has no form rendering |
| Batch Mode | Ignored. A realtime sync always sends one person per request |
| Custom Headers | Sent with every request |
| Authorization header / API key | Sent 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 authentication | What is sent |
|---|---|
| Function Key | The key in the x-functions-key header |
| API Key | The key in the x-functions-key header |
| Bearer Token | Authorization: Bearer <token> |
| None | No 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 authentication | What is sent |
|---|---|
| Bearer Token | Authorization: Bearer <token> |
| API Key | The key in the X-Api-Key header |
| None | No credential, for a public function |
| Service Account | Authorization: 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
| Setting | What it does |
|---|---|
| MoEngage user attribute | The 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 yet | Off (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
| Setting | What it does |
|---|---|
| Trait name | The 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
| Setting | What it does |
|---|---|
| User attribute | The user attribute set to true on join and false on leave |
| What the destination key is in mParticle | The 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
| Setting | What it does |
|---|---|
| Pendo custom field | A 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
| Setting | What it does |
|---|---|
| Trait name | The 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
| Setting | What it does |
|---|---|
| Customer.io attribute | The 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 yet | Off (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
| Setting | What it does |
|---|---|
| CleverTap profile property | A 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
}| Field | What it is |
|---|---|
type | audience.entered or audience.exited |
sync_id | The sync that sent it — how a shared endpoint tells two syncs apart |
audience | The audience’s id and its name at the moment of the change |
user_id | Who it is about. Always present: this is the identifier the destination knows them by |
anonymous_id | The device the triggering event came from, when there was one. Usually null, and never what the change is keyed on |
occurred_at | When the event that caused the change happened — not when it was sent |
sequence | Microseconds, 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
2xxis success. A4xxmeans “do not send this again” and stops the retries; a5xx, a408or a429means “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.
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:
- One lookup in the Store, by the destination key — the same
user_idthe 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. - The mapping runs over the change and whatever the lookup returned.
- 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
| Source | Paths |
|---|---|
| The person | user_id |
| The audience | audience.id, audience.name |
| The change itself | transition.kind, transition.occurred_at, transition.sequence |
| The Store | store.<attribute>, one for each attribute you selected |
| System values and constants | The 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 field | Value |
|---|---|
tier | store.plan, through Uppercase |
hashed_email | store.email, lowercased and then SHA-256 |
ltv | store.ltv |
audience | System 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.
| Setting | What 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 all | The 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):
| Count | What it means |
|---|---|
| With attributes | The Store had an entry, and the attributes went out with the change |
| Sent without attributes | The Store had nothing, and the change went out without them |
| Not sent, no attributes | The 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:
| Setting | What it does |
|---|---|
| Store | The Store to read. Stores that do not hold this audience’s people are shown greyed out, with the reason |
| Attributes | The 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 match | Deliver without the attributes, or Send nothing at all |
| Lookup timeout | How long one lookup may take: between 50 ms and 2000 ms, 250 ms by default |
| Cache | How 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 |
| Mapping | The 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.
| From | To | Target |
|---|---|---|
| The event arriving at Zeotap | audience.entered at your endpoint | a few seconds |
| The event that disqualifies someone | audience.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.
| Tab | The question | What it shows |
|---|---|---|
| Overview | Is 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 |
| Deliveries | What did we send this person? | Every change this sync acted on for one identifier, newest first, and whether each one was actually sent |
| Playground | What 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
identifyevent links that device to auser_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:
- 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.
- 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.
- 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.
- 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_idat their next event after anidentify. - 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
- Realtime audiences — writing the audience a sync watches
- Membership — the pull side of the same plane
- Realtime events — declaring the events everything here is triggered by
- Stores — the by-key attribute cache a sync reads its attributes from
- Field transforms — the transform vocabulary a mapping uses
- Repeated events and counts — why an event received twice does not move a person twice