OpenReplay (openreplay/openreplay)

OpenReplay

https://github.com/openreplay/openreplay
Admin
OpenReplay is an open-source session replay suite that lets you see what users do on your web app,...

Tokens:114,475
Snippets:1,262
Trust Score:8.7
Update:1 month ago
Show doc for...
Context Summary (auto-generated)
Raw
# OpenReplay

OpenReplay is an open-source session replay suite that lets you see what users do on your web app, helping you troubleshoot issues faster. It captures network activity, console logs, JS errors, store actions/state, page speed metrics, CPU/memory usage, and more. Unlike SaaS solutions, OpenReplay can be self-hosted for complete control over your data and privacy compliance.

The platform consists of a JavaScript tracker SDK that captures user sessions on the frontend, a backend API for processing and storing session data, and various plugins for integrating with state management libraries (Redux, Vuex, MobX, NgRx, Zustand), network libraries (Fetch, Axios, GraphQL), and live assistance features (Assist for co-browsing and WebRTC calls). OpenReplay also provides a browser extension called Spot for quick bug recording and reporting.

---

## Tracker SDK Installation

Install the core tracker package to start recording user sessions.

```bash
npm install @openreplay/tracker
```

---

## Basic Tracker Initialization

Initialize the tracker with your project key and start recording sessions.

```javascript
import Tracker from '@openreplay/tracker';

const tracker = new Tracker({
  projectKey: 'YOUR_PROJECT_KEY',
  ingestPoint: 'https://your-openreplay-instance.com/ingest', // Optional for self-hosted
  __DISABLE_SECURE_MODE: true, // Set to true for localhost testing
});

// Start the tracker with optional user identification
tracker.start({
  userID: 'user-123',
  metadata: {
    plan: 'enterprise',
    version: '2.1.0',
    environment: 'production'
  }
}).then(session => {
  if (session.success) {
    console.log('Session started:', session.sessionID);
    console.log('Session URL:', tracker.getSessionURL());
  } else {
    console.error('Failed to start:', session.reason);
  }
});
```

---

## tracker.setUserID()

Identify users during their session for easier debugging and user tracking.

```javascript
import Tracker from '@openreplay/tracker';

const tracker = new Tracker({ projectKey: 'YOUR_PROJECT_KEY' });

// Set user ID after authentication
function onUserLogin(user) {
  tracker.setUserID(user.id);
  // Or use the alias
  tracker.identify(user.id);
}

// Can also be set at start
tracker.start({
  userID: 'authenticated-user-456'
});
```

---

## tracker.setMetadata()

Add custom metadata key-value pairs to sessions for filtering and context.

```javascript
import Tracker from '@openreplay/tracker';

const tracker = new Tracker({ projectKey: 'YOUR_PROJECT_KEY' });
tracker.start();

// Add metadata throughout the session
tracker.setMetadata('subscription', 'premium');
tracker.setMetadata('cartValue', '150.00');
tracker.setMetadata('featureFlags', 'newCheckout,darkMode');
tracker.setMetadata('userRole', 'admin');
tracker.setMetadata('pageCategory', 'checkout');
```

---

## tracker.event()

Log custom events with optional payload data for tracking user actions.

```javascript
import Tracker from '@openreplay/tracker';

const tracker = new Tracker({ projectKey: 'YOUR_PROJECT_KEY' });
tracker.start();

// Simple event
tracker.event('button_clicked');

// Event with string payload
tracker.event('form_submitted', 'contact-form');

// Event with object payload (will be JSON stringified)
tracker.event('purchase_completed', {
  orderId: 'ORD-12345',
  amount: 99.99,
  currency: 'USD',
  items: ['product-1', 'product-2']
});

// Event with custom timestamp for analytics
tracker.event('page_interaction', {
  action: 'scroll_to_bottom',
  or_timestamp: Date.now() // Custom timestamp
});
```

---

## tracker.issue()

Log custom issues that will be highlighted in the session replay for debugging.

```javascript
import Tracker from '@openreplay/tracker';

const tracker = new Tracker({ projectKey: 'YOUR_PROJECT_KEY' });
tracker.start();

// Log validation errors
function validateForm(data) {
  if (!data.email) {
    tracker.issue('validation_error', {
      field: 'email',
      message: 'Email is required'
    });
  }
}

// Log business logic issues
function processPayment(result) {
  if (result.status === 'declined') {
    tracker.issue('payment_declined', {
      reason: result.declineReason,
      cardLast4: result.cardLast4
    });
  }
}
```

---

## tracker.handleError()

Manually capture and report errors with additional context.

```javascript
import Tracker from '@openreplay/tracker';

const tracker = new Tracker({ projectKey: 'YOUR_PROJECT_KEY' });
tracker.start();

// Handle caught errors
try {
  await riskyOperation();
} catch (error) {
  tracker.handleError(error, {
    component: 'PaymentProcessor',
    action: 'processPayment',
    userId: currentUser.id
  });
}

// Handle promise rejections
window.addEventListener('unhandledrejection', (event) => {
  tracker.handleError(event, {
    type: 'unhandled_promise_rejection'
  });
});

// Handle error events
window.addEventListener('error', (event) => {
  tracker.handleError(event, {
    source: event.filename,
    line: event.lineno
  });
});
```

---

## tracker.getSessionURL()

Get the URL to view the current session replay in OpenReplay.

```javascript
import Tracker from '@openreplay/tracker';

const tracker = new Tracker({ projectKey: 'YOUR_PROJECT_KEY' });

tracker.start().then(() => {
  // Get session URL for support tickets
  const sessionUrl = tracker.getSessionURL();
  console.log('View this session:', sessionUrl);

  // Get URL with current timestamp for precise location
  const urlWithTime = tracker.getSessionURL({ withCurrentTime: true });
  console.log('Jump to current moment:', urlWithTime);

  // Include in error reports
  function reportBug(description) {
    sendToSupport({
      description,
      sessionReplay: tracker.getSessionURL({ withCurrentTime: true }),
      sessionId: tracker.getSessionID()
    });
  }
});
```

---

## Cold Start / Conditional Recording

Buffer session data without recording, then decide later whether to capture it.

```javascript
import Tracker from '@openreplay/tracker';

const tracker = new Tracker({ projectKey: 'YOUR_PROJECT_KEY' });

// Start buffering without sending data (30 second buffer)
tracker.coldStart({
  userID: 'user-123',
  metadata: { tier: 'free' }
}, true); // Second param enables conditional recording

// Later, if something interesting happens, start the real session
// The buffered data will be included
document.getElementById('purchase-btn').addEventListener('click', () => {
  tracker.start().then(session => {
    if (session.success) {
      console.log('Captured the purchase flow!');
    }
  });
});

// Or trigger on errors
window.addEventListener('error', () => {
  tracker.start(); // Captures the 30 seconds leading up to the error
});
```

---

## Offline Recording

Record sessions offline and upload them later when connectivity is restored.

```javascript
import Tracker from '@openreplay/tracker';

const tracker = new Tracker({ projectKey: 'YOUR_PROJECT_KEY' });

// Start offline recording
const { saveBuffer, getBuffer, setBuffer } = tracker.startOfflineRecording(
  { userID: 'offline-user' },
  () => {
    console.log('Session uploaded successfully!');
  }
);

// Save buffer periodically to localStorage
setInterval(() => {
  saveBuffer();
}, 30000);

// When back online, upload the recording
window.addEventListener('online', async () => {
  try {
    await tracker.uploadOfflineRecording();
  } catch (error) {
    console.error('Failed to upload offline session:', error);
  }
});
```

---

## WebSocket Tracking

Track WebSocket messages for real-time application debugging.

```javascript
import Tracker from '@openreplay/tracker';

const tracker = new Tracker({ projectKey: 'YOUR_PROJECT_KEY' });
tracker.start();

// Create a WebSocket tracker hook
const trackWs = tracker.trackWs('chat-channel');

const socket = new WebSocket('wss://api.example.com/ws');

socket.onmessage = (event) => {
  // Track incoming messages
  trackWs('message', event.data, 'down');
  handleMessage(JSON.parse(event.data));
};

function sendMessage(type, data) {
  const payload = JSON.stringify({ type, data });
  // Track outgoing messages
  trackWs(type, payload, 'up');
  socket.send(payload);
}

sendMessage('user_typing', { roomId: '123' });
```

---

## Redux Plugin

Capture Redux actions and state changes for debugging application state.

```bash
npm install @openreplay/tracker-redux
```

```javascript
import Tracker from '@openreplay/tracker';
import trackerRedux from '@openreplay/tracker-redux';
import { createStore, applyMiddleware } from 'redux';

const tracker = new Tracker({ projectKey: 'YOUR_PROJECT_KEY' });

// Configure the plugin
const reduxPlugin = tracker.use(trackerRedux({
  actionFilter: (action) => {
    // Filter out noisy actions
    return !action.type.startsWith('@@redux-form');
  },
  actionTransformer: (action) => {
    // Sanitize sensitive data
    if (action.type === 'SET_USER') {
      return {
        ...action,
        payload: { ...action.payload, password: '[REDACTED]' }
      };
    }
    return action;
  },
  stateTransformer: (state) => {
    // Sanitize state before sending
    const { auth, ...safeState } = state;
    return safeState;
  }
}));

// Apply as Redux middleware
const store = createStore(
  rootReducer,
  applyMiddleware(reduxPlugin)
);

tracker.start();
```

---

## Fetch Plugin

Capture fetch API requests and responses for network debugging.

```bash
npm install @openreplay/tracker-fetch
```

```javascript
import Tracker from '@openreplay/tracker';
import trackerFetch from '@openreplay/tracker-fetch';

const tracker = new Tracker({ projectKey: 'YOUR_PROJECT_KEY' });

// Configure the fetch plugin
const fetch = tracker.use(trackerFetch({
  failuresOnly: false, // Capture all requests, not just failures
  sessionTokenHeader: 'X-OpenReplay-Session', // Add session token to requests
  ignoreHeaders: ['Cookie', 'Set-Cookie', 'Authorization'], // Don't capture these headers
  sanitiser: (data) => {
    // Sanitize request/response data
    if (data.url.includes('/api/auth')) {
      return {
        ...data,
        request: { ...data.request, body: '[REDACTED]' },
        response: { ...data.response, body: '[REDACTED]' }
      };
    }
    return data;
  },
  overrideGlobal: true // Replace window.fetch automatically
}));

tracker.start();

// If overrideGlobal is false, use the returned fetch function
// const response = await fetch('/api/users');
```

---

## Axios Plugin

Capture Axios HTTP requests and responses with automatic interceptors.

```bash
npm install @openreplay/tracker-axios
```

```javascript
import Tracker from '@openreplay/tracker';
import trackerAxios from '@openreplay/tracker-axios';
import axios from 'axios';

const tracker = new Tracker({ projectKey: 'YOUR_PROJECT_KEY' });

// Create a custom axios instance
const apiClient = axios.create({
  baseURL: 'https://api.example.com',
  timeout: 10000
});

// Apply the plugin to your axios instance
tracker.use(trackerAxios({
  instance: apiClient, // Your axios instance
  failuresOnly: false,
  captureWhen: (config) => {
    // Only capture API calls, not static assets
    return config.url.startsWith('/api');
  },
  ignoreHeaders: ['Authorization', 'Cookie'],
  sanitiser: (data) => {
    // Remove sensitive data
    if (data.url.includes('/login')) {
      return {
        ...data,
        request: { ...data.request, body: '{"email":"[REDACTED]"}' }
      };
    }
    return data;
  }
}));

tracker.start();

// Make requests as normal
apiClient.get('/api/users');
apiClient.post('/api/orders', { items: ['product-1'] });
```

---

## GraphQL Plugin

Capture GraphQL queries and mutations for Apollo, Relay, and custom clients.

```bash
npm install @openreplay/tracker-graphql
```

```javascript
import Tracker from '@openreplay/tracker';
import { createTrackerLink, createRelayMiddleware } from '@openreplay/tracker-graphql';
import { ApolloClient, InMemoryCache, HttpLink, from } from '@apollo/client';

const tracker = new Tracker({ projectKey: 'YOUR_PROJECT_KEY' });

// For Apollo Client
const trackerLink = tracker.use(createTrackerLink({
  operationFilter: (operation) => {
    // Don't track introspection queries
    return !operation.operationName?.includes('Introspection');
  }
}));

const apolloClient = new ApolloClient({
  cache: new InMemoryCache(),
  link: from([
    trackerLink,
    new HttpLink({ uri: 'https://api.example.com/graphql' })
  ])
});

tracker.start();

// For Relay
import { Environment, Network, Store, RecordSource } from 'relay-runtime';

const relayMiddleware = tracker.use(createRelayMiddleware());

const network = Network.create(async (request, variables) => {
  const response = await fetch('/graphql', {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({ query: request.text, variables })
  });
  return response.json();
});

const environment = new Environment({
  network: relayMiddleware(network),
  store: new Store(new RecordSource())
});
```

---

## Assist Plugin (Co-Browsing)

Enable live co-browsing and WebRTC calls with your users for real-time support.

```bash
npm install @openreplay/tracker-assist
```

```javascript
import Tracker from '@openreplay/tracker';
import trackerAssist from '@openreplay/tracker-assist';

const tracker = new Tracker({ projectKey: 'YOUR_PROJECT_KEY' });

// Configure Assist plugin
tracker.use(trackerAssist({
  onAgentConnect: (agentInfo) => {
    console.log('Support agent connected:', agentInfo.name);
    showNotification(`${agentInfo.name} is viewing your screen`);
    return () => {
      // Cleanup when agent disconnects
      hideNotification();
    };
  },
  onCallStart: (agentInfo) => {
    console.log('Call started with:', agentInfo.name);
    return () => {
      console.log('Call ended');
    };
  },
  onRemoteControlStart: (agentInfo) => {
    console.log('Remote control started by:', agentInfo.name);
    showRemoteControlIndicator();
    return () => {
      hideRemoteControlIndicator();
    };
  },
  callConfirm: {
    text: 'Support agent wants to start a call. Accept?',
    confirmBtn: 'Accept Call',
    declineBtn: 'Decline'
  },
  controlConfirm: {
    text: 'Support agent wants to control your screen. Allow?',
    confirmBtn: 'Allow',
    declineBtn: 'Deny'
  }
}));

tracker.start();
```

---

## Privacy Controls

Configure what data to capture and sanitize for GDPR compliance.

```javascript
import Tracker from '@openreplay/tracker';

const tracker = new Tracker({
  projectKey: 'YOUR_PROJECT_KEY',

  // Text obfuscation options
  obscureTextEmails: true,  // Replace emails with asterisks
  obscureTextNumbers: true, // Replace numbers with asterisks

  // Default input mode for form fields
  defaultInputMode: 0, // 0 = plain, 1 = obscured, 2 = hidden

  // Respect browser's Do Not Track setting
  respectDoNotTrack: true,

  // Network options
  network: {
    failuresOnly: false,
    ignoreHeaders: ['Authorization', 'Cookie', 'X-API-Key'],
    capturePayload: true,
    sanitizer: (request) => {
      // Remove sensitive URLs entirely
      if (request.url.includes('/api/auth')) {
        return null;
      }
      return request;
    }
  }
});

tracker.start();

// In HTML, use data attributes for fine-grained control
// <input type="password" data-openreplay-hidden />
// <div data-openreplay-obscured>Sensitive content</div>
// <span data-openreplay-htmlmasked>Email: user@example.com</span>
```

---

## REST API - Session Search

Search and filter recorded sessions with various criteria.

```bash
# Search sessions with filters
curl -X POST "https://your-openreplay-instance.com/api/{projectId}/sessions/search" \
  -H "Authorization: Bearer YOUR_JWT_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "startDate": 1704067200000,
    "endDate": 1704672000000,
    "filters": [
      {
        "type": "USERID",
        "operator": "is",
        "value": ["user-123"]
      },
      {
        "type": "DURATION",
        "operator": ">=",
        "value": [30000]
      },
      {
        "type": "REFERRER",
        "operator": "contains",
        "value": ["google.com"]
      }
    ],
    "sort": "startTs",
    "order": "desc",
    "limit": 50,
    "page": 1
  }'

# Response
{
  "data": {
    "sessions": [
      {
        "sessionId": "1234567890",
        "startTs": 1704326400000,
        "duration": 125000,
        "eventsCount": 234,
        "pagesCount": 5,
        "errorsCount": 2,
        "userBrowser": "Chrome",
        "userOs": "MacOS",
        "userDevice": "Desktop",
        "userCountry": "US",
        "userId": "user-123"
      }
    ],
    "total": 156
  }
}
```

---

## REST API - Session Replay

Retrieve session replay data including events and DOM snapshots.

```bash
# Get session replay data
curl -X GET "https://your-openreplay-instance.com/api/{projectId}/sessions/{sessionId}/replay" \
  -H "Authorization: Bearer YOUR_JWT_TOKEN"

# Response
{
  "data": {
    "sessionId": "1234567890",
    "projectId": 1,
    "startTs": 1704326400000,
    "duration": 125000,
    "events": [...],
    "errors": [
      {
        "errorId": "err-123",
        "name": "TypeError",
        "message": "Cannot read property 'map' of undefined",
        "timestamp": 1704326450000,
        "stack": "..."
      }
    ],
    "userBrowser": "Chrome 120",
    "userOs": "MacOS 14",
    "metadata": {
      "version": "2.1.0",
      "environment": "production"
    }
  }
}

# Get session events only
curl -X GET "https://your-openreplay-instance.com/api/{projectId}/sessions/{sessionId}/events" \
  -H "Authorization: Bearer YOUR_JWT_TOKEN"
```

---

## REST API - Live Assist Sessions

Get and manage live assistance sessions for real-time support.

```bash
# Get all live sessions in a project
curl -X GET "https://your-openreplay-instance.com/api/{projectId}/assist/sessions" \
  -H "Authorization: Bearer YOUR_JWT_TOKEN"

# Response
{
  "data": [
    {
      "sessionId": "live-session-123",
      "startTs": 1704326400000,
      "userId": "user-456",
      "userOs": "Windows",
      "userBrowser": "Firefox",
      "pageTitle": "Checkout - MyApp",
      "active": true,
      "live": true
    }
  ]
}

# Search live sessions with filters
curl -X POST "https://your-openreplay-instance.com/api/{projectId}/assist/sessions" \
  -H "Authorization: Bearer YOUR_JWT_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "filters": [
      {
        "type": "USERID",
        "value": ["premium-user"]
      }
    ],
    "sort": "startTs",
    "order": "desc"
  }'
```

---

## REST API - Error Management

Query and manage JavaScript errors captured in sessions.

```bash
# Get error details with occurrence data
curl -X GET "https://your-openreplay-instance.com/api/{projectId}/errors/{errorId}?density24=24&density30=30" \
  -H "Authorization: Bearer YOUR_JWT_TOKEN"

# Response
{
  "data": {
    "errorId": "err-abc123",
    "name": "TypeError",
    "message": "Cannot read property 'length' of undefined",
    "stack": "TypeError: Cannot read property 'length' of undefined\n    at processData (app.js:234:15)",
    "firstOccurrence": 1704067200000,
    "lastOccurrence": 1704326400000,
    "occurrences": 45,
    "sessionsCount": 23,
    "usersCount": 18,
    "chart24": [...],  // Hourly distribution
    "chart30": [...]   // Daily distribution over 30 days
  }
}

# Get sourcemapped stack trace
curl -X GET "https://your-openreplay-instance.com/api/{projectId}/errors/{errorId}/sourcemaps" \
  -H "Authorization: Bearer YOUR_JWT_TOKEN"
```

---

## REST API - Alerts

Configure alerts for real-time monitoring of application issues.

```bash
# Create a new alert
curl -X POST "https://your-openreplay-instance.com/api/{projectId}/alerts" \
  -H "Authorization: Bearer YOUR_JWT_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "High Error Rate Alert",
    "description": "Alert when JS errors exceed threshold",
    "detectionMethod": "threshold",
    "query": {
      "left": "errorsCount",
      "right": 100
    },
    "options": {
      "currentPeriod": 15,
      "previousPeriod": 15,
      "renotifyInterval": 60
    },
    "notifications": [
      {
        "type": "slack",
        "webhookId": 1
      },
      {
        "type": "email",
        "email": "team@example.com"
      }
    ]
  }'

# Get all alerts for a project
curl -X GET "https://your-openreplay-instance.com/api/{projectId}/alerts" \
  -H "Authorization: Bearer YOUR_JWT_TOKEN"

# Update an alert
curl -X POST "https://your-openreplay-instance.com/api/{projectId}/alerts/{alertId}" \
  -H "Authorization: Bearer YOUR_JWT_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Updated Alert Name",
    "active": true
  }'
```

---

## REST API - Sourcemap Upload

Upload sourcemaps for readable error stack traces.

```bash
# Get pre-signed URLs for sourcemap upload
curl -X PUT "https://your-openreplay-instance.com/api/{projectKey}/sourcemaps/" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "urls": [
      "https://myapp.com/static/js/main.abc123.js",
      "https://myapp.com/static/js/vendor.def456.js"
    ]
  }'

# Response
{
  "data": [
    {
      "url": "https://myapp.com/static/js/main.abc123.js",
      "signedUrl": "https://s3.amazonaws.com/bucket/sourcemaps/..."
    }
  ]
}

# Upload sourcemap to the signed URL
curl -X PUT "SIGNED_URL_FROM_RESPONSE" \
  -H "Content-Type: application/json" \
  --data-binary @main.abc123.js.map
```

---

## REST API - Integrations

Connect OpenReplay with external services like Sentry, Datadog, and Slack.

```bash
# Configure Sentry integration
curl -X POST "https://your-openreplay-instance.com/api/{projectId}/integrations/sentry" \
  -H "Authorization: Bearer YOUR_JWT_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "token": "SENTRY_AUTH_TOKEN",
    "organization_slug": "my-org",
    "project_slug": "my-project"
  }'

# Configure Datadog integration
curl -X POST "https://your-openreplay-instance.com/api/{projectId}/integrations/datadog" \
  -H "Authorization: Bearer YOUR_JWT_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "api_key": "DATADOG_API_KEY",
    "application_key": "DATADOG_APP_KEY"
  }'

# Add Slack webhook for notifications
curl -X POST "https://your-openreplay-instance.com/api/integrations/slack" \
  -H "Authorization: Bearer YOUR_JWT_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "url": "https://hooks.slack.com/services/T00000000/B00000000/XXXXXXXXXXXXXXXXXXXXXXXX",
    "name": "Engineering Channel"
  }'

# Get all integrations status
curl -X GET "https://your-openreplay-instance.com/api/{projectId}/integrations" \
  -H "Authorization: Bearer YOUR_JWT_TOKEN"
```

---

## REST API - Projects

Manage OpenReplay projects and their configurations.

```bash
# Create a new project
curl -X POST "https://your-openreplay-instance.com/api/projects" \
  -H "Authorization: Bearer YOUR_JWT_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "My New App",
    "platform": "web"
  }'

# Response
{
  "data": {
    "projectId": 123,
    "projectKey": "abc123xyz",
    "name": "My New App",
    "platform": "web"
  }
}

# Get all projects
curl -X GET "https://your-openreplay-instance.com/api/projects" \
  -H "Authorization: Bearer YOUR_JWT_TOKEN"

# Update project settings
curl -X PUT "https://your-openreplay-instance.com/api/projects/{projectId}" \
  -H "Authorization: Bearer YOUR_JWT_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Updated App Name"
  }'

# Configure sample rate for session recording
curl -X POST "https://your-openreplay-instance.com/api/{projectId}/sample_rate" \
  -H "Authorization: Bearer YOUR_JWT_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "rate": 50,
    "conditionalCapture": false
  }'
```

---

## REST API - Feature Flags

Manage feature flags for controlled rollouts and A/B testing.

```bash
# Create a feature flag
curl -X POST "https://your-openreplay-instance.com/api/{projectId}/feature-flags" \
  -H "Authorization: Bearer YOUR_JWT_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "new_checkout_flow",
    "description": "Enable new checkout experience",
    "is_active": true,
    "conditions": [
      {
        "type": "userProperty",
        "property": "plan",
        "operator": "is",
        "value": "premium"
      }
    ],
    "rollout_percentage": 25
  }'

# Get feature flag details
curl -X GET "https://your-openreplay-instance.com/api/{projectId}/feature-flags/{flagId}" \
  -H "Authorization: Bearer YOUR_JWT_TOKEN"

# Update feature flag status
curl -X POST "https://your-openreplay-instance.com/api/{projectId}/feature-flags/{flagId}/status" \
  -H "Authorization: Bearer YOUR_JWT_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "is_active": false
  }'

# Search feature flags
curl -X POST "https://your-openreplay-instance.com/api/{projectId}/feature-flags/search" \
  -H "Authorization: Bearer YOUR_JWT_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "query": "checkout",
    "is_active": true
  }'
```

---

## Tracker Configuration Options

Complete configuration options for the OpenReplay tracker.

```javascript
import Tracker from '@openreplay/tracker';

const tracker = new Tracker({
  // Required
  projectKey: 'YOUR_PROJECT_KEY',

  // Server configuration
  ingestPoint: 'https://api.openreplay.com/ingest', // Default for cloud
  resourceBaseHref: null, // Base URL for relative resource URLs

  // Session configuration
  revID: '1.0.0', // Your app revision ID
  respectDoNotTrack: false,

  // Storage keys (customize if conflicts)
  session_token_key: '__openreplay_token',
  session_pageno_key: '__openreplay_pageno',
  session_tabid_key: '__openreplay_tabid',
  local_uuid_key: '__openreplay_uuid',

  // Privacy options
  obscureTextEmails: true,
  obscureTextNumbers: false,
  defaultInputMode: 0, // 0=plain, 1=obscured, 2=hidden

  // Performance options
  disableStringDict: false,
  forceSingleTab: false,

  // Canvas recording
  canvas: {
    disableCanvas: false,
    fixedCanvasScaling: false,
    useAnimationFrame: false,
    fileExt: 'webp' // 'webp', 'png', 'jpeg', 'avif'
  },

  // Cross-domain iframe tracking
  crossdomain: {
    enabled: false,
    parentDomain: '*'
  },

  // Network capture
  network: {
    failuresOnly: false,
    ignoreHeaders: ['Cookie', 'Authorization'],
    capturePayload: true,
    sessionTokenHeader: null,
    captureInIframes: false
  },

  // Development
  __DISABLE_SECURE_MODE: false, // Enable for localhost testing
  __debug__: 0 // 0=silent, 1=errors, 2=warnings, 3=verbose
});
```

---

OpenReplay provides a comprehensive session replay and debugging platform that integrates seamlessly with modern JavaScript applications. The tracker SDK captures DOM mutations, user interactions, network requests, console logs, and JavaScript errors with minimal performance impact (~26KB compressed). For web applications, it supports major frameworks including React, Vue, Angular, and Svelte through its plugin architecture.

The self-hosted deployment option makes OpenReplay ideal for organizations with strict data privacy requirements, as all session data remains within your infrastructure. The platform supports scalable deployments on AWS, GCP, Azure, and Kubernetes, with built-in integrations for popular monitoring tools like Sentry, Datadog, and New Relic. The Assist feature enables real-time co-browsing and WebRTC calls, making it valuable for customer support teams who need to see exactly what users see and guide them through issues interactively.