Mixpanel

https://docs.mixpanel.com/docs
Admin
Mixpanel helps you better understand your customers by tracking user engagement with your product...
Tokens:378,859
Snippets:5,130
Trust Score:10
Update:2 months ago
Show doc for...
Tokens:
Raw
### Install and Configure Mixpanel Go SDK

Source: https://docs.mixpanel.com/docs/quickstart/connect-your-data

Installation via go get and initialization of the API client.

```bash
go get github.com/mixpanel/mixpanel-go
```

```go
package main

import (
	"context"
	"github.com/mixpanel/mixpanel-go"
)

func main() {
ctx := context.Background()
mp := mixpanel.NewApiClient("YOUR_TOKEN")
}
```

--------------------------------

### Install Mixpanel Go Library

Source: https://docs.mixpanel.com/docs/tracking-methods/sdks/go

Install the Mixpanel Go library using the 'go get' command. This is the first step before using the SDK in your Go projects.

```shell
# install mixpanel library using Go get
go get github.com/mixpanel/mixpanel-go
```

--------------------------------

### Quick Start: Initialize and Evaluate Flags

Source: https://docs.mixpanel.com/docs/tracking-methods/sdks/swift/swift-openfeature

Initialize the MixpanelOpenFeatureProvider with your project token and register it with OpenFeature. Then, get a client to evaluate boolean feature flags.

```swift
import Mixpanel
import MixpanelOpenFeature
import OpenFeature

// 1. Create and register the provider
let options = MixpanelOptions(token: "YOUR_PROJECT_TOKEN")
let provider = MixpanelOpenFeatureProvider(options: options)
await OpenFeatureAPI.shared.setProviderAndWait(provider: provider)

// 2. Get a client and evaluate flags
let client = OpenFeatureAPI.shared.getClient()
let showNewFeature = client.getBooleanValue(key: "new-feature-flag", defaultValue: false)

if showNewFeature {
    print("New feature is enabled!")
}
```

--------------------------------

### Quick Start: Initialize Mixpanel and OpenFeature

Source: https://docs.mixpanel.com/docs/tracking-methods/sdks/javascript/javascript-openfeature

Initialize the Mixpanel SDK with your project token and feature flag context. Then, create and register the Mixpanel OpenFeature provider with the OpenFeature SDK. Finally, get a client to evaluate boolean flags.

```typescript
import mixpanel from 'mixpanel-browser';
import { OpenFeature } from '@openfeature/web-sdk';
import { MixpanelProvider } from '@mixpanel/openfeature-web-provider';

// 1. Initialize Mixpanel with feature flags
mixpanel.init('YOUR_PROJECT_TOKEN', {
  flags: {
    context: { plan: 'premium' }
  }
});

// 2. Create and register the Mixpanel provider
const provider = new MixpanelProvider(mixpanel.flags);
await OpenFeature.setProviderAndWait(provider);

// 3. Get a client and evaluate flags
const client = OpenFeature.getClient();
const showNewFeature = client.getBooleanValue('new-feature-flag', false);

if (showNewFeature) {
  console.log('New feature is enabled!');
}
```

--------------------------------

### Initialization and Control

Source: https://docs.mixpanel.com/docs/tracking-methods/sdks/react-native/react-native-replay

This snippet demonstrates the basic setup and control flow for the React Native Session Replay SDK. It shows how to initialize the SDK with a configuration object, start and stop recording sessions, and check the current recording status.

```APIDOC
## Initialize Session Replay

### Description
Initializes the Session Replay SDK with the provided Mixpanel token, distinct ID, and configuration.

### Method
`MPSessionReplay.initialize(token: string, distinctId: string, config: MPSessionReplayConfig)`

### Parameters
- **token** (string) - Required - Your Mixpanel project token.
- **distinctId** (string) - Required - The distinct ID for the user.
- **config** (MPSessionReplayConfig) - Required - Configuration object for session replay.
  - **wifiOnly** (boolean) - Optional - If true, recording only happens on Wi-Fi.
  - **recordingSessionsPercent** (number) - Optional - Percentage of sessions to record (0-100).
  - **autoStartRecording** (boolean) - Optional - If true, recording starts automatically.
  - **autoMaskedViews** (Array<MPSessionReplayMask>) - Optional - Views to automatically mask (e.g., Image, Text).
  - **flushInterval** (number) - Optional - Interval in seconds for flushing recorded data.
  - **enableLogging** (boolean) - Optional - If true, enables SDK logging.
  - **serverURL** (string) - Optional - Custom server URL for data submission.

### Control Recording

#### Start Recording

### Method
`MPSessionReplay.startRecording()`

### Description
Manually starts the session recording.

#### Stop Recording

### Method
`MPSessionReplay.stopRecording()`

### Description
Manually stops the session recording.

#### Check Recording Status

### Method
`MPSessionReplay.isRecording()`

### Description
Checks if the session recording is currently active.

### Returns
- **recording** (Promise<boolean>) - A promise that resolves to true if recording, false otherwise.
```

--------------------------------

### Install and Configure Mixpanel Node.js SDK

Source: https://docs.mixpanel.com/docs/quickstart/connect-your-data

Installation via npm and initialization of the Mixpanel client instance.

```bash
npm install mixpanel
```

```javascript
// Grab the Mixpanel factory
var Mixpanel = require("mixpanel");

// Create an instance of the mixpanel client
var mixpanel = Mixpanel.init("YOUR_TOKEN");
```

--------------------------------

### Install and Configure Mixpanel Ruby SDK

Source: https://docs.mixpanel.com/docs/quickstart/install-mixpanel

Install the gem and initialize the tracker with your project token.

```shell
gem install mixpanel-ruby
```

```ruby
require 'mixpanel-ruby'

mp = Mixpanel::Tracker.new(YOUR_TOKEN)
```

--------------------------------

### Install and Configure Mixpanel PHP SDK

Source: https://docs.mixpanel.com/docs/quickstart/connect-your-data

Installation via Composer or manual download, followed by library initialization.

```json
"require": {
    ...
    "mixpanel/mixpanel-php" : "2.*"
    ...
```

```php
<?php
// import Mixpanel
require 'mixpanel-php/lib/Mixpanel.php';

// get the Mixpanel class instance, replace with your project token
$mp = Mixpanel::getInstance("YOUR_TOKEN");

?>
```

--------------------------------

### Install Ruby SDK

Source: https://docs.mixpanel.com/docs/quickstart/connect-your-data

Use the gem command to install the Mixpanel Ruby library.

```bash
gem install mixpanel-ruby
```

--------------------------------

### Install and Initialize Mixpanel for JavaScript

Source: https://docs.mixpanel.com/docs/quickstart/connect-your-data?sdk=flutter

Methods for installing the JavaScript SDK and initializing it with project tokens and configuration options.

```html
<!-- Paste this right before your closing </head> tag -->
<script type="text/javascript">
  (function (f, b) { if (!b.__SV) { var e, g, i, h; window.mixpanel = b; b._i = []; b.init = function (e, f, c) { function g(a, d) { var b = d.split("."); 2 == b.length && ((a = a[b[0]]), (d = b[1])); a[d] = function () { a.push([d].concat(Array.prototype.slice.call(arguments, 0))); }; } var a = b; "undefined" !== typeof c ? (a = b[c] = []) : (c = "mixpanel"); a.people = a.people || []; a.toString = function (a) { var d = "mixpanel"; "mixpanel" !== c && (d += "." + c); a || (d += " (stub)"); return d; }; a.people.toString = function () { return a.toString(1) + ".people (stub)"; }; i = "disable time_event track track_pageview track_links track_forms track_with_groups add_group set_group remove_group register register_once alias unregister identify name_tag set_config reset opt_in_tracking opt_out_tracking has_opted_in_tracking has_opted_out_tracking clear_opt_in_out_tracking start_batch_senders people.set people.set_once people.unset people.increment people.append people.union people.track_charge people.clear_charges people.delete_user people.remove".split( " "); for (h = 0; h < i.length; h++) g(a, i[h]); var j = "set set_once union unset remove delete".split(" "); a.get_group = function () { function b(c) { d[c] = function () { call2_args = arguments; call2 = [c].concat(Array.prototype.slice.call(call2_args, 0)); a.push([e, call2]); }; } for ( var d = {}, e = ["get_group"].concat( Array.prototype.slice.call(arguments, 0)), c = 0; c < j.length; c++) b(j[c]); return d; }; b._i.push([e, f, c]); }; b.__SV = 1.2; e = f.createElement("script"); e.type = "text/javascript"; e.async = !0; e.src = "undefined" !== typeof MIXPANEL_CUSTOM_LIB_URL ? MIXPANEL_CUSTOM_LIB_URL : "file:" === f.location.protocol && "//cdn.mxpnl.com/libs/mixpanel-2-latest.min.js".match(/^\/\//) ? "https://cdn.mxpnl.com/libs/mixpanel-2-latest.min.js" : "//cdn.mxpnl.com/libs/mixpanel-2-latest.min.js"; g = f.getElementsByTagName("script")[0]; g.parentNode.insertBefore(e, g); } })(document, window.mixpanel || []);
</script>
```

```bash
npm install --save mixpanel-browser
```

```bash
yarn add mixpanel-browser
```

```javascript
//Import Mixpanel SDK (only required for npm and yarn)
import mixpanel from "mixpanel-browser";

// Near entry of your product, init Mixpanel
mixpanel.init("YOUR_TOKEN", {
  debug: true,
  track_pageview: true,
  persistence: "localStorage",
  record_sessions_percent: 100, //records 100% of all sessions
  record_heatmap_data: true,
});
```

--------------------------------

### Install Pods

Source: https://docs.mixpanel.com/docs/tracking-methods/sdks/ios

Command to install dependencies and create an Xcode workspace.

```bash
# install library in your dependencies
pod install
```

--------------------------------

### Install Mixpanel Go SDK

Source: https://docs.mixpanel.com/docs/tracking-methods/sdks/go/go-flags

Install the Mixpanel Go SDK to version v2.0.0 or later. Ensure you are on an Enterprise subscription plan.

```bash
go get github.com/mixpanel/mixpanel-go@v2.0.0
```

--------------------------------

### Install OpenFeature Provider for Go

Source: https://docs.mixpanel.com/docs/tracking-methods/sdks/go/go-openfeature

Install the Mixpanel Go OpenFeature provider and the OpenFeature Go SDK. Ensure you have an Enterprise subscription with Feature Flags enabled and a Project Token.

```bash
go get github.com/mixpanel/mixpanel-go/openfeature
go get github.com/open-feature/go-sdk
```

--------------------------------

### Install and Configure Mixpanel Python SDK

Source: https://docs.mixpanel.com/docs/quickstart/connect-your-data

Installation via pip and basic initialization for Python applications.

```bash
pip install mixpanel
```

```python
from mixpanel import Mixpanel

mp = Mixpanel("YOUR_TOKEN")
```

--------------------------------

### Install Mixpanel OpenFeature Provider

Source: https://docs.mixpanel.com/docs/tracking-methods/sdks/python/python-openfeature

Install the necessary packages for the Mixpanel OpenFeature provider and the OpenFeature SDK.

```bash
pip install mixpanel-openfeature openfeature-sdk
```

--------------------------------

### Start Session Replay Recording with Sampling

Source: https://docs.mixpanel.com/docs/tracking-methods/sdks/android/android-replay

Programmatically start recording replay data with a specified sampling percentage. This overrides the `recordingSessionsPercent` set in the configuration. Recording starts regardless of the configured sampling rate.

```kotlin
MPSessionReplay.getInstance()?.startRecording(sessionsPercent = 10.0)
```

--------------------------------

### Install OpenFeature Provider and SDKs

Source: https://docs.mixpanel.com/docs/tracking-methods/sdks/javascript/javascript-openfeature

Install the necessary packages for the Mixpanel OpenFeature provider, the OpenFeature web SDK, and the Mixpanel browser SDK using npm.

```bash
npm install @mixpanel/openfeature-web-provider @openfeature/web-sdk mixpanel-browser
```

--------------------------------

### Install dependencies via command line

Source: https://docs.mixpanel.com/docs/tracking-methods/sdks/flutter

Run this command in your terminal to install the declared dependencies.

```bash
# install packages in your dependencies
$ flutter pub get
```

--------------------------------

### Install and Configure Mixpanel React Native SDK

Source: https://docs.mixpanel.com/docs/quickstart/install-mixpanel

Install the npm package and CocoaPods dependencies, then initialize the SDK.

```sh
npm install mixpanel-react-native
```

```sh
pod install
```

```javascript
//Import Mixpanel API
import { Mixpanel } from "mixpanel-react-native";

// Set up an instance of Mixpanel
const trackAutomaticEvents = false;
const mixpanel = new Mixpanel("YOUR_TOKEN", trackAutomaticEvents);
mixpanel.init();
```

--------------------------------

### Install OpenFeature Provider for Node.js

Source: https://docs.mixpanel.com/docs/tracking-methods/sdks/nodejs/nodejs-openfeature

Install the necessary packages for the Mixpanel OpenFeature server provider and the OpenFeature SDK.

```bash
npm install @mixpanel/openfeature-server-provider @openfeature/server-sdk mixpanel
```

--------------------------------

### Start Recording Replay

Source: https://docs.mixpanel.com/docs/tracking-methods/sdks/android/android-replay

Programmatically start capturing replay data. You can optionally specify a sampling percentage.

```APIDOC
## startRecording()

### Description
Starts capturing replay data. Recording begins regardless of the `recordingSessionsPercent` configuration. You may optionally specify a sampling percentage.

### Method
`MPSessionReplay.getInstance()?.startRecording(sessionsPercent: Double?)`

### Parameters
#### Path Parameters
- **sessionsPercent** (Double) - Optional - The percentage of sessions to record, between 0.0 and 100.0. If not provided, the percentage set in `MPSessionReplayConfig` is used.

### Request Example
```kotlin theme="system"
// start recording with a specified sampling rate (10%)
MPSessionReplay.getInstance()?.startRecording(sessionsPercent = 10.0)

// start recording using the configured sampling rate
MPSessionReplay.getInstance()?.startRecording()
```

### Notes
- `.startRecording()` will have no effect if recording is already in progress.
- Recording automatically stops when the app goes into the background. If `autoStartRecording` is true, recording will automatically start when the app returns to the foreground.
```

--------------------------------

### Setup CocoaPods Mirror

Source: https://docs.mixpanel.com/docs/tracking-methods/sdks/ios

Command to create a local CocoaPods spec mirror.

```bash
# Create CocoaPods spec mirror
pod setup
```

--------------------------------

### Initialize Mixpanel with Options

Source: https://docs.mixpanel.com/docs/tracking-methods/sdks/swift

Configure the SDK during application launch to ensure consistent settings across all components. This example demonstrates setting the project token, server URL for EU data residency, and a custom flush interval.

```swift
import Mixpanel

func application(_ application: UIApplication,
                 didFinishLaunchingWithOptions launchOptions: [NSObject: AnyObject]?) -> Bool {
    ...
    /// Configure Mixpanel for EU data residency
    let options = MixpanelOptions(
        token: "YOUR_PROJECT_TOKEN",
        serverURL: "https://api-eu.mixpanel.com",
        flushInterval: 15
    )
    Mixpanel.initialize(options: options)

    /// Enable debug logging after initialization
    Mixpanel.mainInstance().loggingEnabled = true
    ...
}
```

--------------------------------

### Initialize Session Replay SDK

Source: https://docs.mixpanel.com/docs/tracking-methods/sdks/android/android-replay

Initialize the MPSessionReplay SDK in your Application class after ensuring the main Mixpanel Android SDK is installed. This example shows basic initialization with custom configuration.

```kotlin
private fun initializeMixpanel() {
    val token = "MY_PROJECT_TOKEN"
    val trackAutomaticEvents = true
 
    val mixpanel = MixpanelAPI.getInstance(this, token, trackAutomaticEvents)
    mixpanel.identify("DISTINCT_ID")
 
 
    val config = MPSessionReplayConfig(
        wifiOnly = false,
        enableLogging = true
    )
 
    MPSessionReplay.initialize(this, token, mixpanel.distinctId, config)
}
```

--------------------------------

### init()

Source: https://docs.mixpanel.com/docs/tracking-methods/sdks/react-native/react-native-flags

Initializes the SDK with specific configuration options, including enabling feature flags.

```APIDOC
## init(optOutTrackingDefault, superProperties, serverURL, useGzipCompression, featureFlagsOptions)

### Description
Configures the SDK instance. To enable feature flags, the `featureFlagsOptions` object must be provided with `enabled: true`.

### Parameters
- **optOutTrackingDefault** (boolean) - Required
- **superProperties** (object) - Required
- **serverURL** (string) - Optional
- **useGzipCompression** (boolean) - Optional
- **featureFlagsOptions** (object) - Optional - Configuration for feature flags. Includes `enabled` (boolean) and `context` (object) for variant assignment keys and `custom_properties` for runtime targeting.
```

--------------------------------

### Example Params for JQL Query

Source: https://docs.mixpanel.com/docs/reports/apps/jql

Define parameters like start date, end date, and event name to be used in JQL queries. This allows for dynamic query execution based on provided inputs.

```javascript
params = {
  start_date: "2016-01-01",
  end_date: "2016-01-10",
  event: "View Blog"
}
```

--------------------------------

### Initialize Podfile

Source: https://docs.mixpanel.com/docs/tracking-methods/sdks/ios

Command to initialize a Podfile in the project directory.

```bash
# create Podfile in project directory
pod init
```

--------------------------------

### Install React Native SDK

Source: https://docs.mixpanel.com/docs/quickstart/connect-your-data

Install the package via npm and install iOS pods.

```bash
npm install mixpanel-react-native
```

```bash
pod install
```

--------------------------------

### Install CocoaPods

Source: https://docs.mixpanel.com/docs/tracking-methods/sdks/ios

Command to install the CocoaPods dependency manager.

```bash
# install CocoaPods
gem install cocoapods
```

--------------------------------

### Install Mixpanel Ruby OpenFeature Provider

Source: https://docs.mixpanel.com/docs/tracking-methods/sdks/ruby/ruby-openfeature

Add the necessary gems to your Gemfile for the Mixpanel Ruby OpenFeature provider and OpenFeature SDK. Run `bundle install` to install them.

```ruby
gem 'mixpanel-ruby-openfeature'
gem 'openfeature-sdk'
gem 'mixpanel-ruby'
```

--------------------------------

### Initializing Mixpanel with Network Recording Options

Source: https://docs.mixpanel.com/docs/tracking-methods/sdks/javascript/javascript-replay

Example of initializing the Mixpanel SDK with custom network recording configurations.

```APIDOC
## Initialize Mixpanel with Network Recording Options

### Description
This example demonstrates how to initialize the Mixpanel JavaScript SDK and configure advanced network recording options.

### Method
`mixpanel.init(token, config)`

### Parameters
- `token` (string): Your Mixpanel project token.
- `config` (object): Configuration object for the SDK.
  - `record_sessions_percent` (number): Percentage of sessions to record.
  - `record_network` (boolean): Enable network recording.
  - `record_network_options` (object): Options to customize network recording.
    - `initiatorTypes` (InitiatorType[]): Resource types to capture (e.g., `fetch`, `xmlhttprequest`).
    - `ignoreRequestUrls` (string[]): URL patterns to exclude from recording.
    - `ignoreRequestFn` ((data: NetworkRequest) => boolean): Custom function to filter requests.
    - `recordHeaders` ({ request: string[], response: string[] }): Allowlist of headers to record.
    - `recordBodyUrls` ({ request: string[], response: string[] }): URL patterns for which to record request/response bodies.
    - `recordInitialRequests` (boolean): Capture requests that occurred before recording started.

### Request Example
```javascript
mixpanel.init('YOUR_PROJECT_TOKEN', {
    record_sessions_percent: 100,
    record_network: true,
    record_network_options: {
        initiatorTypes: ['fetch', 'xmlhttprequest'],
        ignoreRequestUrls: ['https://api.example.com/health'],
        ignoreRequestFn: function(data) {
            return data.url.includes('/internal/');
        },
        recordHeaders: {
            request: ['content-type', 'authorization'],
            response: ['content-type', 'x-request-id']
        },
        recordBodyUrls: {
            request: ['https://api.example.com/submit'],
            response: ['https://api.example.com/submit']
        },
        recordInitialRequests: true
    }
});
```
```

--------------------------------

### Install Mixpanel JS SDK via NPM or Yarn

Source: https://docs.mixpanel.com/docs/tracking-methods/sdks/javascript

Install the `mixpanel-browser` package using npm or yarn. After installation, import the Mixpanel class and initialize it with your project token and configuration.

```bash
# via npm
npm install --save mixpanel-browser

# via yarn
yarn add mixpanel-browser
```

```javascript
// import mixpanel class from the library
import mixpanel from 'mixpanel-browser'

// create an instance Mixpanel object using your project token
mixpanel.init("YOUR_PROJECT_TOKEN", {
    autocapture: true,
    track_pageview: true,
    record_sessions_percent: 100, //records 100% of all sessions
    record_heatmap_data: true,
});
```

--------------------------------

### Install Library via CocoaPods

Source: https://docs.mixpanel.com/docs/tracking-methods/sdks/swift

Command to install dependencies defined in the Podfile.

```bash
// install library in your dependencies
pod install
```

--------------------------------

### Quick Start: Mixpanel Go OpenFeature Provider

Source: https://docs.mixpanel.com/docs/tracking-methods/sdks/go/go-openfeature

Initialize the Mixpanel OpenFeature provider with local evaluation, register it with the OpenFeature SDK, and evaluate a boolean flag. Replace 'YOUR_PROJECT_TOKEN' with your actual Mixpanel Project Token.

```go
package main

import (
    "context"
    "fmt"

    mixpanelopenfeature "github.com/mixpanel/mixpanel-go/openfeature"
    "github.com/mixpanel/mixpanel-go/v2/flags"
    of "github.com/open-feature/go-sdk/openfeature"
)

func main() {
    // 1. Create the Mixpanel OpenFeature provider with local evaluation
    provider, err := mixpanelopenfeature.NewProviderWithLocalConfig("YOUR_PROJECT_TOKEN", flags.LocalFlagsConfig{})
    if err != nil {
        panic(err)
    }

    // 2. Register the provider with OpenFeature
    of.SetProvider(provider)
    client := of.NewClient("my-app")

    // 3. Evaluate flags
    showNewFeature, _ := client.BooleanValue(context.Background(), "new-feature-flag", false, of.EvaluationContext{})

    if showNewFeature {
        fmt.Println("New feature is enabled!")
    }
}
```

--------------------------------

### Initialize Mixpanel with Crash Tracking

Source: https://docs.mixpanel.com/docs/tracking-methods/sdks/ios

Example of initializing the SDK with specific configuration options enabled.

```objc
//import library to AppDelegate
#import "Mixpanel/Mixpanel.h"

- (BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:(NSDictionary *)launchOptions {
...
  //create Mixpanel instance with trackCrashes enabled
  [Mixpanel sharedInstanceWithToken:@"YOUR_PROJECT_TOKEN" trackAutomaticEvents:NO trackCrashes:YES];
...
}
```

--------------------------------

### Install iOS Dependencies

Source: https://docs.mixpanel.com/docs/tracking-methods/sdks/react-native

Install the necessary native dependencies for iOS after adding the library.

```bash
pod install
```

--------------------------------

### Install AsyncStorage for Javascript Mode

Source: https://docs.mixpanel.com/docs/tracking-methods/sdks/react-native

Install the required storage dependency for enabling Javascript Mode.

```bash
npm install @react-native-async-storage/async-storage
```

--------------------------------

### Quick Start: Initialize and Evaluate Flags

Source: https://docs.mixpanel.com/docs/tracking-methods/sdks/java/java-openfeature

Initialize the Mixpanel OpenFeature provider with your project token and local configuration. Then, obtain a client to evaluate boolean feature flags.

```java
import com.mixpanel.openfeature.MixpanelProvider;
import com.mixpanel.mixpanelapi.featureflags.config.LocalFlagsConfig;
import dev.openfeature.sdk.OpenFeatureAPI;
import dev.openfeature.sdk.Client;

// 1. Create and register the provider with local evaluation
MixpanelProvider provider = new MixpanelProvider(
    "YOUR_PROJECT_TOKEN",
    new LocalFlagsConfig("YOUR_PROJECT_TOKEN")
);
OpenFeatureAPI api = OpenFeatureAPI.getInstance();
api.setProvider(provider);

// 2. Get a client and evaluate flags
Client client = api.getClient();
boolean showNewFeature = client.getBooleanValue("new-feature-flag", false);

if (showNewFeature) {
    System.out.println("New feature is enabled!");
}
```

--------------------------------

### Configure Java SDK

Source: https://docs.mixpanel.com/docs/quickstart/connect-your-data

Set up the MixpanelAPI instance with your project token.

```java
//Import Mixpanel API
import com.mixpanel.mixpanelapi.MessageBuilder;
import com.mixpanel.mixpanelapi.MixpanelAPI;

// Set up an instance of MixpanelAPI
MixpanelAPI mixpanel = new MixpanelAPI();

MessageBuilder messageBuilder = new MessageBuilder('YOUR_TOKEN');
```

--------------------------------

### Configure Ruby SDK

Source: https://docs.mixpanel.com/docs/quickstart/connect-your-data

Initialize the tracker using your project token.

```ruby
require 'mixpanel-ruby'

mp = Mixpanel::Tracker.new(YOUR_TOKEN)
```

--------------------------------

### Install Mixpanel Node.js SDK

Source: https://docs.mixpanel.com/docs/tracking-methods/sdks/nodejs

Use npm to install the Mixpanel library in your project's root directory.

```bash
# install Mixpanel using npm
npm install mixpanel
```

--------------------------------

### Quick Start: Initialize and Evaluate Flags

Source: https://docs.mixpanel.com/docs/tracking-methods/sdks/python/python-openfeature

Initialize the Mixpanel OpenFeature provider with your project token and local configuration, then register it with the OpenFeature API. Use the client to evaluate boolean feature flags.

```python
from mixpanel_openfeature import MixpanelProvider
from mixpanel.flags.types import LocalFlagsConfig
from openfeature import api

# 1. Create and register the provider with local evaluation
provider = MixpanelProvider.from_local_config(
    "YOUR_PROJECT_TOKEN",
    LocalFlagsConfig(token="YOUR_PROJECT_TOKEN"),
)
api.set_provider(provider)

# 2. Get a client and evaluate flags
client = api.get_client()
show_new_feature = client.get_boolean_value("new-feature-flag", False)

if show_new_feature:
    print("New feature is enabled!")
```

--------------------------------

### startRecording

Source: https://docs.mixpanel.com/docs/tracking-methods/sdks/react-native/react-native-replay

Starts the session recording process, capturing user interactions within the application.

```APIDOC
## startRecording

### Description
Start recording user interactions.

### Method Signature
```typescript
startRecording(): Promise<void>
```

### Example
```typescript
await MPSessionReplay.startRecording();
```
```

--------------------------------

### Initialize SDK with Default Opt-Out

Source: https://docs.mixpanel.com/docs/tracking-methods/sdks/android

Configure the SDK to start in an opted-out state and use optInTracking to enable data collection later.

```java
// users opted out of tracking by default
optOutTrackingDefault = true;
trackAutomaticEvents = false;
MixpanelAPI mixpanel =
    MixpanelAPI.getInstance(context, 'YOUR_PROJECT_TOKEN', optOutTrackingDefault, trackAutomaticEvents);


// this track call will not work
mixpanel.track('some_event');

// opt user back into tracking
mixpanel.optInTracking();
 
// this track call will work
mixpanel.track('some_other_event');
```

--------------------------------

### Install Session Replay Package

Source: https://docs.mixpanel.com/docs/tracking-methods/sdks/react-native

Install the required Session Replay package alongside the main Mixpanel React Native SDK.

```bash
npm install @mixpanel/react-native-session-replay
```

--------------------------------

### Initialize Mixpanel SDK

Source: https://docs.mixpanel.com/docs/tracking-methods/sdks/react-native

Import the Mixpanel class, instantiate it with your project token, and initialize the SDK.

```javascript
//import Mixpanel class from the SDK
import { Mixpanel } from 'mixpanel-react-native';

// create an instance of Mixpanel using your project token
// disable legacy autotrack mobile events
const trackAutomaticEvents = false;
const mixpanel = new Mixpanel('YOUR_PROJECT_TOKEN', trackAutomaticEvents);

//initialize Mixpanel
await mixpanel.init();
```

--------------------------------

### Install Mixpanel Python Library

Source: https://docs.mixpanel.com/docs/tracking-methods/sdks/python

Install the Mixpanel Python module using pip. This is the first step to using the SDK in your Python projects.

```shell
# install the Mixpanel module
pip install mixpanel
```

--------------------------------

### Initialize and Track to Multiple Projects in Web

Source: https://docs.mixpanel.com/docs/best-practices/developer-environments

Use the library_name parameter in mixpanel.init to create a named instance, then reference that instance for tracking calls.

```javascript
// Replace 456def with your project B token
mixpanel.init("456def", {}, "project_b")
```

```javascript
mixpanel.project_b.track("event name")
```

--------------------------------

### Install Mixpanel Headless SDK

Source: https://docs.mixpanel.com/docs/mixpanel-headless

Install the Mixpanel Headless SDK using pip. This command is essential for setting up the SDK in your Python environment.

```bash
pip install mixpanel-headless
```

--------------------------------

### Initialize Mixpanel with Composer

Source: https://docs.mixpanel.com/docs/tracking-methods/sdks/php

After installing via Composer, use this PHP code to include the autoloader and create an instance of the Mixpanel class with your project token.

```php
<?php
// import dependencies
require 'vendor/autoload.php';

// create an instance of the Mixpanel class
$mp = Mixpanel::getInstance("YOUR_PROJECT_TOKEN");

?>
```

--------------------------------

### Start Polling for Definitions in Java

Source: https://docs.mixpanel.com/docs/tracking-methods/sdks/java/java-flags

For local evaluation, ensure you start polling for feature flag definitions using `startPollingForDefinitions()` after initializing the `MixpanelAPI`.

```java
mixpanel.getLocalFlags().startPollingForDefinitions();
```
Tokens:
Raw