Mixpanel Autocapture: how do I turn it on and which events/properties does it collect by default?

Autocapture is the fastest way to get immediate value from Mixpanel—without manually instrumenting every click and pageview. Once it’s on, Mixpanel automatically tracks common user interactions and enriches them with useful properties, so product and web teams can start answering behavior questions in minutes instead of waiting on a full tracking plan.

The Quick Overview

What It Is: Autocapture is Mixpanel’s automatic event tracking for web (and supported frameworks) that records user interactions like page views, clicks, and form submissions, plus key context (browser, URL, device, etc.) with no or minimal code.
Who It Is For: Product, growth, and marketing teams who want to start exploring user behavior quickly—especially when they don’t yet have a full event taxonomy or engineering cycles to instrument every event.
Core Problem Solved: It eliminates the “blank state” problem and long implementation timelines by giving you immediate behavioral data, so you can explore funnels, retention, and flows without waiting for custom tracking.

How It Works

At a high level, Mixpanel Autocapture injects a lightweight tracking snippet into your app or site. That snippet listens for common UI interactions (like clicking, page loading, or submitting a form), packages those as Mixpanel events, and sends them to your project with a rich set of default properties about the user, device, and page context.

From there, you can:

Analyze Autocapture events in Insights, Funnels, Retention, and Flows reports.
Use default properties to segment behavior (e.g., by browser, device, or page).
Gradually layer in custom event instrumentation for high-value behaviors while Autocapture keeps feeding you broad coverage in the background.

A typical setup flows in three phases:

Enable Autocapture: Add the Mixpanel SDK (usually a JavaScript snippet or framework-specific module), turn Autocapture on in configuration, and verify events in the Live View.
Review & Configure: Confirm which default events and properties you want to keep, configure any privacy controls, and standardize naming where appropriate.
Analyze & Iterate: Start answering product questions with Autocapture data, then introduce custom events for key behaviors and refine your taxonomy over time.

How to Turn On Mixpanel Autocapture

The exact steps vary by platform, but the pattern is similar: install the SDK, enable Autocapture, then verify data. Below is a generalized walkthrough for a typical web setup with the JavaScript SDK.

1. Add the Mixpanel Snippet or SDK

In your frontend code (usually your main layout or entry point), include Mixpanel’s JavaScript library and initialize it with your project token:

<script type="text/javascript">
  (function(f,b){
    if(!b.__SV){
      var a,e,i,g;
      window.mixpanel=b;
      // ... standard Mixpanel snippet content ...
      mixpanel.init("YOUR_PROJECT_TOKEN", {
        api_host: "https://api.mixpanel.com",
        autocapture: true
      });
    }
  })(document, window.mixpanel || []);
</script>

Key points:

Replace YOUR_PROJECT_TOKEN with your actual token from Project Settings in Mixpanel.
Set autocapture: true in the init configuration to enable Autocapture (some implementations may default to true, but it’s good to be explicit).
For modern bundler setups (React, Vue, etc.), you may use the npm package instead of the script tag. The configuration flag is the same:

import mixpanel from 'mixpanel-browser';

mixpanel.init('YOUR_PROJECT_TOKEN', {
  autocapture: true,
  api_host: 'https://api.mixpanel.com',
});

2. Confirm Autocapture Is Enabled

After deployment:

Visit your site/app with the Mixpanel snippet live.
Open your Mixpanel project.
Go to Live View (or your equivalent real-time events view).
Interact with the page—click buttons, navigate between views, submit a form.
You should see Autocapture events (e.g., click, pageview-style events) streaming in.

If you don’t see events:

Confirm the snippet is on the page and firing (browser dev tools → Network tab).
Check for ad blocker or script-blocking extensions.
Confirm the autocapture flag is set to true and that you’re using the correct project token.

3. Apply Privacy & Governance Settings

Before rolling Autocapture to production at scale:

Filter sensitive elements: Use configuration options or data attributes to avoid capturing interactions with sensitive fields (e.g., passwords, payment details, PII-heavy forms).
Respect consent: Wire Autocapture to your consent banner; only initialize Mixpanel once the user has given the appropriate consent.
Govern names: Use Mixpanel’s governance tools to define which events should be source-of-truth, rename noisy events, and hide those you don’t plan to use.

This keeps Autocapture powerful without becoming a cluttered or risky firehose.

Which Events Autocapture Collects by Default

Autocapture focuses on “behavioral primitives”—the interactions most interfaces are built from. The exact list can evolve by SDK version, but in a typical web scenario, you can expect it to automatically track events like:

1. Click / Tap Events

Autocapture records clicks (and taps on touch devices) on interactive elements, for example:

Buttons (<button>, clickable <div>s and <span>s)
Links (<a> elements)
Inputs and controls (checkboxes, radio buttons, toggles)
Other interactive UI components from frameworks (modals, tabs, accordions), when they resolve to click events in the DOM

Each click event is captured with contextual properties describing:

The element (text, tag name, classes, attributes)
The page/view where it occurred
The user and device context

2. Page Views / Page Load Events

In single-page-apps and traditional sites alike, Mixpanel can track navigation and page loads so you can:

See which pages or screens users visit most
Build Funnels from landing page → key action
Analyze Flows of navigation paths

Depending on your setup, this may appear as events like:

page_view
page load / page viewed
Or framework-specific screen change events you configure

Some frameworks require a small additional hook to ensure route changes in single-page apps are captured as separate views.

3. Form Submissions / Inputs (Where Supported)

Autocapture can track form submissions and certain input interactions so you can:

Analyze drop-off in signup or checkout flows
Understand which forms are most used
Debug friction points in lead capture or onboarding

Event patterns here include:

Form submission
Key input interactions (e.g., certain change or blur events), depending on SDK and configuration

Again, sensitive fields should be explicitly excluded via configuration or HTML attributes.

Which Properties Autocapture Collects by Default

Every Autocapture event is enriched with properties so you can segment, filter, and compare behavior. While the exact property list can vary by SDK and configuration, these categories are standard:

1. Event-Level UI Properties

These describe the element and interaction itself, for example:

Element text – visible label on the clicked element (e.g., “Sign up”, “Add to cart”)
Element tag name – button, a, input, div, etc.
Element classes – CSS classes applied to the element
Element ID – the HTML id attribute, if present
Element href – for links, the href target
Element type – for inputs (e.g., text, checkbox, radio)

These properties are powerful for building reports like: “Clicks on elements labeled ‘Upgrade’ in the last 30 days by country and device.”

2. Page / Screen Context Properties

These describe where the event happened:

Current URL – full URL (can be split into path, query string, etc.)
Host / domain
Page path – URL path without domain
Referrer URL – where the user came from (if available)
Page title – <title> content

This is critical for web analytics use cases: landing page analysis, referrer comparisons, and navigation flows.

3. Device & Environment Properties

These describe the user’s technical environment:

Browser / user agent – Chrome, Safari, Firefox, etc.
OS – Windows, macOS, iOS, Android, etc.
Device type – desktop, tablet, mobile
Screen resolution – width and height
Language / locale – browser language settings

These properties let you quickly answer questions like “Does our funnel drop-off spike on mobile Safari?” or “Are we under-serving a specific locale?”

4. Time & Session Properties

Properties that contextualize when and in what session the event occurred:

Timestamp – when the event was recorded
Session-related fields (if configured) – session ID, session start/end markers

These are especially useful for Retention and Flows analysis, or for building cohorts like “users whose first session came from campaign X.”

5. User/Profile Properties (When Identified)

Once you call mixpanel.identify() and mixpanel.people.set() (or the equivalent in your SDK), Autocapture events are linked to profiles that can include:

Account-level or user-level metadata (e.g., plan, role, lifecycle stage)
Custom properties you set (e.g., MRR, signup date, experiment bucket)

Autocapture itself doesn’t invent these, but it attaches events to those profiles so you can view Autocapture behavior through a rich, business-relevant lens.

Features & Benefits Breakdown

Core Feature	What It Does	Primary Benefit
Automatic UI event tracking	Captures clicks, page views, and form interactions with no manual wiring	Get instant behavioral coverage and start analysis in Mixpanel in minutes
Rich default properties	Adds device, browser, page, and element context to every event	Segment behavior by context without asking engineers for more data
Fast, AI-assisted setup	Pairs with AI-guided installation and templates for faster implementation	Move from zero data to actionable reports quickly—without SQL bottlenecks

Ideal Use Cases

Best for new Mixpanel projects without a tracking plan: Because Autocapture gives you immediate, broad coverage of user behavior, you can explore patterns, learn what matters, and then design your long-term event schema from real data instead of guesswork.
Best for web teams iterating on UX and conversion: Because it captures clicks and pageviews automatically, you can monitor how users interact with new flows, spot drop-offs, and optimize without waiting on new instrumentation for every experiment.

Limitations & Considerations

Not a full replacement for custom events: Autocapture is excellent for broad coverage, but you’ll still want custom events for key behaviors that your business cares about (e.g., “Completed Signup,” “Activated Feature X,” “Upgraded Plan”). Use Autocapture as a safety net, not your only data model.
Potential noise if unmanaged: By design, Autocapture can generate many events and properties. Without governance, this can feel noisy. Use Mixpanel’s naming conventions, hidden events, and governance tools to focus on the interactions that matter most, and filter or exclude sensitive or irrelevant elements.

Pricing & Plans

Autocapture is part of Mixpanel’s integrated digital analytics platform—covering product analytics, web analytics, and session replay in one place.

Pricing is typically tied to event volume and feature tiers rather than charging separately for Autocapture. This means you can:

Turn on Autocapture to bootstrap your implementation.
Gradually refine your events and properties as you grow.

Two common plan patterns:

Growth / Startup-friendly plans: Best for teams that need to get to insights quickly with limited resources. Autocapture plus templates and AI-guided setup help them get full-funnel visibility without a dedicated data team.
Enterprise plans: Best for larger organizations needing governance, SSO/SAML, audit logs, and warehouse connectors (e.g., BigQuery, Segment). Autocapture helps product and marketing teams self-serve answers while data teams maintain a governed source of truth.

For current pricing details and limits, check the plans on mixpanel.com or contact sales.

Frequently Asked Questions

Do I still need custom events if I’m using Autocapture?

Short Answer: Yes. Autocapture jumpstarts your analytics, but custom events are still essential for business-critical metrics.

Details: Autocapture is great for discovering behavior patterns, debugging UX, and answering questions like “Which buttons do people click most on this page?” or “Which pages drive the most engagement?” But your core KPIs—like activation events, subscription upgrades, or feature adoption milestones—should be explicitly instrumented as custom events. That’s how you build a reliable, stable metric tree that your whole organization can align around. In practice, strong teams use Autocapture for coverage and discovery, then gradually formalize high-value events into a governed tracking plan.

Can I control which Autocapture events and properties are collected?

Short Answer: Yes. You can configure what Autocapture collects and exclude sensitive or irrelevant data.

Details: Mixpanel provides controls to:

Disable Autocapture entirely if you prefer a fully manual implementation.
Filter out specific elements (e.g., password fields, payment forms) using code or attributes.
Govern and hide noisy events and properties in the Mixpanel UI so they don’t distract downstream users. Combined with your consent and privacy framework, this lets you keep Autocapture powerful and safe: you capture enough detail to analyze behavior in depth, without collecting data you shouldn’t.

Summary

Autocapture in Mixpanel is the fastest route from “no data” to “actionable insights.” By automatically collecting common UI interactions—enriched with device, page, and element properties—it lets product and web teams start exploring user behavior in seconds, without waiting on custom instrumentation or SQL. It doesn’t replace a thoughtful event taxonomy; it gives you the raw material and momentum to build one, while still empowering teams to answer real questions today.

Next Step

Get Started