35000 Watts :: The Story of College Radio

Posthog Session Replay Portable Online

// session-uploader.ts
class SessionUploader 
  async uploadSession(session: SessionRecording, endpoint: string): Promise<void> 
    const compressed = await this.compressSession(session);

const response = await fetch(endpoint, 
  method: 'POST',
  headers: 
    'Content-Type': 'application/json',
  ,
  body: JSON.stringify(
    sessionId: session.sessionId,
    userId: session.userId,
    startTime: session.startTime,
    endTime: session.endTime,
    events: compressed,
    metadata: session.metadata,
  ),
);
if (!response.ok) 
  throw new Error(`Upload failed: $response.statusText`);





private async compressSession(session: SessionRecording): Promise<any> 
// Implement compression (e.g., using CompressionStream API)
const jsonString = JSON.stringify(session.events);
const compressed = await this.gzipCompress(jsonString);
return 
compressed: true,
algorithm: 'gzip',
data: Array.from(new Uint8Array(compressed)),
;



private async gzipCompress(data: string): Promise<ArrayBuffer> 
const stream = new CompressionStream('gzip');
const writer = stream.writable.getWriter();
writer.write(new TextEncoder().encode(data));
writer.close();


const compressed = await new Response(stream.readable).arrayBuffer();
return compressed;

This implementation provides:

The system works completely offline and doesn't require PostHog cloud services, making it truly portable. posthog session replay portable

PostHog's session replay is highly portable across platforms, enabling you to record and watch user interactions on React Native Key Portable Features Multi-Platform Support : Capture sessions on web apps via posthog-js

or on mobile apps using native and cross-platform SDKs (Android, iOS, React Native, Flutter). Shareable Links

: Individual replays can be shared via direct links or organized into collections for internal reviews. Integration Flexibility

: Replay links can be automatically added as attributes in tools like or linked to support tickets in Data Portability : You can export recording data to formats for external analysis or documentation. Implementation Highlights : Quick setup by installing the PostHog-js library or using a snippet. Mobile (Android/iOS)

: Uses "wireframe" or "screenshot" modes to reconstruct sessions, ensuring visibility even on complex mobile UI frameworks like SwiftUI. Privacy & Control : Includes portable Privacy Controls ph-no-capture tags to mask sensitive data across all platforms. For developer-specific details, you can explore the Session Replay Architecture

or find installation guides for your specific tech stack in the PostHog Docs code snippets // session-uploader

for integrating PostHog session replay into a particular platform? Privacy controls - Docs - PostHog

PostHog's session replay is a "portable" and highly versatile tool because it functions across both web and mobile platforms (iOS, Android, React Native, and Flutter). While it doesn't offer a traditional "portable" standalone executable file (like a .exe or .app that works offline), its data and insights are highly mobile through cloud access, extensive sharing features, and integration capabilities. Core Platform Support

PostHog offers "portable" coverage for your entire application stack with dedicated SDKs: Web: Capture detailed user interactions on any website.

Mobile: Dedicated support for iOS, Android, React Native, and Flutter.

Mobile Mode: For mobile, it defaults to a performance-friendly Wireframe mode that captures the UI hierarchy as JSON, though a screenshot mode is also available. Features for Sharing and Portability

The platform makes session data easy to move and share across teams: Mobile session replay - Docs - PostHog extensive sharing features

Imagine a bug that only appears when a user has an ad-blocker and a specific browser extension.

Session replays are bulky. Storing 90 days of replays in PostHog Cloud can get expensive. With portability, you can set up a lifecycle policy: keep recent replays in PostHog for debugging, but export historical replays to Glacier or Deep Archive for 7-year retention at pennies per gigabyte.

There are two main ways to achieve portability:

Critically, PostHog does not record a video MP4. It records a series of DOM mutation events and user interactions via JSON. This is massive for portability.

Traditional session replay records DOM mutations. PostHog captures these events as JSON blobs. Instead of storing these in a proprietary database format, PostHog allows you to pipe these blobs directly into object storage.

The workflow is simple:

Because the data is stored as standard JSON (not a binary proprietary format), you can write a simple Python or Node script to read these files and reconstruct the session without ever touching PostHog’s server.