Persisted Properties

Property persistence helps teams create consistent, reliable reporting across Amplitude by controlling how long event property values like page path or search term remain attached to events. Persistence makes sure that context, such as which campaign, channel, or merchandising asset drove engagement, remains available across the entire user journey. Go to the Verify persisted properties page to confirm that your persisted properties are working correctly.

For example:

• Marketing teams can persist page path values across multiple sessions to understand campaign effectiveness over time.
• Merchandising teams can use item-level attribution to attribute revenue to the search term, recommendation, or promo that drove each item in a cart.

Persisted properties operate on event properties

Persisted properties only persist event properties. They don't read user properties, and they don't update the user profile. Amplitude evaluates them at query time and applies allocation and expiration rules to event-level data for analysis.

That distinction matters when you instrument tracking. If the data you want to persist arrives only as a user property, for example, marketing attribution that some integrations only set at the user level, Amplitude can't use it as an input to a persisted property. To make a value available, capture it as an event property on the events you care about. The Amplitude Browser SDK can do this automatically for marketing attribution. Refer to Capture event properties from the SDK.

What persisted properties are and aren't

Persisted properties aren't user properties and don't represent long-lived user state. Amplitude evaluates them at query time and applies allocation and expiration rules to event-level data for analysis. Persisted properties don't update the user profile, don't mutate user state, and don't replace core event or user properties. Their purpose is to control how Amplitude applies context such as marketing or merchandising data during analysis.

What property persistence does

Property persistence defines which property values "stick" beyond the event where they were first experienced and how long they remain valid.

Instead of requiring every event to include its own source or merchandising data, Amplitude can remember the property value and apply it automatically to later events until it expires or Amplitude replaces it.

Property persistence is especially useful in marketing and merchandising analysis, where you want to connect early engagement with later outcomes.

User properties compared to persisted properties

Key concepts

Allocation types

Allocation decides which property value should "stick" across a series of events for the same user. Amplitude provides the following allocation types:

• Original: The property value Amplitude captures when it first creates the entity. Typically, the original value occurs at the point of account creation or initial identification. The original value persists and never changes.
• Most recent: Always the latest value of a property within a defined or active tracking window. Typically, the most recent value is the most recent event or session. Most recent data values are dynamic and shift as Amplitude collects new data.
• First known: The earliest value recorded for that property, regardless of the entity's creation date. If data collection starts after the creation date, the first known value can come from a later point in time than the Original value. Applies to all events before and after.
• Last known: The most recent value of a property at any given point in time. Last known values are dynamic and shift as Amplitude collects new data. However, if Amplitude can't collect data, the Last known value may differ from the true state of the property. Applies to all events before and after.

The table below displays an example of a user's activity, from sign-up through page views to purchase. The first column shows the events and property values as they exist in the dataset. The remaining four columns show different allocation methods and how property values change under each method.

● = Property value present on the event ◌ = Property value filled by allocation

Expiration

Expiration defines when a persisted property value stops applying.

Common use cases

Persisted properties make sense any time you want analysis to reflect context from earlier (or later) events than the one being measured. The patterns below come up repeatedly across marketing, merchandising, experimentation, and media analytics.

• Entry-page attribution. Group conversions by where the session originally started, even when the conversion event doesn't carry Page Path. Config: Page Path + Original + Session.

• Campaign attribution across sessions. Connect early marketing touchpoints to later conversions without forcing every event to carry UTMs. Pairs well with Browser SDK 2.40 event-property attribution tracking. Config: utm_campaign (or similar) + Original + Custom time, for example 30 days.

• Item-level discovery attribution. Each item in a cart keeps its own discovery source — search, recommendation, or homepage hero — so revenue attributes to the right surface per product. Refer to Advanced: Item-level attribution. Config: discovery_method + Most recent + Session + item-level binding.

• A/B test exposure persistence. Carry the variant a user saw forward to all downstream events, even when the experimentation platform only stamps the variant on the exposure event itself. Config: experiment_variant + Original or Most recent + Session or User.

• Channel attribution that ignores internal navigation. Persist the channel that brought a user in without letting internal page-to-page clicks overwrite it. Refer to Filter internal referrers from attribution. Config: channel property + Most recent + Session + Excluded values.

• Retroactive attribution when properties arrive late. First known and Last known apply values to events that already happened, not just events going forward. Useful when the trigger event and its attribution data don't arrive together:

  • Mobile install attribution. New User and install events often land in Amplitude before the MMP (AppsFlyer, Adjust) sends the attribution event. A persisted property with Last known allocation attaches the source back to the install, so you can measure which campaign drove each install.
  • Streaming and media metadata. Real-time play events fire during a session, but properties like program, genre, or content_id are often only sent at session close. A persisted property with Last known allocation applies that metadata backwards to every play event in the session.

  Config: attribution or metadata property + Last known (or First known) + Session or a longer window.

Capture event properties from the SDK

Persisted properties read from event properties, so the upstream question is making sure the values you want to persist arrive as event properties in the first place.

Marketing attribution (Browser SDK 2)

Browser SDK 2.40.0 introduces an attribution tracking method that automatically attaches UTM parameters, referrer, referring domain, and click identifiers (for example gclid, fbclid) to every event as event properties — making them eligible inputs for persisted properties.

Set config.autocapture.attribution.trackingMethod to 'eventProperty' when initializing the SDK:

import * as amplitude from '@amplitude/analytics-browser';

amplitude.init('AMPLITUDE_API_KEY', {
  autocapture: {
    attribution: {
      trackingMethod: 'eventProperty',
    },
  },
});

For details, including the optional fallbackAttributionEvent heartbeat for single-page apps and how to run user-property and event-property tracking together during migration, refer to Event property tracking in the Browser SDK 2 documentation.

Auto-captured page and interaction properties

When you enable Autocapture, Amplitude automatically captures event properties such as Page Path, Page URL, Page Title, Element Text, and File Name on the relevant events. Any of these can become an input to a persisted property — for example, persisting Page Path with Original allocation captures the entry page that started the session.

Custom event properties

You can persist any event property your team sends, including custom properties such as discovery_method, experiment_variant, or internal_search_term. As long as the value travels on at least one event for the user, persisted properties can carry it forward.

Set up persisted properties

The following section contains examples for using the Persistence and Advanced settings. Review each one as they apply to different ways you can implement persisted properties.

1. Navigate to the Properties section of Data Settings and then click to create a new persisted property. Give this persisted property a name, such as Entry Page. In the description, provide additional information such as the allocation method and expiration. The description helps make sure that anyone using this property in a chart or data table understands the configuration.
2. Select the event property you want to persist. For this example, use Page Path.
3. Choose an Allocation method. In the example, because you want to identify the Entry Page, select Original. Selecting Original makes sure you include the first touchpoint.
4. Set the Expiration. By default, the persisted property expires at the end of the session.
5. (Optional) Configure Excluded values. Add any property values you want the persisted property to ignore — for example, internal traffic markers, test values, or specific channels you don't want to overwrite the persisted source. Amplitude doesn't treat excluded values as new property values during allocation, so a previously valid value continues to persist through them. For a common use case, refer to Filter internal referrers from attribution.

If your analysis involves merchandising (item-level attribution), refer to the Advanced: Item-level attribution section. Otherwise, go to Use persisted properties across analyses.

Filter internal referrers from attribution

When a user navigates within your own site, the referrer is your own domain. If you classify referrers into channels and persist that channel with Most recent allocation, every internal page-to-page click can overwrite the original marketing source — attribution flips to "internal" or "direct" the moment the user moves to a second page.

Use Excluded values on the persisted property to skip internal navigation during allocation. The previously valid value — the campaign or external referrer that originally brought the user in — continues to apply through any internal events.

set up a filter for internal referrers:

1. Create a channel in Data → Channels that classifies your traffic sources. Add a definition that maps your own domain (in the referrer event property) to a channel value such as internal.
2. Create a persisted property in Data → Properties that uses your channel as the event property. Set Allocation to Most recent and Expiration to match your analysis (commonly Session).
3. In the persisted property's Excluded values field, add the channel value you want to ignore — for example, internal. Persisted properties treat excluded values as if the property weren't on the event at all, so allocation rolls forward from the previous valid value.
4. Use the persisted property in your charts. Internal navigation no longer resets the persisted source; the original campaign or referrer continues to attribute downstream events such as Add to Cart or Purchase.

The same pattern works for any value you want allocation to ignore — internal QA traffic, bot signatures, or test events — not just internal referrers.

Achieve last non-direct touch attribution

Last non-direct touch attribution assigns credit to the most recent marketing channel a user engaged with before converting, skipping over direct visits. Persisted properties can replicate this model.

This is the attribution model used for user-scoped and session-scoped dimensions in Google Analytics.

How it works

Persisted property allocation automatically skips events where the property has no value, so direct visits with no channel value don't overwrite the persisted source. If a user enters through Paid Search, browses, returns directly later, and converts, the conversion event still attributes to Paid Search.

The setup combines two configurations:

• A channel classifier that doesn't assign "Direct" as a catch-all fallback. Direct sessions arrive without a channel value rather than with a Direct value.
• A persisted property that renames (none) to "Direct" for display, so genuinely unattributed users still appear under a named value rather than blank.

Set up the persisted property

1. Go to Data → Properties and create a new persisted property.
2. Select your channel classifier output (for example, Marketing Channel) as the event property.
3. Set Allocation to Most recent.
4. Set Expiration to a window that matches your business cycle, such as 7 days.
5. In Rename (none) values, enter Direct. Users with no attributed channel display as "Direct" rather than blank.

Configure the channel classifier

In Data → Channels, make sure your classifier defines explicit rules for each channel — Paid Search, Organic Social, Email, and so on. Don't add a catch-all rule that assigns Direct to everything else. With no catch-all, direct sessions arrive without a channel value, and the persisted property carries the most recent non-direct channel forward.

Supported metrics

This approach works with Event Totals, Session Totals, and Unique counting mechanisms in Data Tables. Amplitude doesn't support changing the attribution method within data tables when you use a persisted property as a group-by, so multi-touch attribution models don't apply.

Related pattern: Excluded values for named traffic

If you want to skip specific named values during allocation — for example, an "internal" channel for same-domain referrers, QA traffic, or bot signatures — use Excluded values on the persisted property. Refer to Filter internal referrers from attribution. The Rename (none) approach above is the right tool when direct visits arrive as fully unattributed sessions; Excluded values is the right tool when allocation needs to skip a specific value the classifier emits.

Verify the setup

After you configure the property and the classifier, follow the verify persisted properties guide to confirm direct visits don't overwrite the persisted channel for users who arrived through marketing.

Advanced: Item-level attribution

Item-level attribution typically powers merchandising analyses. It ties a persisted property to a specific item inside a cart event, rather than to the user or the session as a whole. When a cart contains multiple items, each item keeps its own persisted context (the search term, recommendation, or promo that influenced that specific item). Metrics such as Revenue reflect the source that drove each item individually.

This is the configuration that powers the Product Discovery hub in Out-of-the-box E-commerce Analytics.

For example, a single cart contains three items, and the user discovered each one a different way:

• The user discovered Item 1 through Search.
• The user discovered Item 2 from the Popular Products display.
• The user discovered Item 3 from Recommendations.

Without item-level attribution, Amplitude credits all conversion events for the entire order to a single discovery method. With Original allocation, on-site Search receives all the credit. With Most Recent, Recommendations receives the credit.

Item-level attribution instead credits the correct discovery method to each item in the cart.

Set up the persisted property

1. Create a new persisted property called Most recent Finding Method.
2. Select the event property you want to persist. For this example, use discovery_method.
3. Choose an Allocation method. Because you want the last touchpoint, select Most Recent.
4. To credit the first touchpoint instead, select Original.
5. Set the Expiration. By default, the persisted property expires at the end of the session.

After you create the property, configure item-level attribution.

Configure item-level attribution

1. Select the product identifier you use. Ideally, use an item property in an Object Array such as product.item_id. For more on object arrays, refer to Cart Analysis.
2. Select one or more linking events. These are events that carry both the persisted property value (such as discovery_method) and the item identifier (product.item_id). These are typically the events where the user interacts with an item, such as View Item Details, Home Hero Clicked, Promotion Clicked, Recommendation Clicked, or Add to Cart. Linking events let Amplitude tie the engagement signal to the specific item.

Amplitude then carries the persisted value forward to cart events (Add to Cart, Remove from Cart, Purchase) per item, using the product identifier as the join key.

Verify the setup

After you save the property, the persisted value appears as a column on the linking and cart events. Use the Verify a property with item-level attribution section of the verify guide to confirm each item shows the expected value.

Use persisted properties across analyses

After you define a persisted property (such as Entry Page or Most Recent Finding Method), Amplitude automatically applies it to upstream/downstream events based on the allocation and expiration rules you've configured. You don't need to manually re-attribute or make sure the original property exists on every event.

You can use persisted properties anywhere you select event properties in Amplitude:

• Data Tables: Group, filter, and break down rows by persisted properties.
• Event Segmentation: Segment, group by, or filter charts using persisted properties.
• Funnels: Apply persisted properties to funnel steps or as group-bys for downstream conversion analysis.
• Cohorts: Define audiences using persisted property values, including in inline cohorts.

Persisted properties appear in property selectors alongside standard event properties under the name you gave them in Data Settings (for example, Entry Page).

You can access the context you captured earlier wherever you analyze outcomes.

For example:

• Entry Page (Original, Session): A user lands on /mens-shoes, browses several pages, then completes a purchase. Even though the Purchase event doesn't include Page Path, your persisted Entry Page still displays /mens-shoes, letting you group purchases by where sessions originally started.

• Most recent Finding Method (Most recent, Session): A user first discovers a product through Search, later clicks a Recommendation, and finally adds the item to cart. Because you set the allocation to Most recent, the persisted value on Add to Cart and Purchase is Recommendation, reflecting the last touchpoint before conversion.

For merchandising teams using the advanced setup:

• Amplitude carries product-level context (such as Finding Method or homepage module) forward to cart and purchase events using the product identifier you configured.
• If a cart contains multiple items, each item keeps its own persisted value. Amplitude attributes revenue, AOV, and add-to-cart metrics to the correct source for each product.

This lets you:

• Group or filter outcome events (Add to Cart, Purchase, or Revenue) by persisted properties in data tables.
• Measure which entry pages, homepage modules, or recommendation zones drive conversions.
• Analyze results consistently across charts without rebuilding attribution logic each time.

Product Discovery hub

The Product Discovery hub in E-comm Analytics uses persisted properties to power its Which properties describe how users discover your product? breakdown. The hub lets you attribute purchases and revenue to the discovery method that influenced each item in the cart.

For example, if a user discovers one product through on-site search and another through a homepage recommendation, item-level attribution assigns revenue to the correct discovery source for each product individually.

To configure a persisted property for Product Discovery:

1. Create a persisted property that captures your discovery context. For example, Most Recent Finding Method using the discovery_method event property.
2. Set Allocation to Most Recent to capture the last discovery action before the cart event.
3. Set Expiration to Session so discovery context resets at the end of each session.
4. Enable Item-level attribution and select your product identifier (for example, product.item_id).
5. Select the events where both your discovery property and product identifier are present (for example, View Item Details or Add to Cart).

After you configure the property, select this persisted property in the Product Discovery hub under Which properties describe how users discover your product?. Amplitude uses item-level attribution to credit each item's revenue to the correct discovery source.

For a detailed walkthrough of setting up item-level attribution, refer to Advanced: Item-level attribution.

Multiple groupbys

You can group by more than one property in the same data table to combine persisted context with regular event data.

For example, you can group purchases by Entry Page and Most Recent Finding Method to understand how session entry points and discovery behavior work together.

Add additional groupbys by clicking Add top-level group-by at the top of a data table column.

When you include multiple properties in the same analysis, Amplitude evaluates each property independently.

If both properties are persisted:

• Amplitude populates each property using its own allocation and expiration rules.
• For example, Entry Page reflects where the session started (Original, Session), while Most recent Finding Method reflects the last discovery action before conversion (Most recent, Session).
• Both values appear on outcome events such as Add to Cart or Purchase, even if those events didn't originally contain them.

If only some properties are persisted:

• Persisted properties retain their computed values based on their configuration.
• Amplitude takes non-persisted properties directly from the outcome event being analyzed. For example, Entry Page comes from persistence, while Device Type comes from the Purchase event itself.

If none are persisted:

• All property values come as-is from the outcome events, with no carryover from earlier interactions.

You can combine journey context and event-level attributes in a single table, knowing that persisted properties keep their defined behavior while regular properties reflect what happened at the moment of conversion.

Availability and limitations

• You can use persisted properties in Data Tables, Event Segmentation, Funnels, and Cohorts.
• Support in Stickiness, Composition, Growth Accounting, Revenue LTV, Impact, and Customer Journeys is coming soon.
• Persisted properties don't appear on the user profile.
• Raw data exports such as BigQuery don't include persisted property values. Amplitude computes them at query time, not at ingest, so they aren't materialized on the underlying events.
• Data tables support a 6-month time range when you select a persisted property.

Attribution compared to persistence

Persistence controls how long property context remains available, while attribution controls how Amplitude assigns conversion credit. They solve related, but distinct, problems. You configure them independently.

If, after reading this article, the difference between attribution and persistence in Amplitude still isn't clear, review the following summary: