You can't improve what you can't measure, and retention is the metric that matters most to growth. Amplitude's Retention chart shows you exactly which users come back—and which don't. Pick a cohort event (like signup), pick a return event (like active session), and Amplitude does the rest. You get a table showing day-by-day comeback rates broken down by cohort.
Create Your Retention Chart
The Retention analysis in Amplitude takes two inputs: the event that defines your cohort (day zero) and the event that indicates a return visit. From there, Amplitude builds the table automatically.
Step 1: Navigate to Charts and select Retention
Click Charts in the left sidebar. Click Create and select Retention from the chart type options. Amplitude opens the retention builder.
Step 2: Define your cohort event
In the Starting Event field, choose the event that marks the beginning of a user's lifecycle. This is usually signup, app_open, first_action, or trial_start. All users are grouped by the date they first triggered this event.
import * as amplitude from '@amplitude/analytics-browser';
amplitude.init('API_KEY');
// Track the cohort event—this establishes day zero
amplitude.track('signup', {
plan_type: 'free',
signup_source: 'organic'
});Step 3: Select your return event
In the Return Event field, pick the event you want to count as a return. For SaaS, this is often session_start or dashboard_view. For ecommerce, it might be purchase or checkout_started. Amplitude checks if each user fired this event on day 1, day 7, day 30, etc.
Step 4: Choose your time bucket
Select Days, Weeks, or Months. Days is the default—each column represents a calendar day relative to the cohort date. Weeks and months are useful for longer-term retention trends.
Step 5: Run and inspect
Click View. Amplitude renders a table. Rows are cohorts (grouped by signup date), columns are days since signup. Each cell shows the percentage of that cohort that returned. Hover over a cell to see the exact user count.
Segment and Filter for Insight
Raw retention is a start, but you'll want to slice by user properties. Did free-tier users retain differently than paid? Do new users from ads perform worse than organic?
Step 1: Add a property segment
Click + Segment below the retention builder. Select a user or event property like device_type, country, utm_source, or paid_plan. Amplitude splits the table into tabs, one per segment value. Switch tabs to compare.
Step 2: Filter to a specific cohort
Click + Filter and select a property from your starting event. For example, filter to users whose signup had plan: 'enterprise'. Now you see retention only for enterprise signups—useful when one cohort dominates the numbers and masks patterns in smaller groups.
// Include plan and campaign data on your cohort event
amplitude.track('signup', {
plan: 'pro',
utm_campaign: 'jan_promo',
region: 'EU',
referred_by: 'partner'
});Step 3: Export the data
Click the ⋯ menu in the top right and select Export. Amplitude generates a CSV of the entire table. Open it in a spreadsheet to calculate averages, plot curves, or build your own visualizations.
Access Retention Data via API
If you need retention data in code—to feed a dashboard, trigger alerts, or log trends—use Amplitude's REST API to pull cohort and event data.
Step 1: Call the Funnels API to model retention
Retention is a two-step funnel: step 1 is your cohort event, step 2 is your return event. Call the /api/2/funnels endpoint with your events and date range. Amplitude returns conversion counts for each step—use these to calculate retention rate.
const apiKey = 'YOUR_API_KEY';
const secretKey = 'YOUR_SECRET_KEY';
const auth = Buffer.from(`${apiKey}:${secretKey}`).toString('base64');
const payload = {
start: '2026-01-01',
end: '2026-03-26',
funnel: [
{ event: 'signup' },
{ event: 'session_start' }
]
};
const response = await fetch('https://api.amplitude.com/api/2/funnels', {
method: 'POST',
headers: {
'Authorization': `Basic ${auth}`,
'Content-Type': 'application/json'
},
body: JSON.stringify(payload)
});
const data = await response.json();
const signupCount = data.steps[0].count;
const returnCount = data.steps[1].count;
const retentionRate = (returnCount / signupCount) * 100;Step 2: Handle rate limits and cache
Amplitude's API is rate-limited. Don't call it on every request. Instead, cache the result and refresh on a schedule—e.g., once per day via a cron job. Store the retention rate in your database so your dashboard queries local data, not the API.
Common Pitfalls
- Choosing the wrong cohort event. If you pick
page_view, every page view creates a new cohort. Use something intentional likesignuporaccount_created. Events that fire too frequently create noise. - Confusing retention with repeat visits. A user who returns once counts as retained. A user who returns ten times also counts as retained. Retention is binary—either they came back or they didn't.
- Ignoring time zone shifts. Amplitude applies your project time zone to all cohort dates. If your users span multiple countries, day boundaries may not match their local midnight.
- Filtering too aggressively and losing statistical power. If you drill into a tiny segment (e.g., just Friday signups from France), sample size shrinks and percentages become unreliable. Keep cohorts above 100 users.
Wrapping Up
Amplitude's Retention chart is the fastest way to answer the question every product leader asks: *who stays?* Define your cohort event, pick your return event, and you get instant visibility into user stickiness—segmented, filterable, exportable. If you want to centralize retention tracking across all your tools and automate alerts when retention drops, Product Analyst can help.