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

Most teams turn on Mixpanel Autocapture when they want answers fast—without waiting on full tracking specs or engineering cycles. Autocapture records a standardized set of events and properties from your product automatically, so you can start exploring behavior, building funnels, and validating your event model while you instrument your custom events.

Quick Answer: Autocapture is an automatic event collection feature that records key user interactions (like clicks and page views) and attaches useful context (like URLs and element attributes) out of the box. You enable it in your implementation snippet or SDK config, then Mixpanel sends a default set of events and properties you can immediately analyze, without manual tagging.

The Quick Overview

What It Is: An automatic, event-based tracking layer that captures common UX interactions and metadata from your web or mobile product, with no per-event coding required.
Who It Is For: Product, growth, marketing, and data teams that want to explore behavior and build early reports in Mixpanel quickly, then layer on a more robust event model over time.
Core Problem Solved: You can’t afford to wait weeks for perfect tracking before answering basic questions like “where do users drop off?” or “which pages actually get engagement?” Autocapture gives you real data in Mixpanel in minutes.

How It Works

At a high level, Autocapture hooks into your app via the Mixpanel SDK and listens for user interactions that are strong indicators of behavior—primarily page/screen views and element interactions (such as clicks or taps). When these interactions occur, the SDK automatically sends them to Mixpanel as events, along with a rich set of properties (page URL, referrer, device info, and element attributes) that let you slice, filter, and build Funnels, Flows, and Insights reports right away.

The goal is not to replace a deliberate event taxonomy, but to accelerate you from “no data” to “answering questions in seconds” while you design your long-term tracking plan.

Implementation & Toggle On:
You add Mixpanel’s SDK to your site/app (or use an integration), then enable the Autocapture flag in the config or snippet. For most modern stacks this is a one-line change.
Automatic Event Collection:
Once enabled, Mixpanel starts capturing a default set of behavioral events (e.g., page views, clicks, form interactions) and attaches standardized event properties (URL, referrer, device, element attributes) and user properties where available.
Explore & Evolve:
You log into Mixpanel, open Insights, Funnels, or Flows, and immediately start exploring these Autocapture events. As you learn what matters, you define your custom events and properties, refine your event naming, and gradually shift your key metrics to your canonical event model.

Features & Benefits Breakdown

Core Feature	What It Does	Primary Benefit
Zero-config event collection	Captures standard interactions without tagging every button or page.	See real user behavior in Mixpanel within minutes of installing SDK.
Rich default properties	Attaches context like URLs, referrers, devices, and element metadata.	Slice and filter Autocapture data to answer nuanced questions fast.
Event-model ramp-up	Works alongside your custom events and properties as you mature tracking.	Validate your assumptions and prioritize instrumentation with data.

Ideal Use Cases

Best for new implementations: Because it gets data flowing into Mixpanel right after you install the SDK, so teams can explore behavior and align on tracking requirements before writing a full spec.
Best for fast diagnostics: Because you can quickly investigate drop-offs, broken flows, or UX issues using Autocapture events (page views, clicks, forms) without waiting for new releases.

What Autocapture Typically Collects by Default

Exact event names and behavior can vary by SDK and configuration, but Autocapture is oriented around a few core categories of events and properties. The specifics below are representative of what you should expect conceptually; always confirm against your SDK’s latest docs and settings.

Default Autocapture Events

Most Autocapture setups focus on these event types:

Page / Screen Views
- Web: Events representing page loads or route changes (e.g., a Page Viewed / pageview-style event).
- Mobile: Screen view or activity-style events depending on platform and SDK configuration.
- Why it matters: Lets you see which pages or screens get traffic, where users land, and where they drop off across the journey.
Clicks / Taps on Interactive Elements
- Captures user interactions with:
  - Buttons
  - Links
  - Navigation items
  - Other clickable/tap-able elements
- Typically excludes obviously non-interactive elements to avoid noise.
- Why it matters: You can quickly spot which CTAs users actually engage with, which menus get ignored, and where users mis-click or churn.
Form Interactions
- Events for form submissions and sometimes key input interactions:
  - Signup or login form submits
  - Checkout or lead forms
  - Other critical conversion forms
- Why it matters: You can build Autocapture-based funnels for signup or purchase flows to see drop-off even before a full custom event model is in place.
Basic Navigation & Engagement Actions
- Depending on implementation, these might include:
  - Scroll depth milestones
  - Tab or accordion toggles
  - Other clearly interactive UI patterns
- Why it matters: Helps assess whether users actually consume content or just bounce.

Default Event Properties

Each Autocapture event is enriched with a standard set of event properties so you can actually analyze behavior, not just count clicks:

Page / Screen Context
- url (full URL)
- host / domain
- path (URL path)
- title (page title, where available)
- referrer (the page that sent the user)
- Why it matters: Segment traffic by landing page, feature area, or marketing campaign paths.
Device & Environment
- browser (e.g., Chrome, Safari)
- os (operating system)
- device or device type (desktop, tablet, mobile)
- Possibly screen resolution or viewport, depending on SDK
- Why it matters: Identify environment-specific issues and optimize experiences for the devices that matter most.
Interaction / Element Metadata
- element_text or similar (visible text on the clicked element)
- element_tag (HTML tag: button, a, etc.)
- element_id (DOM id attribute, if present)
- element_class (CSS class names, often hashed or truncated)
- Possibly a limited subset of data attributes (e.g., data-* attributes if enabled)
- Why it matters: Distinguish between different buttons or links on the same page, attribute conversions to specific CTAs, and see which UI elements drive deeper engagement.
Timing & Session Context
- Timestamp (standard for all events)
- Session or visit identifier (depending on implementation)
- Why it matters: Build Funnels and Flows based on session behavior, understand recency, and analyze time-to-convert.

Default User Properties

Autocapture itself is event-focused, but when paired with identify/alias logic or upstream integrations, Mixpanel can associate these events with:

Anonymous IDs (pre-login behavior)
User IDs (post-login, from your system)
User properties (e.g., plan, country, signup date) that you set separately

The Autocapture events then become far more powerful: you can compare behavior for different cohorts (free vs. paid, new vs. returning) without additional tags on each event.

How to Turn Mixpanel Autocapture On (Conceptual Steps)

The exact instructions depend on your stack (React, plain JS, mobile SDKs, tag managers, or tools like Segment), but the flow is generally:

Install Mixpanel SDK or Integration
- For web:
  - Add the Mixpanel JavaScript snippet directly, or
  - Use a tag manager / CDP (e.g., Segment) that sends events to Mixpanel.
- For mobile:
  - Add Mixpanel’s iOS/Android SDK and initialize it in your app.
Enable Autocapture in the Config
- In your initialization code or configuration, set the relevant Autocapture flag to true (wording and options vary by SDK).
- Optional: Configure domain allowlists/denylists or features to control what is captured (e.g., disable certain element types or paths to avoid noise or sensitive areas).
Deploy and Verify
- Deploy the updated code to a staging environment first.
- Open Mixpanel and:
  - Go to Live View or an Insights report.
  - Filter for your environment or test users.
  - Trigger interactions in your product (page views, clicks, form submits).
  - Confirm you see Autocapture events and that properties (URLs, element text, etc.) look sane and non-sensitive.
Harden for Privacy and Governance
- Work with security/legal to ensure no sensitive content is exposed via:
  - Element text (e.g., PII in labels)
  - Form values (these should not be captured by default, but verify)
- Use Mixpanel’s governance tools to:
  - Hide or block unwanted properties.
  - Define naming conventions and descriptions for commonly used Autocapture events.
- This keeps Mixpanel “Secure by default” from your stakeholders’ perspective, and supports “Governance made easy” with defined source-of-truth metrics later on.
Start Building Reports
- Use Insights to explore top Autocapture events by count, URL, and device.
- Use Funnels to:
  - Track conversions from landing pages to key actions using Autocapture page and click events.
- Use Flows to:
  - See what users do before or after certain Autocapture events (e.g., specific CTA clicks).
- As you learn, define your own custom events and gradually re-center your key KPIs on those, while Autocapture remains a valuable exploratory layer.

Limitations & Considerations

Noise and Naming Ambiguity:
Because Autocapture is generic, you’ll see many events like “button clicked” differentiated mainly by element properties. For important workflows, plan to add explicit custom events (e.g., Sign Up Submitted, Upgrade Clicked) to avoid ambiguity.
Privacy and Sensitive Data:
Autocapture focuses on interaction metadata, but you should always validate that no sensitive user data is being captured in element text or attributes. Use Mixpanel’s governance tools and SDK configuration options to block or sanitize where needed.

Pricing & Plans

Autocapture is part of Mixpanel’s broader digital analytics platform—it isn’t a separate product. You get it as one of the ways to get set up quickly and start exploring behavior, alongside features like AI-guided installation and pre-built templates.

Free / Starter Plans: Best for smaller teams or early-stage products needing to validate user journeys fast and build foundational analytics without a data team.
Growth / Enterprise Plans: Best for organizations that want Autocapture as a supplement to a full, governed event model—combining it with advanced features (Metric Trees, governance, SSO/SAML, audit logs) to support many teams and billions of events with sub-second query times.

For the latest, plan-specific details, check the pricing page on mixpanel.com or talk to Sales.

Frequently Asked Questions

Can I rely on Autocapture alone for my long-term event strategy?

Short Answer: No. Autocapture is excellent for exploration and speed, but you should still design a deliberate event model for core metrics.

Details:
Autocapture is designed to get you out of the “blank slate” problem and reduce the initial setup burden. It’s perfect for discovering which flows users actually take, how they engage with CTAs, and where they drop off, all without tagging every interaction manually.
However, for durable KPIs (activation, retention, monetization), you want clearly named events that represent business behaviors (e.g., Project Created, Subscription Started) instead of generic clicks. Mixpanel works best when you treat Autocapture as a fast feedback loop early on, then layer in structured events and properties that map to your Metric Trees and reporting standards.

Can I disable or customize specific Autocapture behaviors?

Short Answer: Yes. You can configure what Autocapture tracks and use governance to hide or block noisy or sensitive data.

Details:
Most implementations give you control over Autocapture behavior via SDK options and in-app governance:

Turn Autocapture on/off globally or per environment.
Restrict which domains, paths, or element types are tracked.
Use Mixpanel’s governance UI to:
- Hide properties from self-serve users.
- Block properties entirely if you consider them out-of-bounds.
Combine this with privacy reviews to ensure you adhere to company policies and regulations.

This gives you the benefits of “fast, easy setup” without compromising on control or security.

Summary

Autocapture lets you get Mixpanel working for you in minutes instead of weeks. By automatically collecting key events (page views, clicks, forms) and enriching them with contextual properties (URLs, device, element attributes), it gives product, marketing, and data teams the ability to explore user behavior and build meaningful reports without waiting on a full tracking spec or SQL queries.

Used well, Autocapture accelerates discovery and helps you design a better, more targeted event taxonomy. It’s not a replacement for deliberate behavioral tracking—but it is the fastest way to start answering product questions in seconds and move from “we think users do X” to “we know users do X, and here’s how we’ll improve it.”

Next Step

Get Started