> ## Documentation Index
> Fetch the complete documentation index at: https://mintlify.com/mixpanel/docs/llms.txt
> Use this file to discover all available pages before exploring further.

# Tips and Tricks

> Best practices and helpful tips for using Mixpanel effectively

## Overview

Now that you have Mixpanel installed and tracking events, here are some tips and tricks to help you get the most out of your implementation.

## Implementation Best Practices

### 1. Track Consistently

<Tip>
  Establish naming conventions early. Use consistent patterns like "Noun + Verb" (e.g., "Video Played") or "Verb + Noun" (e.g., "Played Video") across all events.
</Tip>

**Good Examples:**

* Sign Up
* Video Played
* Purchase Completed
* Search Performed

**Avoid:**

* signup (inconsistent casing)
* video\_play (inconsistent format)
* user-purchased-item (too verbose)

### 2. Choose the Right Tracking Method

<CardGroup cols={2}>
  <Card title="Server-Side Tracking" icon="server">
    **Best for:**

    * Critical business events
    * Payment/transaction tracking
    * Server-side operations
    * Most reliable data
  </Card>

  <Card title="Client-Side Tracking" icon="browser">
    **Best for:**

    * User interactions
    * Page views
    * Quick prototyping
    * Session replay data
  </Card>
</CardGroup>

**Recommendation:** Use server-side tracking for critical events and client-side for user interactions. Learn more in our [choosing the right method guide](/docs/tracking-methods/choosing-the-right-method).

### 3. Add Meaningful Properties

```javascript theme={null}
// Good: Includes context
mixpanel.track('Video Played', {
  'Video Title': 'Product Demo',
  'Video Duration': 120,
  'Video Category': 'Tutorial',
  'Auto Played': false,
  'Video Quality': '1080p'
});

// Less useful: Missing context
mixpanel.track('Video Played');
```

## Privacy and Compliance

### Implement Opt-Out Tracking

Respect user privacy by implementing opt-out tracking:

<Tabs>
  <Tab title="JavaScript">
    ```javascript theme={null}
    // When user opts out
    mixpanel.opt_out_tracking();

    // When user opts back in
    mixpanel.opt_in_tracking();

    // Check if user has opted out
    if (mixpanel.has_opted_out_tracking()) {
      // Show appropriate UI
    }
    ```
  </Tab>

  <Tab title="iOS Swift">
    ```swift theme={null}
    // Opt out
    Mixpanel.mainInstance().optOutTracking()

    // Opt in
    Mixpanel.mainInstance().optInTracking()

    // Check status
    if Mixpanel.mainInstance().hasOptedOutTracking() {
        // Handle opt-out state
    }
    ```
  </Tab>

  <Tab title="Android">
    ```java theme={null}
    // Opt out
    mixpanel.optOutTracking();

    // Opt in
    mixpanel.optInTracking();

    // Check status
    if (mixpanel.hasOptedOutTracking()) {
        // Handle opt-out state
    }
    ```
  </Tab>
</Tabs>

### Don't Track Sensitive Data

<Warning>
  Never track:

  * Passwords or security credentials
  * Credit card numbers
  * Social security numbers
  * Health information
  * Full IP addresses (unless necessary)
</Warning>

## Performance Optimization

### 1. Use Proxy Servers

Avoid ad-blockers by setting up a proxy:

```javascript theme={null}
mixpanel.init('YOUR_TOKEN', {
  api_host: 'https://your-proxy.yourdomain.com'
});
```

[Learn how to set up a proxy](/docs/tracking-methods/sdks/javascript#tracking-via-proxy)

### 2. Configure Persistence

For web tracking, use localStorage for better reliability:

```javascript theme={null}
mixpanel.init('YOUR_TOKEN', {
  persistence: 'localStorage'
});
```

<Info>
  Note: localStorage doesn't support cross-subdomain tracking. Use cookies if you need cross-subdomain support.
</Info>

### 3. Batch Events on Mobile

Mobile SDKs automatically batch events. You can also manually flush:

<Tabs>
  <Tab title="iOS">
    ```swift theme={null}
    // Flush events immediately
    Mixpanel.mainInstance().flush()
    ```
  </Tab>

  <Tab title="Android">
    ```java theme={null}
    // Flush events immediately
    mixpanel.flush();
    ```
  </Tab>
</Tabs>

## Testing Your Implementation

### 1. Enable Debug Mode

<Tabs>
  <Tab title="JavaScript">
    ```javascript theme={null}
    mixpanel.init('YOUR_TOKEN', {
      debug: true
    });
    ```
  </Tab>

  <Tab title="Python">
    ```python theme={null}
    mp = Mixpanel('YOUR_TOKEN', consumer=mixpanel.Consumer(api_host="api.mixpanel.com"))
    ```
  </Tab>
</Tabs>

### 2. Use Browser Console

Check the browser console for Mixpanel debug output:

```javascript theme={null}
// Enable verbose logging
mixpanel.set_config({debug: true});

// Check if initialized
console.log(mixpanel);

// Verify events
mixpanel.track('Test Event');
```

### 3. View Live Events

Use the [Events page](https://mixpanel.com/report/events) to see events in real-time:

1. Click "Live View" to see events as they arrive
2. Filter by your user ID or device
3. Verify event properties are correct

## Advanced Tips

### 1. Use Super Properties

Set properties that are included with every event:

```javascript theme={null}
// Set super properties
mixpanel.register({
  'App Version': '2.5.0',
  'Plan Type': 'Premium',
  'Environment': 'Production'
});

// Now all events include these properties
mixpanel.track('Button Clicked');
// Automatically includes App Version, Plan Type, and Environment
```

### 2. Track Timing

Measure how long actions take:

```javascript theme={null}
// Start timing
mixpanel.time_event('Video Watched');

// Later, when video ends
mixpanel.track('Video Watched', {
  'Video Title': 'Product Demo'
});
// Automatically includes duration
```

### 3. Implement Funnel Tracking

Track complete user journeys:

```javascript theme={null}
// Step 1: User views product
mixpanel.track('Product Viewed', {
  'Product ID': '12345',
  'Category': 'Electronics'
});

// Step 2: User adds to cart
mixpanel.track('Add to Cart', {
  'Product ID': '12345',
  'Price': 99.99
});

// Step 3: User completes purchase
mixpanel.track('Purchase Completed', {
  'Product ID': '12345',
  'Revenue': 99.99
});
```

## Common Pitfalls to Avoid

<AccordionGroup>
  <Accordion title="Tracking Too Many Events">
    Start with 5-10 critical events. You can always add more later. Tracking everything makes analysis overwhelming and slows down reports.
  </Accordion>

  <Accordion title="Inconsistent Event Names">
    Use a consistent naming convention from day one. Changing event names later requires code updates and makes historical analysis difficult.
  </Accordion>

  <Accordion title="Missing User Identification">
    Always call `identify()` when users log in. Without it, you can't track user journeys across sessions or devices.
  </Accordion>

  <Accordion title="Not Testing Before Production">
    Always test your implementation in a development environment first. Use a separate Mixpanel project for testing.
  </Accordion>

  <Accordion title="Ignoring Mobile Buffering">
    Mobile SDKs buffer events for battery life. Call `.flush()` after critical events or use the `track_pageview` option.
  </Accordion>
</AccordionGroup>

## Useful Resources

<CardGroup cols={2}>
  <Card title="SDK Documentation" icon="book" href="/docs/tracking-methods/sdks">
    Complete reference for all Mixpanel SDKs
  </Card>

  <Card title="Property Reference" icon="list" href="/docs/data-structure/property-reference">
    Learn about default and custom properties
  </Card>

  <Card title="Community Forum" icon="users" href="https://community.mixpanel.com/">
    Get help from the Mixpanel community
  </Card>

  <Card title="Support" icon="life-ring" href="https://mixpanel.com/contact-us/support/">
    Contact Mixpanel support team
  </Card>
</CardGroup>

## FAQ

<AccordionGroup>
  <Accordion title="Does Mixpanel automatically track page views?">
    Yes, if you pass `track_pageview: true` in the `mixpanel.init()` call, Mixpanel will automatically track a "Page View" event every time a new page is loaded. Learn more [here](/docs/tracking-methods/sdks/javascript#tracking-page-views).
  </Accordion>

  <Accordion title="Why aren't my events showing up?">
    If tracking from web, make sure you've disabled ad blockers and your Do Not Track (DNT) browser settings are set to false when testing your JavaScript implementation. If the DNT setting is set to true, then Mixpanel won't collect information from that Mixpanel instance. We also recommend [setting up a proxy server](/docs/tracking-methods/sdks/javascript#tracking-via-proxy) so that you don't lose events due to ad-blockers.

    If tracking from a mobile device, events may take 1-2 minutes to appear because Mixpanel's mobile SDKs buffer events for 1 minute, or when the app transitions to the background, to conserve battery life and bandwidth. You can call `.flush()` in the mobile SDKs to manually flush events to Mixpanel.
  </Accordion>

  <Accordion title="How can I track in a privacy compliant way?">
    If a user opts out of tracking, you can call the `.optOutTracking()` method on any of our client-side SDKs; this prevents any subsequent data being tracked from that user's device. Learn more [here](/docs/privacy/protecting-user-data).

    For iOS specifically: Mixpanel does not use IDFA, so it does not require user permission through the AppTrackingTransparency(ATT) framework. For more details, refer to our [Apple App Developer Privacy Guidance](https://mixpanel.com/legal/app-store-privacy-details).
  </Accordion>

  <Accordion title="Does Mixpanel use third-party cookies?">
    No, our Mixpanel JavaScript SDK does not set or use any third-party cookies. If you wish to disable cookies entirely, you can set the disable\_persistence option to true when initializing your Mixpanel JS instance. Note that disabling persistence will disable the use of super properties and anonymous -> identified user tracking.
  </Accordion>

  <Accordion title="What are the recommended configuration options?">
    When tracking on web, we recommend using localStorage, as this is more reliable:

    ```javascript theme={null}
    mixpanel.set_config({ persistence: "localStorage" });
    ```
  </Accordion>

  <Accordion title="How do I connect events from logged out vs logged in users?">
    If tracking client-side, just call `.identify(<user_id>)` when a user logs in and `.reset()` when they log out. Mixpanel will automatically stitch the user journey across logged out and logged in.

    If tracking server-side, check out our [server-side best practices guide](/docs/best-practices/server-side-best-practices). For more information, read our comprehensive guide on [Identifying Users](/docs/tracking-methods/id-management/identifying-users).
  </Accordion>
</AccordionGroup>