Event frequency tells you how often users perform specific actions—like signing in, viewing a product, or completing a checkout. Without measuring it, you're flying blind on engagement. Amplitude makes it straightforward to track, analyze, and act on frequency data.

Understanding Event Frequency

Event frequency is simply the count of how many times an event occurs within a time period.

Know what event frequency measures

Event frequency tracks the number of times a user (or group of users) triggers a specific event. It answers questions like: How many times did users view a page today? How often is a feature actually used? Are power users doing something 10x more than casual users? This is the foundation for understanding engagement.

javascript

// Track an event each time a user takes an action
amplitude.track('View Product', {
  product_id: '12345',
  category: 'Electronics',
  timestamp: new Date().getTime()
});

// Track another event - frequency is measured by how many times this fires
amplitude.track('Add to Cart', {
  product_id: '12345',
  cart_value: 99.99
});

Each track() call increments the frequency for that event

Understand frequency vs. unique users

Don't confuse frequency with unique users. Frequency is total event count. If 10 users each add to cart once, that's 10 frequency. If 1 user adds to cart 10 times, that's also 10 frequency. Amplitude distinguishes between these—Total shows sum of all events, Uniques shows distinct users.

javascript

// Use Amplitude REST API to query event frequency
const fetchEventFrequency = async (eventName, startDate, endDate) => {
  const response = await fetch('https://amplitude.com/api/2/events', {
    method: 'POST',
    headers: {
      'Authorization': `Bearer ${AMPLITUDE_API_KEY}`,
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({
      event_type: eventName,
      start_day: startDate,
      end_day: endDate
    })
  });
  const data = await response.json();
  return data;
};

fetchEventFrequency('View Product', '20260101', '20260131');

The API returns total event frequency for the specified date range

Watch out: Event frequency can be inflated by bots or accidental repeated actions. Always filter your analysis to real user actions.

Measuring Event Frequency in Amplitude

Use Event Analysis to view frequency

In Amplitude, go to Events > Event Analysis. Select your event, choose a date range, and the report shows total frequency (event count) over time. You can also break it down by user properties using the By dropdown to see frequency per segment.

javascript

// SDK code to ensure events are tracked consistently
const trackUserAction = (eventName, properties = {}) => {
  amplitude.track(eventName, {
    user_tier: getUserTier(),
    feature_enabled: isFeatureActive(),
    ...properties,
    tracked_at: new Date().toISOString()
  });
};

// Usage in your app
trackUserAction('Feature Used', { feature_name: 'Export', duration_ms: 1200 });

Consistent event tracking with properties ensures accurate frequency reporting

Build custom frequency metrics with Amplitude Chart

Create custom queries in Amplitude > Chart. Use the query builder to count events, group by time or user properties, and filter by segments. You can compare frequency between user cohorts—e.g., 'How often do premium users use the API vs. free users?'

javascript

// Track subscription tier to enable segmentation in Amplitude
amplitude.track('API Request', {
  subscription_tier: user.plan, // 'premium' or 'free'
  endpoint: '/analytics',
  response_time_ms: 145
});

// Now in Amplitude Chart, filter by subscription_tier
// and compare frequency (event count) between segments

Include segment identifiers in event properties for grouping in Amplitude Chart

Create cohorts based on event frequency

Use Cohorts > Create and define cohorts by event frequency thresholds. For example, 'Users who trigger [Event] more than 10 times per week' or 'Users who haven't triggered [Event] in 30 days.' These cohorts let you target messaging, A/B tests, or support workflows.

javascript

// Check if user is in a high-frequency user cohort
const isHighFrequencyUser = (user) => {
  // In practice, this comes from Amplitude Cohorts via your backend or CDP
  const cohortMembership = getCohortMembership(user.id, 'high_engagement');
  return cohortMembership ? true : false;
};

if (isHighFrequencyUser(currentUser)) {
  amplitude.track('Power User Activity', { cohort: 'high_engagement' });
}

Amplitude cohorts sync to your app, enabling personalization based on frequency

Tip: Use event properties (like user_tier, feature_flag) to slice frequency data without creating separate events. This keeps your event taxonomy clean.

Using Event Frequency for Product Decisions

Spot engagement drops using frequency trends

A sudden drop in event frequency is often your first signal of a problem. Track View Product frequency daily—if it drops 40% overnight, something broke. Use Amplitude Chart with a 7-day or 30-day rolling average to filter out noise.

javascript

// Set up alerts by querying frequency via API
const checkFrequencyAnomaly = async (eventName, threshold) => {
  const today = new Date();
  const yesterday = new Date(today.getTime() - 24 * 60 * 60 * 1000);
  
  const todayFreq = await fetchEventFrequency(eventName, today, today);
  const yesterdayFreq = await fetchEventFrequency(eventName, yesterday, yesterday);
  
  const percentChange = ((todayFreq - yesterdayFreq) / yesterdayFreq) * 100;
  
  if (Math.abs(percentChange) > threshold) {
    console.warn(`Alert: ${eventName} frequency changed ${percentChange}%`);
  }
};

await checkFrequencyAnomaly('View Product', 30);

Monitor frequency changes to catch engagement issues early

Identify power users and churn risk

Compare event frequency between user segments. Users with high frequency (daily active, multiple events per session) are power users. Users whose frequency dropped to zero in the last 7 days are churn risks. Use these insights to segment campaigns and retention efforts.

javascript

// Track feature usage frequency to identify power users
amplitude.track('Dashboard Loaded', {
  user_id: user.id,
  dashboard_views_this_month: user.dashboardViews,
  days_since_signup: calculateDaysSinceSignup(user.created_at)
});

// In Amplitude Cohorts, create:
// "Dashboard Loaded frequency > 20 in last 30 days"
// This identifies power users for VIP support or feature beta access

Frequency cohorts separate power users from casual users

Common Pitfalls

Forgetting to account for time period. 10 events per day is very different from 10 events per year. Always specify the time window when reporting frequency.
Mixing up event frequency with unique users. If a feature has high frequency but low unique users, it means a few users are heavily using it (possibly power users or excessive testing).
Not filtering out non-human traffic. Bots, test accounts, and internal team activity will inflate frequency numbers. Set up filters in Amplitude to exclude them before analyzing.
Tracking the same action multiple times. Make sure your SDK isn't firing the same event twice per action, which artificially inflates frequency and skews your insights.

Wrapping Up

Event frequency is your window into how engaged users really are. By tracking it consistently in Amplitude, segmenting by user properties, and monitoring trends, you spot engagement changes before they become churn. If you want to track this automatically across tools, Product Analyst can help.

What Is Event Frequency in Amplitude

Understanding Event Frequency

Know what event frequency measures

Understand frequency vs. unique users

Measuring Event Frequency in Amplitude

Use Event Analysis to view frequency

Build custom frequency metrics with Amplitude Chart

Create cohorts based on event frequency

Using Event Frequency for Product Decisions

Spot engagement drops using frequency trends

Identify power users and churn risk

Common Pitfalls

Wrapping Up