funnel

* init

* fix

* update docs

* bump: all sdks

* rename types test

.gitignore

@@ -1,5 +1,6 @@
 .secrets
 packages/db/src/generated/prisma
+packages/db/code-migrations/*.sql
 
 # Based on https://raw.githubusercontent.com/github/gitignore/main/Node.gitignore
 packages/sdk/profileId.txt

.vscode/settings.json

@@ -17,7 +17,7 @@
     "editor.defaultFormatter": "biomejs.biome"
   },
   "[json]": {
-    "editor.defaultFormatter": "biomejs.biome"
+    "editor.defaultFormatter": "vscode.json-language-features"
   },
   "editor.formatOnSave": true,
   "tailwindCSS.experimental.classRegex": [

admin/README.md

@@ -0,0 +1,161 @@
+# OpenPanel Admin CLI
+
+An interactive CLI tool to help manage and lookup OpenPanel organizations, projects, and clients.
+
+## Setup
+
+First, install dependencies:
+
+```bash
+cd admin
+pnpm install
+```
+
+## Usage
+
+Run the CLI from the admin directory:
+
+```bash
+pnpm start
+```
+
+Or use the convenient shell script from anywhere:
+
+```bash
+./admin/cli
+```
+
+## Features
+
+The CLI provides 4 focused lookup commands for easier navigation:
+
+### 🏢 Lookup by Organization
+
+Search and view detailed information about an organization.
+
+- Fuzzy search across all organizations by name or ID
+- Shows full organization details with all projects, clients, and members
+
+### 📊 Lookup by Project
+
+Search for a specific project and view its organization context.
+
+- Fuzzy search across all projects by name or ID
+- Highlights the selected project in the organization view
+- Displays: `org → project`
+
+### 🔑 Lookup by Client ID
+
+Search for a specific client and view its full context.
+
+- Fuzzy search across all clients by name or ID
+- Highlights the selected client and its project
+- Displays: `org → project → client`
+
+### 📧 Lookup by Email
+
+Search for a member by email address.
+
+- Fuzzy search across all member emails
+- Shows which organization(s) the member belongs to
+- Displays member role (👑 owner, ⭐ admin, 👤 member)
+
+**All lookups display:**
+- Organization information (ID, name, subscription status, timezone, event usage)
+- Organization members and their roles
+- All projects with their settings (domain, CORS, event counts)
+- All clients for each project (ID, name, type, credentials)
+- Deletion warnings if scheduled
+
+---
+
+### 🗑️ Clear Cache
+
+Clear cache for an organization and all its projects.
+
+- Fuzzy search to find the organization
+- Shows organization details and all projects
+- Confirms before clearing cache
+- Provides organization ID and all project IDs for cache clearing logic
+
+**Use when:**
+- You need to invalidate cache after data changes
+- Troubleshooting caching issues
+- After manual database updates
+
+**Note:** The cache clearing logic needs to be implemented. The command provides the organization and project data structure for you to add your cache clearing calls.
+
+---
+
+### 🔴 Delete Organization
+
+Permanently delete an organization and all its data.
+
+- Fuzzy search to find the organization
+- Shows detailed preview of what will be deleted (projects, members, events)
+- Requires **3 confirmations**:
+  1. Initial confirmation
+  2. Type organization name to confirm
+  3. Final warning confirmation
+- Deletes from both PostgreSQL and ClickHouse
+
+**Use when:**
+- Removing organizations that are no longer needed
+- Cleaning up test/demo organizations
+- Handling deletion requests
+
+**⚠️ WARNING:** This action is PERMANENT and cannot be undone!
+
+**What gets deleted:**
+- Organization record
+- All projects and their settings
+- All clients and credentials
+- All events and analytics data (from ClickHouse)
+- All member associations
+- All dashboards and reports
+
+---
+
+### 🔴 Delete User
+
+Permanently delete a user account and remove them from all organizations.
+
+- Fuzzy search by email or name
+- Shows which organizations the user belongs to
+- Shows if user created any organizations (won't delete those orgs)
+- Requires **3 confirmations**:
+  1. Initial confirmation
+  2. Type user email to confirm
+  3. Final warning confirmation
+
+**Use when:**
+- Removing user accounts at user request
+- Cleaning up inactive accounts
+- Handling GDPR/data deletion requests
+
+**⚠️ WARNING:** This action is PERMANENT and cannot be undone!
+
+**What gets deleted:**
+- User account
+- All auth sessions and tokens
+- All memberships (removed from all orgs)
+- All personal data
+
+**What is NOT deleted:**
+- Organizations created by the user (only the creator reference is removed)
+
+## Environment Variables
+
+Make sure you have the proper environment variables set up:
+- `DATABASE_URL` - PostgreSQL connection string
+- `DATABASE_URL_REPLICA` (optional) - Read replica connection string
+
+## Development
+
+The CLI uses:
+- **jiti** - Direct TypeScript execution without build step
+- **inquirer** - Interactive prompts
+- **inquirer-autocomplete-prompt** - Fuzzy search functionality
+- **chalk** - Colored terminal output
+- **@openpanel/db** - Direct Prisma database access
+

admin/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "@openpanel/admin",
+  "version": "0.0.1",
+  "type": "module",
+  "private": true,
+  "scripts": {
+    "start": "dotenv -e .env -c -- jiti src/cli.ts",
+    "typecheck": "tsc --noEmit"
+  },
+  "dependencies": {
+    "@openpanel/common": "workspace:*",
+    "@openpanel/db": "workspace:*",
+    "chalk": "^5.3.0",
+    "fuzzy": "^0.1.3",
+    "inquirer": "^9.3.5",
+    "inquirer-autocomplete-prompt": "^3.0.1",
+    "jiti": "^2.4.2"
+  },
+  "devDependencies": {
+    "@types/inquirer": "^9.0.7",
+    "@types/inquirer-autocomplete-prompt": "^3.0.3",
+    "@types/node": "catalog:",
+    "typescript": "catalog:"
+  }
+}

admin/src/cli.ts

@@ -0,0 +1,118 @@
+#!/usr/bin/env node
+import inquirer from 'inquirer';
+import { clearCache } from './commands/clear-cache';
+import { deleteOrganization } from './commands/delete-organization';
+import { deleteUser } from './commands/delete-user';
+import { lookupByClient } from './commands/lookup-client';
+import { lookupByEmail } from './commands/lookup-email';
+import { lookupByOrg } from './commands/lookup-org';
+import { lookupByProject } from './commands/lookup-project';
+
+const secureEnv = (url: string) => {
+  const parsed = new URL(url);
+  if (parsed.username && parsed.password) {
+    return `${parsed.protocol}//${parsed.username}:${parsed.password.slice(0, 1)}...${parsed.password.slice(-1)}@${parsed.hostname}:${parsed.port}`;
+  }
+
+  return url;
+};
+
+async function main() {
+  console.log('\n🔧 OpenPanel Admin CLI\n');
+
+  const DATABASE_URL = process.env.DATABASE_URL;
+  const CLICKHOUSE_URL = process.env.CLICKHOUSE_URL;
+  const REDIS_URL = process.env.REDIS_URL;
+
+  if (!DATABASE_URL || !CLICKHOUSE_URL || !REDIS_URL) {
+    console.error('Environment variables are not set');
+    process.exit(1);
+  }
+
+  // Log environment variables for debugging
+  console.log('Environment:', {
+    NODE_ENV: process.env.NODE_ENV,
+    SELF_HOSTED: process.env.SELF_HOSTED ? 'Yes' : 'No',
+    DATABASE_URL: secureEnv(DATABASE_URL),
+    CLICKHOUSE_URL: secureEnv(CLICKHOUSE_URL),
+    REDIS_URL: secureEnv(REDIS_URL),
+  });
+  console.log('');
+
+  const { command } = await inquirer.prompt([
+    {
+      type: 'list',
+      name: 'command',
+      message: 'What would you like to do?',
+      pageSize: 20,
+      choices: [
+        {
+          name: '🏢 Lookup by Organization',
+          value: 'lookup-org',
+        },
+        {
+          name: '📊 Lookup by Project',
+          value: 'lookup-project',
+        },
+        {
+          name: '🔑 Lookup by Client ID',
+          value: 'lookup-client',
+        },
+        {
+          name: '📧 Lookup by Email',
+          value: 'lookup-email',
+        },
+        {
+          name: '🗑️  Clear Cache',
+          value: 'clear-cache',
+        },
+        { name: '─────────────────────', value: 'separator', disabled: true },
+        {
+          name: '🔴 Delete Organization',
+          value: 'delete-org',
+        },
+        {
+          name: '🔴 Delete User',
+          value: 'delete-user',
+        },
+        { name: '─────────────────────', value: 'separator', disabled: true },
+        { name: '❌ Exit', value: 'exit' },
+      ],
+    },
+  ]);
+
+  switch (command) {
+    case 'lookup-org':
+      await lookupByOrg();
+      break;
+    case 'lookup-project':
+      await lookupByProject();
+      break;
+    case 'lookup-client':
+      await lookupByClient();
+      break;
+    case 'lookup-email':
+      await lookupByEmail();
+      break;
+    case 'clear-cache':
+      await clearCache();
+      break;
+    case 'delete-org':
+      await deleteOrganization();
+      break;
+    case 'delete-user':
+      await deleteUser();
+      break;
+    case 'exit':
+      console.log('Goodbye! 👋');
+      process.exit(0);
+  }
+
+  // Loop back to main menu
+  await main();
+}
+
+main().catch((error) => {
+  console.error('Error:', error);
+  process.exit(1);
+});

admin/src/commands/clear-cache.ts

@@ -0,0 +1,162 @@
+import {
+  db,
+  getOrganizationAccess,
+  getOrganizationByProjectIdCached,
+  getProjectAccess,
+  getProjectByIdCached,
+} from '@openpanel/db';
+import chalk from 'chalk';
+import fuzzy from 'fuzzy';
+import inquirer from 'inquirer';
+import autocomplete from 'inquirer-autocomplete-prompt';
+
+// Register autocomplete prompt
+inquirer.registerPrompt('autocomplete', autocomplete);
+
+interface OrgSearchItem {
+  id: string;
+  name: string;
+  displayText: string;
+}
+
+export async function clearCache() {
+  console.log(chalk.blue('\n🗑️  Clear Cache\n'));
+  console.log('Loading organizations...\n');
+
+  const organizations = await db.organization.findMany({
+    orderBy: {
+      name: 'asc',
+    },
+  });
+
+  if (organizations.length === 0) {
+    console.log(chalk.red('No organizations found.'));
+    return;
+  }
+
+  const searchItems: OrgSearchItem[] = organizations.map((org) => ({
+    id: org.id,
+    name: org.name,
+    displayText: `${org.name} ${chalk.gray(`(${org.id})`)}`,
+  }));
+
+  const searchFunction = async (_answers: unknown, input = '') => {
+    const fuzzyResult = fuzzy.filter(input, searchItems, {
+      extract: (item: OrgSearchItem) => `${item.name} ${item.id}`,
+    });
+
+    return fuzzyResult.map((result: fuzzy.FilterResult<OrgSearchItem>) => ({
+      name: result.original.displayText,
+      value: result.original,
+    }));
+  };
+
+  const { selectedOrg } = (await inquirer.prompt([
+    {
+      type: 'autocomplete',
+      name: 'selectedOrg',
+      message: 'Search for an organization:',
+      source: searchFunction,
+      pageSize: 15,
+    },
+  ])) as { selectedOrg: OrgSearchItem };
+
+  // Fetch organization with all projects
+  const organization = await db.organization.findUnique({
+    where: {
+      id: selectedOrg.id,
+    },
+    include: {
+      projects: {
+        orderBy: {
+          name: 'asc',
+        },
+      },
+      members: {
+        include: {
+          user: true,
+        },
+      },
+    },
+  });
+
+  if (!organization) {
+    console.log(chalk.red('Organization not found.'));
+    return;
+  }
+
+  console.log(chalk.yellow('\n📋 Organization Details:\n'));
+  console.log(`  ${chalk.gray('ID:')} ${organization.id}`);
+  console.log(`  ${chalk.gray('Name:')} ${organization.name}`);
+  console.log(`  ${chalk.gray('Projects:')} ${organization.projects.length}`);
+
+  if (organization.projects.length > 0) {
+    console.log(chalk.yellow('\n📊 Projects:\n'));
+    for (const project of organization.projects) {
+      console.log(
+        `  - ${project.name} ${chalk.gray(`(${project.id})`)} - ${chalk.cyan(`${project.eventsCount.toLocaleString()} events`)}`,
+      );
+    }
+  }
+
+  // Confirm before clearing cache
+  const { confirm } = await inquirer.prompt([
+    {
+      type: 'confirm',
+      name: 'confirm',
+      message: `Clear cache for organization "${organization.name}" and all ${organization.projects.length} projects?`,
+      default: false,
+    },
+  ]);
+
+  if (!confirm) {
+    console.log(chalk.yellow('\nCache clear cancelled.'));
+    return;
+  }
+
+  console.log(chalk.blue('\n🔄 Clearing cache...\n'));
+
+  for (const project of organization.projects) {
+    // Clear project access cache for each member
+    for (const member of organization.members) {
+      if (!member.user?.id) continue;
+      console.log(
+        `Clearing cache for project: ${project.name} and member: ${member.user?.email}`,
+      );
+      await getProjectAccess.clear({
+        userId: member.user?.id,
+        projectId: project.id,
+      });
+      await getOrganizationAccess.clear({
+        userId: member.user?.id,
+        organizationId: organization.id,
+      });
+    }
+
+    console.log(`Clearing cache for project: ${project.name}`);
+    await getOrganizationByProjectIdCached.clear(project.id);
+    await getProjectByIdCached.clear(project.id);
+  }
+
+  console.log(chalk.gray(`Organization ID: ${organization.id}`));
+  console.log(
+    chalk.gray(
+      `Project IDs: ${organization.projects.map((p) => p.id).join(', ')}`,
+    ),
+  );
+
+  // Example of what you might do:
+  /*
+  for (const project of organization.projects) {
+    console.log(`Clearing cache for project: ${project.name}...`);
+    // await clearProjectCache(project.id);
+    // await redis.del(`project:${project.id}:*`);
+  }
+  
+  // Clear organization-level cache
+  // await clearOrganizationCache(organization.id);
+  // await redis.del(`organization:${organization.id}:*`);
+  
+  console.log(chalk.green('\n✅ Cache cleared successfully!'));
+  */
+}

admin/src/commands/delete-organization.ts

@@ -0,0 +1,215 @@
+import {
+  db,
+  deleteFromClickhouse,
+  deleteOrganization as deleteOrg,
+} from '@openpanel/db';
+import chalk from 'chalk';
+import fuzzy from 'fuzzy';
+import inquirer from 'inquirer';
+import autocomplete from 'inquirer-autocomplete-prompt';
+
+// Register autocomplete prompt
+inquirer.registerPrompt('autocomplete', autocomplete);
+
+interface OrgSearchItem {
+  id: string;
+  name: string;
+  displayText: string;
+}
+
+export async function deleteOrganization() {
+  console.log(chalk.red('\n🗑️  Delete Organization\n'));
+  console.log(
+    chalk.yellow(
+      '⚠️  WARNING: This will permanently delete the organization and all its data!\n',
+    ),
+  );
+  console.log('Loading organizations...\n');
+
+  const organizations = await db.organization.findMany({
+    include: {
+      projects: true,
+      members: {
+        include: {
+          user: true,
+        },
+      },
+    },
+    orderBy: {
+      name: 'asc',
+    },
+  });
+
+  if (organizations.length === 0) {
+    console.log(chalk.red('No organizations found.'));
+    return;
+  }
+
+  const searchItems: OrgSearchItem[] = organizations.map((org) => ({
+    id: org.id,
+    name: org.name,
+    displayText: `${org.name} ${chalk.gray(`(${org.id})`)} ${chalk.cyan(`- ${org.projects.length} projects, ${org.members.length} members`)}`,
+  }));
+
+  const searchFunction = async (_answers: unknown, input = '') => {
+    const fuzzyResult = fuzzy.filter(input, searchItems, {
+      extract: (item: OrgSearchItem) => `${item.name} ${item.id}`,
+    });
+
+    return fuzzyResult.map((result: fuzzy.FilterResult<OrgSearchItem>) => ({
+      name: result.original.displayText,
+      value: result.original,
+    }));
+  };
+
+  const { selectedOrg } = (await inquirer.prompt([
+    {
+      type: 'autocomplete',
+      name: 'selectedOrg',
+      message: 'Search for an organization to delete:',
+      source: searchFunction,
+      pageSize: 15,
+    },
+  ])) as { selectedOrg: OrgSearchItem };
+
+  // Fetch full organization details
+  const organization = await db.organization.findUnique({
+    where: {
+      id: selectedOrg.id,
+    },
+    include: {
+      projects: {
+        include: {
+          clients: true,
+        },
+      },
+      members: {
+        include: {
+          user: true,
+        },
+      },
+    },
+  });
+
+  if (!organization) {
+    console.log(chalk.red('Organization not found.'));
+    return;
+  }
+
+  // Display what will be deleted
+  console.log(chalk.red('\n⚠️  YOU ARE ABOUT TO DELETE:\n'));
+  console.log(`  ${chalk.bold('Organization:')} ${organization.name}`);
+  console.log(`  ${chalk.gray('ID:')} ${organization.id}`);
+  console.log(`  ${chalk.gray('Projects:')} ${organization.projects.length}`);
+  console.log(`  ${chalk.gray('Members:')} ${organization.members.length}`);
+
+  if (organization.projects.length > 0) {
+    console.log(chalk.red('\n  Projects that will be deleted:'));
+    for (const project of organization.projects) {
+      console.log(
+        `    - ${project.name} ${chalk.gray(`(${project.eventsCount.toLocaleString()} events, ${project.clients.length} clients)`)}`,
+      );
+    }
+  }
+
+  if (organization.members.length > 0) {
+    console.log(chalk.red('\n  Members who will lose access:'));
+    for (const member of organization.members) {
+      const email = member.user?.email || member.email || 'Unknown';
+      console.log(`    - ${email} ${chalk.gray(`(${member.role})`)}`);
+    }
+  }
+
+  console.log(
+    chalk.red(
+      '\n⚠️  This will delete ALL projects, clients, events, and data associated with this organization!',
+    ),
+  );
+
+  // First confirmation
+  const { confirmFirst } = await inquirer.prompt([
+    {
+      type: 'confirm',
+      name: 'confirmFirst',
+      message: chalk.red(
+        `Are you ABSOLUTELY SURE you want to delete "${organization.name}"?`,
+      ),
+      default: false,
+    },
+  ]);
+
+  if (!confirmFirst) {
+    console.log(chalk.yellow('\nDeletion cancelled.'));
+    return;
+  }
+
+  // Second confirmation - type organization name
+  const { confirmName } = await inquirer.prompt([
+    {
+      type: 'input',
+      name: 'confirmName',
+      message: `Type the organization name "${organization.name}" to confirm deletion:`,
+    },
+  ]);
+
+  if (confirmName !== organization.name) {
+    console.log(
+      chalk.red('\n❌ Organization name does not match. Deletion cancelled.'),
+    );
+    return;
+  }
+
+  // Final confirmation
+  const { confirmFinal } = await inquirer.prompt([
+    {
+      type: 'confirm',
+      name: 'confirmFinal',
+      message: chalk.red(
+        'FINAL WARNING: This action CANNOT be undone. Delete now?',
+      ),
+      default: false,
+    },
+  ]);
+
+  if (!confirmFinal) {
+    console.log(chalk.yellow('\nDeletion cancelled.'));
+    return;
+  }
+
+  console.log(chalk.red('\n🗑️  Deleting organization...\n'));
+
+  try {
+    const projectIds = organization.projects.map((p) => p.id);
+
+    // Step 1: Delete from ClickHouse (events, profiles, etc.)
+    if (projectIds.length > 0) {
+      console.log(
+        chalk.yellow(
+          `Deleting data from ClickHouse for ${projectIds.length} projects...`,
+        ),
+      );
+      await deleteFromClickhouse(projectIds);
+      console.log(chalk.green('✓ ClickHouse data deletion initiated'));
+    }
+
+    // Step 2: Delete the organization from PostgreSQL (cascade will handle related records)
+    console.log(chalk.yellow('Deleting organization from database...'));
+    await deleteOrg(organization.id);
+    console.log(chalk.green('✓ Organization deleted from database'));
+
+    console.log(chalk.green('\n✅ Organization deleted successfully!'));
+    console.log(
+      chalk.gray(
+        `Deleted: ${organization.name} with ${organization.projects.length} projects and ${organization.members.length} members`,
+      ),
+    );
+    console.log(
+      chalk.gray(
+        '\nNote: ClickHouse deletions are processed asynchronously and may take a few moments to complete.',
+      ),
+    );
+  } catch (error) {
+    console.error(chalk.red('\n❌ Error deleting organization:'), error);
+    throw error;
+  }
+}

admin/src/commands/delete-user.ts

@@ -0,0 +1,220 @@
+import { db } from '@openpanel/db';
+import chalk from 'chalk';
+import fuzzy from 'fuzzy';
+import inquirer from 'inquirer';
+import autocomplete from 'inquirer-autocomplete-prompt';
+
+// Register autocomplete prompt
+inquirer.registerPrompt('autocomplete', autocomplete);
+
+interface UserSearchItem {
+  id: string;
+  email: string;
+  firstName: string | null;
+  lastName: string | null;
+  displayText: string;
+}
+
+export async function deleteUser() {
+  console.log(chalk.red('\n🗑️  Delete User\n'));
+  console.log(
+    chalk.yellow(
+      '⚠️  WARNING: This will permanently delete the user and remove them from all organizations!\n',
+    ),
+  );
+  console.log('Loading users...\n');
+
+  const users = await db.user.findMany({
+    include: {
+      membership: {
+        include: {
+          organization: true,
+        },
+      },
+      accounts: true,
+    },
+    orderBy: {
+      email: 'asc',
+    },
+  });
+
+  if (users.length === 0) {
+    console.log(chalk.red('No users found.'));
+    return;
+  }
+
+  const searchItems: UserSearchItem[] = users.map((user) => {
+    const fullName =
+      user.firstName || user.lastName
+        ? `${user.firstName || ''} ${user.lastName || ''}`.trim()
+        : '';
+    const orgCount = user.membership.length;
+
+    return {
+      id: user.id,
+      email: user.email,
+      firstName: user.firstName,
+      lastName: user.lastName,
+      displayText: `${user.email} ${fullName ? chalk.gray(`(${fullName})`) : ''} ${chalk.cyan(`- ${orgCount} orgs`)}`,
+    };
+  });
+
+  const searchFunction = async (_answers: unknown, input = '') => {
+    const fuzzyResult = fuzzy.filter(input, searchItems, {
+      extract: (item: UserSearchItem) =>
+        `${item.email} ${item.firstName || ''} ${item.lastName || ''}`,
+    });
+
+    return fuzzyResult.map((result: fuzzy.FilterResult<UserSearchItem>) => ({
+      name: result.original.displayText,
+      value: result.original,
+    }));
+  };
+
+  const { selectedUser } = (await inquirer.prompt([
+    {
+      type: 'autocomplete',
+      name: 'selectedUser',
+      message: 'Search for a user to delete:',
+      source: searchFunction,
+      pageSize: 15,
+    },
+  ])) as { selectedUser: UserSearchItem };
+
+  // Fetch full user details
+  const user = await db.user.findUnique({
+    where: {
+      id: selectedUser.id,
+    },
+    include: {
+      membership: {
+        include: {
+          organization: true,
+        },
+      },
+      accounts: true,
+      createdOrganizations: true,
+    },
+  });
+
+  if (!user) {
+    console.log(chalk.red('User not found.'));
+    return;
+  }
+
+  // Display what will be deleted
+  console.log(chalk.red('\n⚠️  YOU ARE ABOUT TO DELETE:\n'));
+  console.log(`  ${chalk.bold('User:')} ${user.email}`);
+  if (user.firstName || user.lastName) {
+    console.log(
+      `  ${chalk.gray('Name:')} ${user.firstName || ''} ${user.lastName || ''}`,
+    );
+  }
+  console.log(`  ${chalk.gray('ID:')} ${user.id}`);
+  console.log(
+    `  ${chalk.gray('Member of:')} ${user.membership.length} organizations`,
+  );
+  console.log(`  ${chalk.gray('Auth accounts:')} ${user.accounts.length}`);
+
+  if (user.createdOrganizations.length > 0) {
+    console.log(
+      chalk.red(
+        `\n  ⚠️  This user CREATED ${user.createdOrganizations.length} organization(s):`,
+      ),
+    );
+    for (const org of user.createdOrganizations) {
+      console.log(`    - ${org.name} ${chalk.gray(`(${org.id})`)}`);
+    }
+    console.log(
+      chalk.yellow(
+        '    Note: These organizations will NOT be deleted, only the user reference.',
+      ),
+    );
+  }
+
+  if (user.membership.length > 0) {
+    console.log(
+      chalk.red('\n  Organizations where user will be removed from:'),
+    );
+    for (const member of user.membership) {
+      console.log(
+        `    - ${member.organization.name} ${chalk.gray(`(${member.role})`)}`,
+      );
+    }
+  }
+
+  console.log(
+    chalk.red(
+      '\n⚠️  This will delete the user account, all sessions, and remove them from all organizations!',
+    ),
+  );
+
+  // First confirmation
+  const { confirmFirst } = await inquirer.prompt([
+    {
+      type: 'confirm',
+      name: 'confirmFirst',
+      message: chalk.red(
+        `Are you ABSOLUTELY SURE you want to delete user "${user.email}"?`,
+      ),
+      default: false,
+    },
+  ]);
+
+  if (!confirmFirst) {
+    console.log(chalk.yellow('\nDeletion cancelled.'));
+    return;
+  }
+
+  // Second confirmation - type email
+  const { confirmEmail } = await inquirer.prompt([
+    {
+      type: 'input',
+      name: 'confirmEmail',
+      message: `Type the user email "${user.email}" to confirm deletion:`,
+    },
+  ]);
+
+  if (confirmEmail !== user.email) {
+    console.log(chalk.red('\n❌ Email does not match. Deletion cancelled.'));
+    return;
+  }
+
+  // Final confirmation
+  const { confirmFinal } = await inquirer.prompt([
+    {
+      type: 'confirm',
+      name: 'confirmFinal',
+      message: chalk.red(
+        'FINAL WARNING: This action CANNOT be undone. Delete now?',
+      ),
+      default: false,
+    },
+  ]);
+
+  if (!confirmFinal) {
+    console.log(chalk.yellow('\nDeletion cancelled.'));
+    return;
+  }
+
+  console.log(chalk.red('\n🗑️  Deleting user...\n'));
+
+  try {
+    // Delete the user (cascade will handle related records like sessions, accounts, memberships)
+    await db.user.delete({
+      where: {
+        id: user.id,
+      },
+    });
+
+    console.log(chalk.green('\n✅ User deleted successfully!'));
+    console.log(
+      chalk.gray(
+        `Deleted: ${user.email} (removed from ${user.membership.length} organizations)`,
+      ),
+    );
+  } catch (error) {
+    console.error(chalk.red('\n❌ Error deleting user:'), error);
+    throw error;
+  }
+}

admin/src/commands/lookup-client.ts

@@ -0,0 +1,104 @@
+import { db } from '@openpanel/db';
+import chalk from 'chalk';
+import fuzzy from 'fuzzy';
+import inquirer from 'inquirer';
+import autocomplete from 'inquirer-autocomplete-prompt';
+import { displayOrganizationDetails } from '../utils/display';
+
+// Register autocomplete prompt
+inquirer.registerPrompt('autocomplete', autocomplete);
+
+interface ClientSearchItem {
+  id: string;
+  name: string;
+  organizationId: string;
+  organizationName: string;
+  projectId: string | null;
+  projectName: string | null;
+  displayText: string;
+}
+
+export async function lookupByClient() {
+  console.log(chalk.blue('\n🔑 Lookup by Client ID\n'));
+  console.log('Loading clients...\n');
+
+  const clients = await db.client.findMany({
+    include: {
+      organization: true,
+      project: true,
+    },
+    orderBy: {
+      name: 'asc',
+    },
+  });
+
+  if (clients.length === 0) {
+    console.log(chalk.red('No clients found.'));
+    return;
+  }
+
+  const searchItems: ClientSearchItem[] = clients.map((client) => ({
+    id: client.id,
+    name: client.name,
+    organizationId: client.organizationId,
+    organizationName: client.organization.name,
+    projectId: client.projectId,
+    projectName: client.project?.name || null,
+    displayText: `${client.organization.name} → ${client.project?.name || '[No Project]'} → ${client.name} ${chalk.gray(`(${client.id})`)}`,
+  }));
+
+  const searchFunction = async (_answers: unknown, input = '') => {
+    const fuzzyResult = fuzzy.filter(input, searchItems, {
+      extract: (item: ClientSearchItem) =>
+        `${item.organizationName} ${item.projectName || ''} ${item.name} ${item.id}`,
+    });
+
+    return fuzzyResult.map((result: fuzzy.FilterResult<ClientSearchItem>) => ({
+      name: result.original.displayText,
+      value: result.original,
+    }));
+  };
+
+  const { selectedClient } = (await inquirer.prompt([
+    {
+      type: 'autocomplete',
+      name: 'selectedClient',
+      message: 'Search for a client:',
+      source: searchFunction,
+      pageSize: 15,
+    },
+  ])) as { selectedClient: ClientSearchItem };
+
+  // Fetch full organization details
+  const organization = await db.organization.findUnique({
+    where: {
+      id: selectedClient.organizationId,
+    },
+    include: {
+      projects: {
+        include: {
+          clients: true,
+        },
+        orderBy: {
+          name: 'asc',
+        },
+      },
+      members: {
+        include: {
+          user: true,
+        },
+      },
+    },
+  });
+
+  if (!organization) {
+    console.log(chalk.red('Organization not found.'));
+    return;
+  }
+
+  displayOrganizationDetails(organization, {
+    highlightProjectId: selectedClient.projectId || undefined,
+    highlightClientId: selectedClient.id,
+  });
+}
+

admin/src/commands/lookup-email.ts

@@ -0,0 +1,112 @@
+import { db } from '@openpanel/db';
+import chalk from 'chalk';
+import fuzzy from 'fuzzy';
+import inquirer from 'inquirer';
+import autocomplete from 'inquirer-autocomplete-prompt';
+import { displayOrganizationDetails } from '../utils/display';
+
+// Register autocomplete prompt
+inquirer.registerPrompt('autocomplete', autocomplete);
+
+interface EmailSearchItem {
+  email: string;
+  organizationId: string;
+  organizationName: string;
+  role: string;
+  userId: string | null;
+  displayText: string;
+}
+
+export async function lookupByEmail() {
+  console.log(chalk.blue('\n📧 Lookup by Email\n'));
+  console.log('Loading members...\n');
+
+  const members = await db.member.findMany({
+    include: {
+      organization: true,
+      user: true,
+    },
+    orderBy: {
+      email: 'asc',
+    },
+  });
+
+  if (members.length === 0) {
+    console.log(chalk.red('No members found.'));
+    return;
+  }
+
+  // Group by email (in case same email is in multiple orgs)
+  const searchItems: EmailSearchItem[] = members.map((member) => {
+    const email = member.user?.email || member.email || 'Unknown';
+    const roleBadge =
+      member.role === 'owner' ? '👑' : member.role === 'admin' ? '⭐' : '👤';
+
+    return {
+      email,
+      organizationId: member.organizationId,
+      organizationName: member.organization.name,
+      role: member.role,
+      userId: member.userId,
+      displayText: `${email} ${chalk.gray(`→ ${member.organization.name}`)} ${roleBadge}`,
+    };
+  });
+
+  const searchFunction = async (_answers: unknown, input = '') => {
+    const fuzzyResult = fuzzy.filter(input, searchItems, {
+      extract: (item: EmailSearchItem) =>
+        `${item.email} ${item.organizationName}`,
+    });
+
+    return fuzzyResult.map((result: fuzzy.FilterResult<EmailSearchItem>) => ({
+      name: result.original.displayText,
+      value: result.original,
+    }));
+  };
+
+  const { selectedMember } = (await inquirer.prompt([
+    {
+      type: 'autocomplete',
+      name: 'selectedMember',
+      message: 'Search for a member by email:',
+      source: searchFunction,
+      pageSize: 15,
+    },
+  ])) as { selectedMember: EmailSearchItem };
+
+  // Fetch full organization details
+  const organization = await db.organization.findUnique({
+    where: {
+      id: selectedMember.organizationId,
+    },
+    include: {
+      projects: {
+        include: {
+          clients: true,
+        },
+        orderBy: {
+          name: 'asc',
+        },
+      },
+      members: {
+        include: {
+          user: true,
+        },
+      },
+    },
+  });
+
+  if (!organization) {
+    console.log(chalk.red('Organization not found.'));
+    return;
+  }
+
+  console.log(
+    chalk.yellow(
+      `\nShowing organization for: ${selectedMember.email} (${selectedMember.role})\n`,
+    ),
+  );
+
+  displayOrganizationDetails(organization);
+}
+

admin/src/commands/lookup-org.ts

@@ -0,0 +1,88 @@
+import { db } from '@openpanel/db';
+import chalk from 'chalk';
+import fuzzy from 'fuzzy';
+import inquirer from 'inquirer';
+import autocomplete from 'inquirer-autocomplete-prompt';
+import { displayOrganizationDetails } from '../utils/display';
+
+// Register autocomplete prompt
+inquirer.registerPrompt('autocomplete', autocomplete);
+
+interface OrgSearchItem {
+  id: string;
+  name: string;
+  displayText: string;
+}
+
+export async function lookupByOrg() {
+  console.log(chalk.blue('\n🏢 Lookup by Organization\n'));
+  console.log('Loading organizations...\n');
+
+  const organizations = await db.organization.findMany({
+    orderBy: {
+      name: 'asc',
+    },
+  });
+
+  if (organizations.length === 0) {
+    console.log(chalk.red('No organizations found.'));
+    return;
+  }
+
+  const searchItems: OrgSearchItem[] = organizations.map((org) => ({
+    id: org.id,
+    name: org.name,
+    displayText: `${org.name} ${chalk.gray(`(${org.id})`)}`,
+  }));
+
+  const searchFunction = async (_answers: unknown, input = '') => {
+    const fuzzyResult = fuzzy.filter(input, searchItems, {
+      extract: (item: OrgSearchItem) => `${item.name} ${item.id}`,
+    });
+
+    return fuzzyResult.map((result: fuzzy.FilterResult<OrgSearchItem>) => ({
+      name: result.original.displayText,
+      value: result.original,
+    }));
+  };
+
+  const { selectedOrg } = (await inquirer.prompt([
+    {
+      type: 'autocomplete',
+      name: 'selectedOrg',
+      message: 'Search for an organization:',
+      source: searchFunction,
+      pageSize: 15,
+    },
+  ])) as { selectedOrg: OrgSearchItem };
+
+  // Fetch full organization details
+  const organization = await db.organization.findUnique({
+    where: {
+      id: selectedOrg.id,
+    },
+    include: {
+      projects: {
+        include: {
+          clients: true,
+        },
+        orderBy: {
+          name: 'asc',
+        },
+      },
+      members: {
+        include: {
+          user: true,
+        },
+      },
+    },
+  });
+
+  if (!organization) {
+    console.log(chalk.red('Organization not found.'));
+    return;
+  }
+
+  displayOrganizationDetails(organization);
+}
+

admin/src/commands/lookup-project.ts

@@ -0,0 +1,98 @@
+import { db } from '@openpanel/db';
+import chalk from 'chalk';
+import fuzzy from 'fuzzy';
+import inquirer from 'inquirer';
+import autocomplete from 'inquirer-autocomplete-prompt';
+import { displayOrganizationDetails } from '../utils/display';
+
+// Register autocomplete prompt
+inquirer.registerPrompt('autocomplete', autocomplete);
+
+interface ProjectSearchItem {
+  id: string;
+  name: string;
+  organizationId: string;
+  organizationName: string;
+  displayText: string;
+}
+
+export async function lookupByProject() {
+  console.log(chalk.blue('\n📊 Lookup by Project\n'));
+  console.log('Loading projects...\n');
+
+  const projects = await db.project.findMany({
+    include: {
+      organization: true,
+    },
+    orderBy: {
+      name: 'asc',
+    },
+  });
+
+  if (projects.length === 0) {
+    console.log(chalk.red('No projects found.'));
+    return;
+  }
+
+  const searchItems: ProjectSearchItem[] = projects.map((project) => ({
+    id: project.id,
+    name: project.name,
+    organizationId: project.organizationId,
+    organizationName: project.organization.name,
+    displayText: `${project.organization.name} → ${project.name} ${chalk.gray(`(${project.id})`)}`,
+  }));
+
+  const searchFunction = async (_answers: unknown, input = '') => {
+    const fuzzyResult = fuzzy.filter(input, searchItems, {
+      extract: (item: ProjectSearchItem) =>
+        `${item.organizationName} ${item.name} ${item.id}`,
+    });
+
+    return fuzzyResult.map((result: fuzzy.FilterResult<ProjectSearchItem>) => ({
+      name: result.original.displayText,
+      value: result.original,
+    }));
+  };
+
+  const { selectedProject } = (await inquirer.prompt([
+    {
+      type: 'autocomplete',
+      name: 'selectedProject',
+      message: 'Search for a project:',
+      source: searchFunction,
+      pageSize: 15,
+    },
+  ])) as { selectedProject: ProjectSearchItem };
+
+  // Fetch full organization details
+  const organization = await db.organization.findUnique({
+    where: {
+      id: selectedProject.organizationId,
+    },
+    include: {
+      projects: {
+        include: {
+          clients: true,
+        },
+        orderBy: {
+          name: 'asc',
+        },
+      },
+      members: {
+        include: {
+          user: true,
+        },
+      },
+    },
+  });
+
+  if (!organization) {
+    console.log(chalk.red('Organization not found.'));
+    return;
+  }
+
+  displayOrganizationDetails(organization, {
+    highlightProjectId: selectedProject.id,
+  });
+}
+

admin/src/utils/display.ts

@@ -0,0 +1,206 @@
+import type {
+  Client,
+  Member,
+  Organization,
+  Project,
+  User,
+} from '@openpanel/db';
+import chalk from 'chalk';
+
+type OrganizationWithDetails = Organization & {
+  projects: (Project & {
+    clients: Client[];
+  })[];
+  members: (Member & {
+    user: User | null;
+  })[];
+};
+
+interface DisplayOptions {
+  highlightProjectId?: string;
+  highlightClientId?: string;
+}
+
+export function displayOrganizationDetails(
+  organization: OrganizationWithDetails,
+  options: DisplayOptions = {},
+) {
+  console.log(`\n${'='.repeat(80)}`);
+  console.log(chalk.bold.yellow(`\n📊 ORGANIZATION: ${organization.name}`));
+  console.log(`${'='.repeat(80)}\n`);
+
+  // Organization Details
+  console.log(chalk.bold('Organization Details:'));
+  console.log(`  ${chalk.gray('ID:')} ${organization.id}`);
+  console.log(`  ${chalk.gray('Name:')} ${organization.name}`);
+  console.log(
+    `  ${chalk.gray('Created:')} ${organization.createdAt.toISOString()}`,
+  );
+  console.log(`  ${chalk.gray('Timezone:')} ${organization.timezone || 'UTC'}`);
+
+  // Subscription info
+  if (organization.subscriptionStatus) {
+    console.log(
+      `  ${chalk.gray('Subscription Status:')} ${getSubscriptionStatusColor(organization.subscriptionStatus)}`,
+    );
+    if (organization.subscriptionPriceId) {
+      console.log(
+        `  ${chalk.gray('Price ID:')} ${organization.subscriptionPriceId}`,
+      );
+    }
+    if (organization.subscriptionPeriodEventsLimit) {
+      const usage = `${organization.subscriptionPeriodEventsCount}/${organization.subscriptionPeriodEventsLimit}`;
+      const percentage =
+        (organization.subscriptionPeriodEventsCount /
+          organization.subscriptionPeriodEventsLimit) *
+        100;
+      const color =
+        percentage > 90
+          ? chalk.red
+          : percentage > 70
+            ? chalk.yellow
+            : chalk.green;
+      console.log(
+        `  ${chalk.gray('Event Usage:')} ${color(usage)} (${percentage.toFixed(1)}%)`,
+      );
+    }
+    if (organization.subscriptionStartsAt) {
+      console.log(
+        `  ${chalk.gray('Starts:')} ${organization.subscriptionStartsAt.toISOString()}`,
+      );
+    }
+    if (organization.subscriptionEndsAt) {
+      console.log(
+        `  ${chalk.gray('Ends:')} ${organization.subscriptionEndsAt.toISOString()}`,
+      );
+    }
+  }
+
+  if (organization.deleteAt) {
+    console.log(
+      `  ${chalk.red.bold('⚠️  Scheduled for deletion:')} ${organization.deleteAt.toISOString()}`,
+    );
+  }
+
+  // Members
+  console.log(`\n${chalk.bold('Members:')}`);
+  if (organization.members.length === 0) {
+    console.log('  No members');
+  } else {
+    for (const member of organization.members) {
+      const roleBadge = getRoleBadge(member.role);
+      console.log(
+        `  ${roleBadge} ${member.user?.email || member.email || 'Unknown'} ${chalk.gray(`(${member.role})`)}`,
+      );
+    }
+  }
+
+  // Projects
+  console.log(`\n${chalk.bold(`Projects (${organization.projects.length}):`)}`);
+
+  if (organization.projects.length === 0) {
+    console.log('  No projects');
+  } else {
+    for (const project of organization.projects) {
+      const isHighlighted = project.id === options.highlightProjectId;
+      const projectPrefix = isHighlighted ? chalk.yellow.bold('→ ') : '  ';
+
+      console.log(`\n${projectPrefix}${chalk.bold.green(project.name)}`);
+      console.log(`    ${chalk.gray('ID:')} ${project.id}`);
+      console.log(
+        `    ${chalk.gray('Events Count:')} ${project.eventsCount.toLocaleString()}`,
+      );
+
+      if (project.domain) {
+        console.log(`    ${chalk.gray('Domain:')} ${project.domain}`);
+      }
+
+      if (project.cors.length > 0) {
+        console.log(`    ${chalk.gray('CORS:')} ${project.cors.join(', ')}`);
+      }
+
+      console.log(
+        `    ${chalk.gray('Cross Domain:')} ${project.crossDomain ? chalk.green('✓') : chalk.red('✗')}`,
+      );
+      console.log(
+        `    ${chalk.gray('Created:')} ${project.createdAt.toISOString()}`,
+      );
+
+      if (project.deleteAt) {
+        console.log(
+          `    ${chalk.red.bold('⚠️  Scheduled for deletion:')} ${project.deleteAt.toISOString()}`,
+        );
+      }
+
+      // Clients for this project
+      if (project.clients.length > 0) {
+        console.log(`    ${chalk.gray('Clients:')}`);
+        for (const client of project.clients) {
+          const isClientHighlighted = client.id === options.highlightClientId;
+          const clientPrefix = isClientHighlighted
+            ? chalk.yellow.bold('    → ')
+            : '      ';
+          const typeBadge = getClientTypeBadge(client.type);
+
+          console.log(`${clientPrefix}${typeBadge} ${chalk.cyan(client.name)}`);
+          console.log(`        ${chalk.gray('ID:')} ${client.id}`);
+          console.log(`        ${chalk.gray('Type:')} ${client.type}`);
+          console.log(
+            `        ${chalk.gray('Has Secret:')} ${client.secret ? chalk.green('✓') : chalk.red('✗')}`,
+          );
+          console.log(
+            `        ${chalk.gray('Ignore CORS/Secret:')} ${client.ignoreCorsAndSecret ? chalk.yellow('✓') : chalk.gray('✗')}`,
+          );
+        }
+      } else {
+        console.log(`    ${chalk.gray('Clients:')} None`);
+      }
+    }
+  }
+
+  // Clients without projects (organization-level clients)
+  const orgLevelClients = organization.projects.length > 0 ? [] : []; // We need to query these separately
+
+  console.log(`\n${'='.repeat(80)}\n`);
+}
+
+function getSubscriptionStatusColor(status: string): string {
+  switch (status) {
+    case 'active':
+      return chalk.green(status);
+    case 'trialing':
+      return chalk.blue(status);
+    case 'canceled':
+      return chalk.red(status);
+    case 'past_due':
+      return chalk.yellow(status);
+    default:
+      return chalk.gray(status);
+  }
+}
+
+function getRoleBadge(role: string): string {
+  switch (role) {
+    case 'owner':
+      return chalk.red.bold('👑');
+    case 'admin':
+      return chalk.yellow.bold('⭐');
+    case 'member':
+      return chalk.blue('👤');
+    default:
+      return chalk.gray('•');
+  }
+}
+
+function getClientTypeBadge(type: string): string {
+  switch (type) {
+    case 'root':
+      return chalk.red.bold('[ROOT]');
+    case 'write':
+      return chalk.green('[WRITE]');
+    case 'read':
+      return chalk.blue('[READ]');
+    default:
+      return chalk.gray('[UNKNOWN]');
+  }
+}

admin/tsconfig.json

@@ -0,0 +1,12 @@
+{
+  "extends": "../tooling/typescript/base.json",
+  "compilerOptions": {
+    "outDir": "dist",
+    "rootDir": "src",
+    "target": "ES2022",
+    "lib": ["ES2022"],
+    "types": ["node"]
+  },
+  "include": ["src"]
+}
+

apps/api/package.json

@@ -13,11 +13,11 @@
   "dependencies": {
     "@ai-sdk/anthropic": "^1.2.10",
     "@ai-sdk/openai": "^1.3.12",
-    "@fastify/compress": "^8.0.1",
+    "@fastify/compress": "^8.1.0",
     "@fastify/cookie": "^11.0.2",
-    "@fastify/cors": "^11.0.0",
-    "@fastify/rate-limit": "^10.2.2",
-    "@fastify/websocket": "^11.0.2",
+    "@fastify/cors": "^11.1.0",
+    "@fastify/rate-limit": "^10.3.0",
+    "@fastify/websocket": "^11.2.0",
     "@node-rs/argon2": "^2.0.2",
     "@openpanel/auth": "workspace:^",
     "@openpanel/common": "workspace:*",
@@ -35,13 +35,12 @@
     "@trpc/server": "^11.6.0",
     "ai": "^4.2.10",
     "fast-json-stable-hash": "^1.0.3",
-    "fastify": "^5.2.1",
+    "fastify": "^5.6.1",
     "fastify-metrics": "^12.1.0",
     "fastify-raw-body": "^5.0.0",
-    "groupmq": "1.0.0-next.19",
+    "groupmq": "1.1.0-next.6",
     "jsonwebtoken": "^9.0.2",
     "ramda": "^0.29.1",
-    "request-ip": "^3.3.0",
     "sharp": "^0.33.5",
     "source-map-support": "^0.5.21",
     "sqlstring": "^2.3.3",
@@ -58,7 +57,6 @@
     "@types/js-yaml": "^4.0.9",
     "@types/jsonwebtoken": "^9.0.9",
     "@types/ramda": "^0.30.2",
-    "@types/request-ip": "^0.0.41",
     "@types/source-map-support": "^0.5.10",
     "@types/sqlstring": "^2.3.2",
     "@types/uuid": "^10.0.0",

apps/api/scripts/get-bots.ts

@@ -7,6 +7,23 @@ const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 import yaml from 'js-yaml';
 
+// Regex special characters that indicate we need actual regex
+const regexSpecialChars = /[|^$.*+?(){}\[\]\\]/;
+
+function transformBots(bots: any[]): any[] {
+  return bots.map((bot) => {
+    const { regex, ...rest } = bot;
+    const hasRegexChars = regexSpecialChars.test(regex);
+
+    if (hasRegexChars) {
+      // Keep as regex
+      return { regex, ...rest };
+    }
+    // Convert to includes
+    return { includes: regex, ...rest };
+  });
+}
+
 async function main() {
   // Get document, or throw exception on error
   try {
@@ -14,6 +31,9 @@ async function main() {
       'https://raw.githubusercontent.com/matomo-org/device-detector/master/regexes/bots.yml',
     ).then((res) => res.text());
 
+    const parsedData = yaml.load(data) as any[];
+    const transformedBots = transformBots(parsedData);
+
     fs.writeFileSync(
       path.resolve(__dirname, '../src/bots/bots.ts'),
       [
@@ -21,11 +41,20 @@ async function main() {
         '',
         '// The data is fetch from device-detector https://raw.githubusercontent.com/matomo-org/device-detector/master/regexes/bots.yml',
         '',
-        `const bots = ${JSON.stringify(yaml.load(data))} as const;`,
+        `const bots = ${JSON.stringify(transformedBots, null, 2)} as const;`,
         'export default bots;',
+        '',
       ].join('\n'),
       'utf-8',
     );
+
+    console.log(
+      `✅ Generated bots.ts with ${transformedBots.length} bot entries`,
+    );
+    const regexCount = transformedBots.filter((b) => 'regex' in b).length;
+    const includesCount = transformedBots.filter((b) => 'includes' in b).length;
+    console.log(`   - ${includesCount} simple string matches (includes)`);
+    console.log(`   - ${regexCount} regex patterns`);
   } catch (e) {
     console.log(e);
   }

apps/api/scripts/test.ts

@@ -40,8 +40,6 @@ async function main() {
         properties: {
           hash: 'test-hash',
           'query.utm_source': 'test',
-          __reqId: `req_${Math.floor(Math.random() * 1000)}`,
-          __user_agent: 'Mozilla/5.0 (Test)',
         },
         created_at: formatClickhouseDate(eventTime),
         country: 'US',

apps/api/src/bots/index.ts

@@ -1,19 +1,47 @@
+import { cacheable, cacheableLru } from '@openpanel/redis';
 import bots from './bots';
 
-export function isBot(ua: string) {
-  const res = bots.find((bot) => {
-    if (new RegExp(bot.regex).test(ua)) {
-      return true;
-    }
-    return false;
-  });
-
-  if (!res) {
-    return null;
+// Pre-compile regex patterns at module load time
+const compiledBots = bots.map((bot) => {
+  if ('regex' in bot) {
+    return {
+      ...bot,
+      compiledRegex: new RegExp(bot.regex),
+    };
   }
+  return bot;
+});
 
-  return {
-    name: res.name,
-    type: 'category' in res ? res.category : 'Unknown',
-  };
-}
+const regexBots = compiledBots.filter((bot) => 'compiledRegex' in bot);
+const includesBots = compiledBots.filter((bot) => 'includes' in bot);
+
+export const isBot = cacheableLru(
+  'is-bot',
+  (ua: string) => {
+    // Check simple string patterns first (fast)
+    for (const bot of includesBots) {
+      if (ua.includes(bot.includes)) {
+        return {
+          name: bot.name,
+          type: 'category' in bot ? bot.category : 'Unknown',
+        };
+      }
+    }
+
+    // Check regex patterns (slower)
+    for (const bot of regexBots) {
+      if (bot.compiledRegex.test(ua)) {
+        return {
+          name: bot.name,
+          type: 'category' in bot ? bot.category : 'Unknown',
+        };
+      }
+    }
+
+    return null;
+  },
+  {
+    maxSize: 1000,
+    ttl: 60 * 5,
+  },
+);

apps/api/src/controllers/event.controller.ts

@@ -1,12 +1,10 @@
-import { getClientIp } from '@/utils/get-client-ip';
 import type { FastifyReply, FastifyRequest } from 'fastify';
 
 import { generateDeviceId, parseUserAgent } from '@openpanel/common/server';
 import { getSalts } from '@openpanel/db';
-import { eventsGroupQueue } from '@openpanel/queue';
+import { getEventsGroupQueueShard } from '@openpanel/queue';
 import type { PostEventPayload } from '@openpanel/sdk';
 
-import { checkDuplicatedEvent } from '@/utils/deduplicate';
 import { generateId } from '@openpanel/common';
 import { getGeoLocation } from '@openpanel/geo';
 import { getStringHeaders, getTimestamp } from './track.controller';
@@ -21,8 +19,8 @@ export async function postEvent(
     request.timestamp,
     request.body,
   );
-  const ip = getClientIp(request)!;
-  const ua = request.headers['user-agent']!;
+  const ip = request.clientIp;
+  const ua = request.headers['user-agent'];
   const projectId = request.client?.projectId;
   const headers = getStringHeaders(request.headers);
 
@@ -32,33 +30,22 @@ export async function postEvent(
   }
 
   const [salts, geo] = await Promise.all([getSalts(), getGeoLocation(ip)]);
-  const currentDeviceId = generateDeviceId({
-    salt: salts.current,
-    origin: projectId,
-    ip,
-    ua,
-  });
-  const previousDeviceId = generateDeviceId({
-    salt: salts.previous,
-    origin: projectId,
-    ip,
-    ua,
-  });
-
-  if (
-    await checkDuplicatedEvent({
-      reply,
-      payload: {
-        ...request.body,
-        timestamp,
-        previousDeviceId,
-        currentDeviceId,
-      },
-      projectId,
-    })
-  ) {
-    return;
-  }
+  const currentDeviceId = ua
+    ? generateDeviceId({
+        salt: salts.current,
+        origin: projectId,
+        ip,
+        ua,
+      })
+    : '';
+  const previousDeviceId = ua
+    ? generateDeviceId({
+        salt: salts.previous,
+        origin: projectId,
+        ip,
+        ua,
+      })
+    : '';
 
   const uaInfo = parseUserAgent(ua, request.body?.properties);
   const groupId = uaInfo.isServer
@@ -66,7 +53,16 @@ export async function postEvent(
       ? `${projectId}:${request.body?.profileId}`
       : `${projectId}:${generateId()}`
     : currentDeviceId;
-  await eventsGroupQueue.add({
+  const jobId = [
+    request.body.name,
+    timestamp,
+    projectId,
+    currentDeviceId,
+    groupId,
+  ]
+    .filter(Boolean)
+    .join('-');
+  await getEventsGroupQueueShard(groupId).add({
     orderMs: new Date(timestamp).getTime(),
     data: {
       projectId,
@@ -76,11 +72,13 @@ export async function postEvent(
         timestamp,
         isTimestampFromThePast,
       },
+      uaInfo,
       geo,
       currentDeviceId,
       previousDeviceId,
     },
     groupId,
+    jobId,
   });
 
   reply.status(202).send('ok');

apps/api/src/controllers/export.controller.ts

@@ -12,8 +12,8 @@ import {
   getEventsCountCached,
   getSettingsForProject,
 } from '@openpanel/db';
-import { getChart } from '@openpanel/trpc/src/routers/chart.helpers';
-import { zChartEvent, zChartInput } from '@openpanel/validation';
+import { ChartEngine } from '@openpanel/db';
+import { zChartEvent, zChartInputBase } from '@openpanel/validation';
 import { omit } from 'ramda';
 
 async function getProjectId(
@@ -139,7 +139,7 @@ export async function events(
   });
 }
 
-const chartSchemeFull = zChartInput
+const chartSchemeFull = zChartInputBase
   .pick({
     breakdowns: true,
     interval: true,
@@ -151,14 +151,27 @@ const chartSchemeFull = zChartInput
   .extend({
     project_id: z.string().optional(),
     projectId: z.string().optional(),
-    events: z.array(
-      z.object({
-        name: z.string(),
-        filters: zChartEvent.shape.filters.optional(),
-        segment: zChartEvent.shape.segment.optional(),
-        property: zChartEvent.shape.property.optional(),
-      }),
-    ),
+    series: z
+      .array(
+        z.object({
+          name: z.string(),
+          filters: zChartEvent.shape.filters.optional(),
+          segment: zChartEvent.shape.segment.optional(),
+          property: zChartEvent.shape.property.optional(),
+        }),
+      )
+      .optional(),
+    // Backward compatibility - events will be migrated to series via preprocessing
+    events: z
+      .array(
+        z.object({
+          name: z.string(),
+          filters: zChartEvent.shape.filters.optional(),
+          segment: zChartEvent.shape.segment.optional(),
+          property: zChartEvent.shape.property.optional(),
+        }),
+      )
+      .optional(),
   });
 
 export async function charts(
@@ -179,9 +192,17 @@ export async function charts(
 
   const projectId = await getProjectId(request, reply);
   const { timezone } = await getSettingsForProject(projectId);
-  const { events, ...rest } = query.data;
+  const { events, series, ...rest } = query.data;
 
-  return getChart({
+  // Use series if available, otherwise fall back to events (backward compat)
+  const eventSeries = (series ?? events ?? []).map((event: any) => ({
+    ...event,
+    type: event.type ?? 'event',
+    segment: event.segment ?? 'event',
+    filters: event.filters ?? [],
+  }));
+
+  return ChartEngine.execute({
     ...rest,
     startDate: rest.startDate
       ? DateTime.fromISO(rest.startDate)
@@ -194,11 +215,7 @@ export async function charts(
           .toFormat('yyyy-MM-dd HH:mm:ss')
       : undefined,
     projectId,
-    events: events.map((event) => ({
-      ...event,
-      segment: event.segment ?? 'event',
-      filters: event.filters ?? [],
-    })),
+    series: eventSeries,
     chartType: 'linear',
     metric: 'sum',
   });

apps/api/src/controllers/live.controller.ts

@@ -4,7 +4,7 @@ import superjson from 'superjson';
 import type { WebSocket } from '@fastify/websocket';
 import {
   eventBuffer,
-  getProfileByIdCached,
+  getProfileById,
   transformMinimalEvent,
 } from '@openpanel/db';
 import { setSuperJson } from '@openpanel/json';
@@ -92,10 +92,7 @@ export async function wsProjectEvents(
     type,
     async (event) => {
       if (event.projectId === params.projectId) {
-        const profile = await getProfileByIdCached(
-          event.profileId,
-          event.projectId,
-        );
+        const profile = await getProfileById(event.profileId, event.projectId);
         socket.send(
           superjson.stringify(
             access

apps/api/src/controllers/misc.controller.ts

@@ -4,9 +4,12 @@ import { parseUrlMeta } from '@/utils/parseUrlMeta';
 import type { FastifyReply, FastifyRequest } from 'fastify';
 import sharp from 'sharp';
 
-import { getClientIp } from '@/utils/get-client-ip';
+import {
+  DEFAULT_IP_HEADER_ORDER,
+  getClientIpFromHeaders,
+} from '@openpanel/common/server/get-client-ip';
 import { TABLE_NAMES, ch, chQuery, formatClickhouseDate } from '@openpanel/db';
-import { getGeoLocation } from '@openpanel/geo';
+import { type GeoLocation, getGeoLocation } from '@openpanel/geo';
 import { getCache, getRedisCache } from '@openpanel/redis';
 
 interface GetFaviconParams {
@@ -129,7 +132,7 @@ async function processImage(
 ): Promise<Buffer> {
   // If it's an ICO file, just return it as-is (no conversion needed)
   if (originalUrl && isIcoFile(originalUrl, contentType)) {
-    logger.info('Serving ICO file directly', {
+    logger.debug('Serving ICO file directly', {
       originalUrl,
       bufferSize: buffer.length,
     });
@@ -137,7 +140,7 @@ async function processImage(
   }
 
   if (originalUrl && isSvgFile(originalUrl, contentType)) {
-    logger.info('Serving SVG file directly', {
+    logger.debug('Serving SVG file directly', {
       originalUrl,
       bufferSize: buffer.length,
     });
@@ -146,7 +149,7 @@ async function processImage(
 
   // If buffer isnt to big just return it as well
   if (buffer.length < 5000) {
-    logger.info('Serving image directly without processing', {
+    logger.debug('Serving image directly without processing', {
       originalUrl,
       bufferSize: buffer.length,
     });
@@ -190,7 +193,7 @@ async function processOgImage(
 ): Promise<Buffer> {
   // If buffer is small enough, return it as-is
   if (buffer.length < 10000) {
-    logger.info('Serving OG image directly without processing', {
+    logger.debug('Serving OG image directly without processing', {
       originalUrl,
       bufferSize: buffer.length,
     });
@@ -394,12 +397,36 @@ export async function stats(request: FastifyRequest, reply: FastifyReply) {
 }
 
 export async function getGeo(request: FastifyRequest, reply: FastifyReply) {
-  const ip = getClientIp(request);
+  const { ip, header } = getClientIpFromHeaders(request.headers);
+  const others = await Promise.all(
+    DEFAULT_IP_HEADER_ORDER.map(async (header) => {
+      const { ip } = getClientIpFromHeaders(request.headers, header);
+      return {
+        header,
+        ip,
+        geo: await getGeoLocation(ip),
+      };
+    }),
+  );
+
   if (!ip) {
     return reply.status(400).send('Bad Request');
   }
   const geo = await getGeoLocation(ip);
-  return reply.status(200).send(geo);
+  return reply.status(200).send({
+    selected: {
+      geo,
+      ip,
+      header,
+    },
+    ...others.reduce(
+      (acc, other) => {
+        acc[other.header] = other;
+        return acc;
+      },
+      {} as Record<string, { ip: string; header: string; geo: GeoLocation }>,
+    ),
+  });
 }
 
 export async function getOgImage(

apps/api/src/controllers/profile.controller.ts

@@ -1,8 +1,6 @@
-import { getClientIp } from '@/utils/get-client-ip';
 import type { FastifyReply, FastifyRequest } from 'fastify';
 import { assocPath, pathOr } from 'ramda';
 
-import { checkDuplicatedEvent, isDuplicatedEvent } from '@/utils/deduplicate';
 import { parseUserAgent } from '@openpanel/common/server';
 import { getProfileById, upsertProfile } from '@openpanel/db';
 import { getGeoLocation } from '@openpanel/geo';
@@ -17,41 +15,39 @@ export async function updateProfile(
   }>,
   reply: FastifyReply,
 ) {
-  const { profileId, properties, ...rest } = request.body;
+  const payload = request.body;
   const projectId = request.client!.projectId;
   if (!projectId) {
     return reply.status(400).send('No projectId');
   }
-  const ip = getClientIp(request)!;
-  const ua = request.headers['user-agent']!;
-  const uaInfo = parseUserAgent(ua, properties);
+  const ip = request.clientIp;
+  const ua = request.headers['user-agent'];
+  const uaInfo = parseUserAgent(ua, payload.properties);
   const geo = await getGeoLocation(ip);
 
-  if (
-    await checkDuplicatedEvent({
-      reply,
-      payload: {
-        ...request.body,
-      },
-      projectId,
-    })
-  ) {
-    return;
-  }
-
   await upsertProfile({
-    id: profileId,
+    ...payload,
+    id: payload.profileId,
     isExternal: true,
     projectId,
     properties: {
-      ...(properties ?? {}),
-      ...(ip ? geo : {}),
-      ...uaInfo,
+      ...(payload.properties ?? {}),
+      country: geo.country,
+      city: geo.city,
+      region: geo.region,
+      longitude: geo.longitude,
+      latitude: geo.latitude,
+      os: uaInfo.os,
+      os_version: uaInfo.osVersion,
+      browser: uaInfo.browser,
+      browser_version: uaInfo.browserVersion,
+      device: uaInfo.device,
+      brand: uaInfo.brand,
+      model: uaInfo.model,
     },
-    ...rest,
   });
 
-  reply.status(202).send(profileId);
+  reply.status(202).send(payload.profileId);
 }
 
 export async function incrementProfileProperty(
@@ -66,18 +62,6 @@ export async function incrementProfileProperty(
     return reply.status(400).send('No projectId');
   }
 
-  if (
-    await checkDuplicatedEvent({
-      reply,
-      payload: {
-        ...request.body,
-      },
-      projectId,
-    })
-  ) {
-    return;
-  }
-
   const profile = await getProfileById(profileId, projectId);
   if (!profile) {
     return reply.status(404).send('Not found');
@@ -120,18 +104,6 @@ export async function decrementProfileProperty(
     return reply.status(400).send('No projectId');
   }
 
-  if (
-    await checkDuplicatedEvent({
-      reply,
-      payload: {
-        ...request.body,
-      },
-      projectId,
-    })
-  ) {
-    return;
-  }
-
   const profile = await getProfileById(profileId, projectId);
   if (!profile) {
     return reply.status(404).send('Not found');

apps/api/src/controllers/track.controller.ts

@@ -1,13 +1,12 @@
-import { getClientIp } from '@/utils/get-client-ip';
 import type { FastifyReply, FastifyRequest } from 'fastify';
-import { path, assocPath, pathOr, pick } from 'ramda';
+import { assocPath, pathOr, pick } from 'ramda';
 
-import { checkDuplicatedEvent } from '@/utils/deduplicate';
 import { generateId } from '@openpanel/common';
 import { generateDeviceId, parseUserAgent } from '@openpanel/common/server';
 import { getProfileById, getSalts, upsertProfile } from '@openpanel/db';
 import { type GeoLocation, getGeoLocation } from '@openpanel/geo';
-import { eventsGroupQueue } from '@openpanel/queue';
+import { getEventsGroupQueueShard } from '@openpanel/queue';
+import { getRedisCache } from '@openpanel/redis';
 import type {
   DecrementPayload,
   IdentifyPayload,
@@ -38,10 +37,10 @@ export function getStringHeaders(headers: FastifyRequest['headers']) {
 }
 
 function getIdentity(body: TrackHandlerPayload): IdentifyPayload | undefined {
-  const identity = path<IdentifyPayload>(
-    ['properties', '__identify'],
-    body.payload,
-  );
+  const identity =
+    'properties' in body.payload
+      ? (body.payload?.properties?.__identify as IdentifyPayload | undefined)
+      : undefined;
 
   return (
     identity ||
@@ -57,28 +56,38 @@ export function getTimestamp(
   timestamp: FastifyRequest['timestamp'],
   payload: TrackHandlerPayload['payload'],
 ) {
-  const safeTimestamp = new Date(timestamp || Date.now()).toISOString();
-  const userDefinedTimestamp = path<string>(
-    ['properties', '__timestamp'],
-    payload,
-  );
+  const safeTimestamp = timestamp || Date.now();
+  const userDefinedTimestamp =
+    'properties' in payload
+      ? (payload?.properties?.__timestamp as string | undefined)
+      : undefined;
 
   if (!userDefinedTimestamp) {
     return { timestamp: safeTimestamp, isTimestampFromThePast: false };
   }
 
   const clientTimestamp = new Date(userDefinedTimestamp);
+  const clientTimestampNumber = clientTimestamp.getTime();
 
+  // Constants for time validation
+  const ONE_MINUTE_MS = 60 * 1000;
+  const FIFTEEN_MINUTES_MS = 15 * ONE_MINUTE_MS;
+
+  // Use safeTimestamp if invalid or more than 1 minute in the future
   if (
-    Number.isNaN(clientTimestamp.getTime()) ||
-    clientTimestamp > new Date(safeTimestamp)
+    Number.isNaN(clientTimestampNumber) ||
+    clientTimestampNumber > safeTimestamp + ONE_MINUTE_MS
   ) {
     return { timestamp: safeTimestamp, isTimestampFromThePast: false };
   }
 
+  // isTimestampFromThePast is true only if timestamp is older than 1 hour
+  const isTimestampFromThePast =
+    clientTimestampNumber < safeTimestamp - FIFTEEN_MINUTES_MS;
+
   return {
-    timestamp: clientTimestamp.toISOString(),
-    isTimestampFromThePast: true,
+    timestamp: clientTimestampNumber,
+    isTimestampFromThePast,
   };
 }
 
@@ -90,22 +99,33 @@ export async function handler(
 ) {
   const timestamp = getTimestamp(request.timestamp, request.body.payload);
   const ip =
-    path<string>(['properties', '__ip'], request.body.payload) ||
-    getClientIp(request)!;
-  const ua = request.headers['user-agent']!;
+    'properties' in request.body.payload &&
+    request.body.payload.properties?.__ip
+      ? (request.body.payload.properties.__ip as string)
+      : request.clientIp;
+  const ua = request.headers['user-agent'];
   const projectId = request.client?.projectId;
 
   if (!projectId) {
-    reply.status(400).send({
+    return reply.status(400).send({
       status: 400,
       error: 'Bad Request',
       message: 'Missing projectId',
     });
-    return;
   }
 
   const identity = getIdentity(request.body);
   const profileId = identity?.profileId;
+  const overrideDeviceId = (() => {
+    const deviceId =
+      'properties' in request.body.payload
+        ? request.body.payload.properties?.__deviceId
+        : undefined;
+    if (typeof deviceId === 'string') {
+      return deviceId;
+    }
+    return undefined;
+  })();
 
   // We might get a profileId from the alias table
   // If we do, we should use that instead of the one from the payload
@@ -116,14 +136,16 @@ export async function handler(
   switch (request.body.type) {
     case 'track': {
       const [salts, geo] = await Promise.all([getSalts(), getGeoLocation(ip)]);
-      const currentDeviceId = ua
-        ? generateDeviceId({
-            salt: salts.current,
-            origin: projectId,
-            ip,
-            ua,
-          })
-        : '';
+      const currentDeviceId =
+        overrideDeviceId ||
+        (ua
+          ? generateDeviceId({
+              salt: salts.current,
+              origin: projectId,
+              ip,
+              ua,
+            })
+          : '');
       const previousDeviceId = ua
         ? generateDeviceId({
             salt: salts.previous,
@@ -133,33 +155,7 @@ export async function handler(
           })
         : '';
 
-      if (
-        await checkDuplicatedEvent({
-          reply,
-          payload: {
-            ...request.body,
-            timestamp,
-            previousDeviceId,
-            currentDeviceId,
-          },
-          projectId,
-        })
-      ) {
-        return;
-      }
-
-      const promises = [
-        track({
-          payload: request.body.payload,
-          currentDeviceId,
-          previousDeviceId,
-          projectId,
-          geo,
-          headers: getStringHeaders(request.headers),
-          timestamp: timestamp.timestamp,
-          isTimestampFromThePast: timestamp.isTimestampFromThePast,
-        }),
-      ];
+      const promises = [];
 
       // If we have more than one property in the identity object, we should identify the user
       // Otherwise its only a profileId and we should not identify the user
@@ -174,23 +170,23 @@ export async function handler(
         );
       }
 
+      promises.push(
+        track({
+          payload: request.body.payload,
+          currentDeviceId,
+          previousDeviceId,
+          projectId,
+          geo,
+          headers: getStringHeaders(request.headers),
+          timestamp: timestamp.timestamp,
+          isTimestampFromThePast: timestamp.isTimestampFromThePast,
+        }),
+      );
+
       await Promise.all(promises);
       break;
     }
     case 'identify': {
-      if (
-        await checkDuplicatedEvent({
-          reply,
-          payload: {
-            ...request.body,
-            timestamp,
-          },
-          projectId,
-        })
-      ) {
-        return;
-      }
-
       const geo = await getGeoLocation(ip);
       await identify({
         payload: request.body.payload,
@@ -201,27 +197,13 @@ export async function handler(
       break;
     }
     case 'alias': {
-      reply.status(400).send({
+      return reply.status(400).send({
         status: 400,
         error: 'Bad Request',
         message: 'Alias is not supported',
       });
-      break;
     }
     case 'increment': {
-      if (
-        await checkDuplicatedEvent({
-          reply,
-          payload: {
-            ...request.body,
-            timestamp,
-          },
-          projectId,
-        })
-      ) {
-        return;
-      }
-
       await increment({
         payload: request.body.payload,
         projectId,
@@ -229,19 +211,6 @@ export async function handler(
       break;
     }
     case 'decrement': {
-      if (
-        await checkDuplicatedEvent({
-          reply,
-          payload: {
-            ...request.body,
-            timestamp,
-          },
-          projectId,
-        })
-      ) {
-        return;
-      }
-
       await decrement({
         payload: request.body.payload,
         projectId,
@@ -249,12 +218,11 @@ export async function handler(
       break;
     }
     default: {
-      reply.status(400).send({
+      return reply.status(400).send({
         status: 400,
         error: 'Bad Request',
         message: 'Invalid type',
       });
-      break;
     }
   }
 
@@ -277,7 +245,7 @@ async function track({
   projectId: string;
   geo: GeoLocation;
   headers: Record<string, string | undefined>;
-  timestamp: string;
+  timestamp: number;
   isTimestampFromThePast: boolean;
 }) {
   const uaInfo = parseUserAgent(headers['user-agent'], payload.properties);
@@ -286,8 +254,11 @@ async function track({
       ? `${projectId}:${payload.profileId}`
       : `${projectId}:${generateId()}`
     : currentDeviceId;
-  await eventsGroupQueue.add({
-    orderMs: new Date(timestamp).getTime(),
+  const jobId = [payload.name, timestamp, projectId, currentDeviceId, groupId]
+    .filter(Boolean)
+    .join('-');
+  await getEventsGroupQueueShard(groupId).add({
+    orderMs: timestamp,
     data: {
       projectId,
       headers,
@@ -296,11 +267,13 @@ async function track({
         timestamp,
         isTimestampFromThePast,
       },
+      uaInfo,
       geo,
       currentDeviceId,
       previousDeviceId,
     },
     groupId,
+    jobId,
   });
 }
 
@@ -323,8 +296,18 @@ async function identify({
     projectId,
     properties: {
       ...(payload.properties ?? {}),
-      ...(geo ?? {}),
-      ...uaInfo,
+      country: geo.country,
+      city: geo.city,
+      region: geo.region,
+      longitude: geo.longitude,
+      latitude: geo.latitude,
+      os: uaInfo.os,
+      os_version: uaInfo.osVersion,
+      browser: uaInfo.browser,
+      browser_version: uaInfo.browserVersion,
+      device: uaInfo.device,
+      brand: uaInfo.brand,
+      model: uaInfo.model,
     },
   });
 }
@@ -400,3 +383,65 @@ async function decrement({
     isExternal: true,
   });
 }
+
+export async function fetchDeviceId(
+  request: FastifyRequest,
+  reply: FastifyReply,
+) {
+  const salts = await getSalts();
+  const projectId = request.client?.projectId;
+  if (!projectId) {
+    return reply.status(400).send('No projectId');
+  }
+
+  const ip = request.clientIp;
+  if (!ip) {
+    return reply.status(400).send('Missing ip address');
+  }
+
+  const ua = request.headers['user-agent'];
+  if (!ua) {
+    return reply.status(400).send('Missing header: user-agent');
+  }
+
+  const currentDeviceId = generateDeviceId({
+    salt: salts.current,
+    origin: projectId,
+    ip,
+    ua,
+  });
+  const previousDeviceId = generateDeviceId({
+    salt: salts.previous,
+    origin: projectId,
+    ip,
+    ua,
+  });
+
+  try {
+    const multi = getRedisCache().multi();
+    multi.exists(`bull:sessions:sessionEnd:${projectId}:${currentDeviceId}`);
+    multi.exists(`bull:sessions:sessionEnd:${projectId}:${previousDeviceId}`);
+    const res = await multi.exec();
+
+    if (res?.[0]?.[1]) {
+      return reply.status(200).send({
+        deviceId: currentDeviceId,
+        message: 'current session exists for this device id',
+      });
+    }
+
+    if (res?.[1]?.[1]) {
+      return reply.status(200).send({
+        deviceId: previousDeviceId,
+        message: 'previous session exists for this device id',
+      });
+    }
+  } catch (error) {
+    request.log.error('Error getting session end GET /track/device-id', error);
+  }
+
+  return reply.status(200).send({
+    deviceId: currentDeviceId,
+    message: 'No session exists for this device id',
+  });
+}

apps/api/src/hooks/duplicate.hook.ts

@@ -0,0 +1,28 @@
+import { isDuplicatedEvent } from '@/utils/deduplicate';
+import type { PostEventPayload, TrackHandlerPayload } from '@openpanel/sdk';
+import type { FastifyReply, FastifyRequest } from 'fastify';
+
+export async function duplicateHook(
+  req: FastifyRequest<{
+    Body: PostEventPayload | TrackHandlerPayload;
+  }>,
+  reply: FastifyReply,
+) {
+  const ip = req.clientIp;
+  const origin = req.headers.origin;
+  const clientId = req.headers['openpanel-client-id'];
+  const shouldCheck = ip && origin && clientId;
+
+  const isDuplicate = shouldCheck
+    ? await isDuplicatedEvent({
+        ip,
+        origin,
+        payload: req.body,
+        projectId: clientId as string,
+      })
+    : false;
+
+  if (isDuplicate) {
+    return reply.status(200).send('Duplicate event');
+  }
+}

apps/api/src/hooks/fix.hook.ts

@@ -1,16 +0,0 @@
-import type { FastifyRequest } from 'fastify';
-
-export async function fixHook(request: FastifyRequest) {
-  const ua = request.headers['user-agent'];
-  // Swift SDK issue: https://github.com/Openpanel-dev/swift-sdk/commit/d588fa761a36a33f3b78eb79d83bfd524e3c7144
-  if (ua) {
-    const regex = /OpenPanel\/(\d+\.\d+\.\d+)\sOpenPanel\/(\d+\.\d+\.\d+)/;
-    const match = ua.match(regex);
-    if (match) {
-      request.headers['user-agent'] = ua.replace(
-        regex,
-        `OpenPanel/${match[1]}`,
-      );
-    }
-  }
-}

apps/api/src/hooks/ip.hook.ts

@@ -1,13 +1,14 @@
-import { getClientIp } from '@/utils/get-client-ip';
-import type {
-  FastifyReply,
-  FastifyRequest,
-  HookHandlerDoneFunction,
-} from 'fastify';
+import { getClientIpFromHeaders } from '@openpanel/common/server/get-client-ip';
+import type { FastifyRequest } from 'fastify';
 
 export async function ipHook(request: FastifyRequest) {
-  const ip = getClientIp(request);
+  const { ip, header } = getClientIpFromHeaders(request.headers);
+
   if (ip) {
     request.clientIp = ip;
+    request.clientIpHeader = header;
+  } else {
+    request.clientIp = '';
+    request.clientIpHeader = '';
   }
 }

apps/api/src/hooks/request-logging.hook.ts

@@ -1,3 +1,4 @@
+import { DEFAULT_IP_HEADER_ORDER } from '@openpanel/common';
 import type { FastifyReply, FastifyRequest } from 'fastify';
 import { path, pick } from 'ramda';
 
@@ -37,12 +38,15 @@ export async function requestLoggingHook(
       url: request.url,
       method: request.method,
       elapsed: reply.elapsedTime,
+      clientIp: request.clientIp,
+      clientIpHeader: request.clientIpHeader,
       headers: pick(
         [
           'openpanel-client-id',
           'openpanel-sdk-name',
           'openpanel-sdk-version',
           'user-agent',
+          ...DEFAULT_IP_HEADER_ORDER,
         ],
         request.headers,
       ),

apps/api/src/index.ts

@@ -28,7 +28,6 @@ import {
   liveness,
   readiness,
 } from './controllers/healthcheck.controller';
-import { fixHook } from './hooks/fix.hook';
 import { ipHook } from './hooks/ip.hook';
 import { requestIdHook } from './hooks/request-id.hook';
 import { requestLoggingHook } from './hooks/request-logging.hook';
@@ -55,7 +54,8 @@ process.env.TZ = 'UTC';
 declare module 'fastify' {
   interface FastifyRequest {
     client: IServiceClientWithProject | null;
-    clientIp?: string;
+    clientIp: string;
+    clientIpHeader: string;
     timestamp?: number;
     session: SessionValidationResult;
   }
@@ -125,7 +125,6 @@ const startServer = async () => {
     fastify.addHook('onRequest', requestIdHook);
     fastify.addHook('onRequest', timestampHook);
     fastify.addHook('onRequest', ipHook);
-    fastify.addHook('onRequest', fixHook);
     fastify.addHook('onResponse', requestLoggingHook);
 
     fastify.register(compress, {

apps/api/src/routes/event.router.ts

@@ -2,9 +2,11 @@ import * as controller from '@/controllers/event.controller';
 import type { FastifyPluginCallback } from 'fastify';
 
 import { clientHook } from '@/hooks/client.hook';
+import { duplicateHook } from '@/hooks/duplicate.hook';
 import { isBotHook } from '@/hooks/is-bot.hook';
 
 const eventRouter: FastifyPluginCallback = async (fastify) => {
+  fastify.addHook('preValidation', duplicateHook);
   fastify.addHook('preHandler', clientHook);
   fastify.addHook('preHandler', isBotHook);
 

apps/api/src/routes/track.router.ts

@@ -1,10 +1,12 @@
-import { handler } from '@/controllers/track.controller';
+import { fetchDeviceId, handler } from '@/controllers/track.controller';
 import type { FastifyPluginCallback } from 'fastify';
 
 import { clientHook } from '@/hooks/client.hook';
+import { duplicateHook } from '@/hooks/duplicate.hook';
 import { isBotHook } from '@/hooks/is-bot.hook';
 
 const trackRouter: FastifyPluginCallback = async (fastify) => {
+  fastify.addHook('preValidation', duplicateHook);
   fastify.addHook('preHandler', clientHook);
   fastify.addHook('preHandler', isBotHook);
 
@@ -29,6 +31,23 @@ const trackRouter: FastifyPluginCallback = async (fastify) => {
       },
     },
   });
+
+  fastify.route({
+    method: 'GET',
+    url: '/device-id',
+    handler: fetchDeviceId,
+    schema: {
+      response: {
+        200: {
+          type: 'object',
+          properties: {
+            deviceId: { type: 'string' },
+            message: { type: 'string', optional: true },
+          },
+        },
+      },
+    },
+  });
 };
 
 export default trackRouter;

apps/api/src/utils/ai-tools.ts

@@ -7,8 +7,8 @@ import {
   ch,
   clix,
 } from '@openpanel/db';
+import { ChartEngine } from '@openpanel/db';
 import { getCache } from '@openpanel/redis';
-import { getChart } from '@openpanel/trpc/src/routers/chart.helpers';
 import { zChartInputAI } from '@openpanel/validation';
 import { tool } from 'ai';
 import { z } from 'zod';

apps/api/src/utils/auth.ts

@@ -3,6 +3,7 @@ import type { FastifyRequest, RawRequestDefaultExpression } from 'fastify';
 import { verifyPassword } from '@openpanel/common/server';
 import type { IServiceClientWithProject } from '@openpanel/db';
 import { ClientType, getClientByIdCached } from '@openpanel/db';
+import { getCache } from '@openpanel/redis';
 import type { PostEventPayload, TrackHandlerPayload } from '@openpanel/sdk';
 import type {
   IProjectFilterIp,
@@ -104,6 +105,22 @@ export async function validateSdkRequest(
     throw createError('Ingestion: Profile id is blocked by project filter');
   }
 
+  const revenue =
+    path(['payload', 'properties', '__revenue'], req.body) ??
+    path(['properties', '__revenue'], req.body);
+
+  // Only allow revenue tracking if it was sent with a client secret
+  // or if the project has allowUnsafeRevenueTracking enabled
+  if (
+    !client.project.allowUnsafeRevenueTracking &&
+    !clientSecret &&
+    typeof revenue !== 'undefined'
+  ) {
+    throw createError(
+      'Ingestion: Revenue tracking is not allowed without a client secret',
+    );
+  }
+
   if (client.ignoreCorsAndSecret) {
     return client;
   }
@@ -135,7 +152,13 @@ export async function validateSdkRequest(
   }
 
   if (client.secret && clientSecret) {
-    if (await verifyPassword(clientSecret, client.secret)) {
+    const isVerified = await getCache(
+      `client:auth:${clientId}:${Buffer.from(clientSecret).toString('base64')}`,
+      60 * 5,
+      async () => await verifyPassword(clientSecret, client.secret!),
+      true,
+    );
+    if (isVerified) {
       return client;
     }
   }

apps/api/src/utils/deduplicate.ts

@@ -1,11 +1,14 @@
 import { getLock } from '@openpanel/redis';
 import fastJsonStableHash from 'fast-json-stable-hash';
-import type { FastifyReply } from 'fastify';
 
 export async function isDuplicatedEvent({
+  ip,
+  origin,
   payload,
   projectId,
 }: {
+  ip: string;
+  origin: string;
   payload: Record<string, any>;
   projectId: string;
 }) {
@@ -13,6 +16,8 @@ export async function isDuplicatedEvent({
     `fastify:deduplicate:${fastJsonStableHash.hash(
       {
         ...payload,
+        ip,
+        origin,
         projectId,
       },
       'md5',
@@ -27,24 +32,3 @@ export async function isDuplicatedEvent({
 
   return true;
 }
-
-export async function checkDuplicatedEvent({
-  reply,
-  payload,
-  projectId,
-}: {
-  reply: FastifyReply;
-  payload: Record<string, any>;
-  projectId: string;
-}) {
-  if (await isDuplicatedEvent({ payload, projectId })) {
-    reply.log.info('duplicated event', {
-      payload,
-      projectId,
-    });
-    reply.status(200).send('duplicated');
-    return true;
-  }
-
-  return false;
-}

apps/api/src/utils/get-client-ip.ts

@@ -1,8 +0,0 @@
-import type { FastifyRequest } from 'fastify';
-import requestIp from 'request-ip';
-
-const ignore = ['127.0.0.1', '::1'];
-
-export function getClientIp(req: FastifyRequest) {
-  return requestIp.getClientIp(req);
-}

apps/api/src/utils/graceful-shutdown.ts

@@ -1,7 +1,7 @@
 import { ch, db } from '@openpanel/db';
 import {
   cronQueue,
-  eventsGroupQueue,
+  eventsGroupQueues,
   miscQueue,
   notificationQueue,
   sessionsQueue,
@@ -71,7 +71,7 @@ export async function shutdown(
   // Step 6: Close Bull queues (graceful shutdown of queue state)
   try {
     await Promise.all([
-      eventsGroupQueue.close(),
+      ...eventsGroupQueues.map((queue) => queue.close()),
       sessionsQueue.close(),
       cronQueue.close(),
       miscQueue.close(),

apps/public/app/api/[...op]/route.ts

@@ -0,0 +1,7 @@
+import {
+  createNextRouteHandler,
+  createScriptHandler,
+} from '@openpanel/nextjs/server';
+
+export const POST = createNextRouteHandler();
+export const GET = createScriptHandler();

apps/public/app/api/headers/route.ts

@@ -0,0 +1,29 @@
+import { NextResponse } from 'next/server';
+
+const IP_HEADER_ORDER = [
+  'cf-connecting-ip',
+  'true-client-ip',
+  'x-vercel-forwarded-for', // Vercel-specific, most reliable on Vercel
+  'x-forwarded-for', // Standard proxy header (first IP in chain)
+  'x-real-ip', // Alternative header
+  'x-client-ip',
+  'fastly-client-ip',
+  'do-connecting-ip',
+  'x-cluster-client-ip',
+];
+
+export const GET = function POST(req: Request) {
+  return NextResponse.json({
+    headers: Object.fromEntries(req.headers),
+    ips: IP_HEADER_ORDER.reduce(
+      (acc, header) => {
+        const value = req.headers.get(header);
+        if (value) {
+          acc[header] = value;
+        }
+        return acc;
+      },
+      {} as Record<string, string>,
+    ),
+  });
+};

apps/public/app/layout.tsx

@@ -61,12 +61,9 @@ export default async function Layout({ children }: { children: ReactNode }) {
         <RootProvider>
           <TooltipProvider>{children}</TooltipProvider>
         </RootProvider>
-        <Script
-          defer
-          src="http://localhost:3000/script.js"
-          data-website-id="44d65df1-e9cb-4c2c-917d-4bf1c7850948"
-        />
         <OpenPanelComponent
+          apiUrl="/api/op"
+          cdnUrl="/api/op/op1.js"
           clientId="301c6dc1-424c-4bc3-9886-a8beab09b615"
           trackAttributes
           trackScreenViews

apps/public/components/flow-step.tsx

@@ -0,0 +1,79 @@
+import { CheckCircle, CreditCard, Globe, Server, User } from 'lucide-react';
+import type { ReactNode } from 'react';
+
+interface FlowStepProps {
+  step: number;
+  actor: string;
+  description: string;
+  children?: ReactNode;
+  icon?: 'visitor' | 'website' | 'backend' | 'payment' | 'success';
+  isLast?: boolean;
+}
+
+const iconMap = {
+  visitor: User,
+  website: Globe,
+  backend: Server,
+  payment: CreditCard,
+  success: CheckCircle,
+};
+
+const iconColorMap = {
+  visitor: 'text-blue-500',
+  website: 'text-green-500',
+  backend: 'text-purple-500',
+  payment: 'text-yellow-500',
+  success: 'text-green-600',
+};
+
+const iconBorderColorMap = {
+  visitor: 'border-blue-500',
+  website: 'border-green-500',
+  backend: 'border-purple-500',
+  payment: 'border-yellow-500',
+  success: 'border-green-600',
+};
+
+export function FlowStep({
+  step,
+  actor,
+  description,
+  children,
+  icon = 'visitor',
+  isLast = false,
+}: FlowStepProps) {
+  const Icon = iconMap[icon];
+
+  return (
+    <div className="relative flex gap-4 mb-4 min-w-0">
+      {/* Step number and icon */}
+      <div className="flex flex-col items-center flex-shrink-0">
+        <div className="relative z-10 bg-background">
+          <div className="flex items-center justify-center size-10 rounded-full bg-primary text-primary-foreground font-semibold text-sm shadow-sm">
+            {step}
+          </div>
+          <div
+            className={`absolute -bottom-2 -right-2 flex items-center justify-center w-6 h-6 rounded-full bg-background border shadow-sm ${iconBorderColorMap[icon] || 'border-primary'}`}
+          >
+            <Icon
+              className={`size-3.5 ${iconColorMap[icon] || 'text-primary'}`}
+            />
+          </div>
+        </div>
+        {/* Connector line - extends from badge through content to next step */}
+        {!isLast && (
+          <div className="w-0.5 bg-border mt-2 flex-1 min-h-[2rem]" />
+        )}
+      </div>
+
+      {/* Content */}
+      <div className="flex-1 pt-1 min-w-0">
+        <div className="mb-2">
+          <span className="font-semibold text-foreground mr-2">{actor}:</span>{' '}
+          <span className="text-muted-foreground">{description}</span>
+        </div>
+        {children && <div className="mt-3 min-w-0">{children}</div>}
+      </div>
+    </div>
+  );
+}

apps/public/components/sections/faq.tsx

@@ -13,7 +13,7 @@ const questions = [
   {
     question: 'Does OpenPanel have a free tier?',
     answer: [
-      'For our Cloud plan we offer a 14 days free trial, this is mostly for you to be able to try out OpenPanel before committing to a paid plan.',
+      'For our Cloud plan we offer a 30 days free trial, this is mostly for you to be able to try out OpenPanel before committing to a paid plan.',
       'OpenPanel is also open-source and you can self-host it for free!',
       '',
       'Why does OpenPanel not have a free tier?',

apps/public/content/articles/cookieless-analytics.mdx

@@ -88,9 +88,7 @@ We built OpenPanel from the ground up with privacy at its heart—and with featu
 
 ```html
 <script>
-  window.op = window.op || function(...args) {
-    (window.op.q = window.op.q || []).push(args);
-  };
+  window.op=window.op||function(){var n=[],o=new Proxy((function(){arguments.length>0&&n.push(Array.prototype.slice.call(arguments))}),{get:function(o,t){return"q"===t?n:function(){n.push([t].concat(Array.prototype.slice.call(arguments)))}}});return o}();
   window.op('init', {
     clientId: 'YOUR_CLIENT_ID',
     trackScreenViews: true,

apps/public/content/docs/(tracking)/adblockers.mdx

@@ -0,0 +1,104 @@
+---
+title: Avoid adblockers with proxy
+description: Learn why adblockers block analytics and how to avoid it by proxying events.
+---
+
+In this article we need to talk about adblockers, why they exist, how they work, and how to avoid them.
+
+Adblockers' main purpose was initially to block ads, but they have since started to block tracking scripts as well. This is primarily for privacy reasons, and while we respect that, there are legitimate use cases for understanding your visitors. OpenPanel is designed to be a privacy-friendly, cookieless analytics tool that doesn't track users across sites, but generic blocklists often catch all analytics tools indiscriminately.
+
+The best way to avoid adblockers is to proxy events via your own domain name. Adblockers generally cannot block requests to your own domain (first-party requests) without breaking the functionality of the site itself.
+
+## Built-in Support
+
+Today, our Next.js SDK and WordPress plugin have built-in support for proxying:
+- **WordPress**: Does it automatically.
+- **Next.js**: Easy to setup with a route handler.
+
+## Implementing Proxying for Any Framework
+
+If you are not using Next.js or WordPress, you can implement proxying in any backend framework. The key is to set up an API endpoint on your domain (e.g., `api.domain.com` or `domain.com/api`) that forwards requests to OpenPanel.
+
+Below is an example of how to set up a proxy using a [Hono](https://hono.dev/) server. This implementation mimics the logic used in our Next.js SDK.
+
+> You can always see how our Next.js implementation looks like in our [repository](https://github.com/Openpanel-dev/openpanel/blob/main/packages/sdks/nextjs/createNextRouteHandler.ts).
+
+### Hono Example
+
+```typescript
+import { Hono } from 'hono'
+
+const app = new Hono()
+
+// 1. Proxy the script file
+app.get('/op1.js', async (c) => {
+  const scriptUrl = 'https://openpanel.dev/op1.js'
+  try {
+    const res = await fetch(scriptUrl)
+    const text = await res.text()
+    
+    c.header('Content-Type', 'text/javascript')
+    // Optional caching for 24 hours
+    c.header('Cache-Control', 'public, max-age=86400, stale-while-revalidate=86400')
+    return c.body(text)
+  } catch (e) {
+     return c.json({ error: 'Failed to fetch script' }, 500)
+  }
+})
+
+// 2. Proxy the track event
+app.post('/track', async (c) => {
+  const body = await c.req.json()
+  
+  // Forward the client's IP address (be sure to pick correct IP based on your infra)
+  const ip = c.req.header('cf-connecting-ip') ?? 
+             c.req.header('x-forwarded-for')?.split(',')[0]
+
+  const headers = new Headers()
+  headers.set('Content-Type', 'application/json')
+  headers.set('Origin', c.req.header('origin') ?? '')
+  headers.set('User-Agent', c.req.header('user-agent') ?? '')
+  headers.set('openpanel-client-id', c.req.header('openpanel-client-id') ?? '')
+  
+  if (ip) {
+    headers.set('openpanel-client-ip', ip)
+  }
+
+  try {
+    const res = await fetch('https://api.openpanel.dev/track', {
+      method: 'POST',
+      headers,
+      body: JSON.stringify(body),
+    })
+    return c.json(await res.text(), res.status)
+  } catch (e) {
+    return c.json(e, 500)
+  }
+})
+
+export default app
+```
+
+This script sets up two endpoints:
+1. `GET /op1.js`: Fetches the OpenPanel script and serves it from your domain.
+2. `POST /track`: Receives events from the frontend, adds necessary headers (User-Agent, Origin, Content-Type, openpanel-client-id, openpanel-client-ip), and forwards them to OpenPanel's API.
+
+## Frontend Configuration
+
+Once your proxy is running, you need to configure the OpenPanel script on your frontend to use your proxy endpoints instead of the default ones.
+
+```html
+<script>
+  window.op=window.op||function(){var n=[],o=new Proxy((function(){arguments.length>0&&n.push(Array.prototype.slice.call(arguments))}),{get:function(o,t){return"q"===t?n:function(){n.push([t].concat(Array.prototype.slice.call(arguments)))}}});return o}();
+  window.op('init', {
+    apiUrl: 'https://api.domain.com'
+    clientId: 'YOUR_CLIENT_ID',
+    trackScreenViews: true,
+    trackOutgoingLinks: true,
+    trackAttributes: true,
+  });
+</script>
+<script src="https://api.domain.com/op1.js" defer async></script>
+```
+
+By doing this, all requests are sent to your domain first, bypassing adblockers that look for third-party tracking domains.

apps/public/content/docs/(tracking)/how-it-works.mdx

@@ -0,0 +1,190 @@
+---
+title: How it works
+description: Understanding device IDs, session IDs, profile IDs, and event tracking
+---
+
+## Device ID
+
+A **device ID** is a unique identifier generated for each device/browser combination. It's calculated using a hash function that combines:
+
+- **User Agent** (browser/client information)
+- **IP Address**
+- **Origin** (project ID)
+- **Salt** (a rotating secret key)
+
+```typescript:packages/common/server/profileId.ts
+export function generateDeviceId({
+  salt,
+  ua,
+  ip,
+  origin,
+}: GenerateDeviceIdOptions) {
+  return createHash(`${ua}:${ip}:${origin}:${salt}`, 16);
+}
+```
+
+### Salt Rotation
+
+The salt used for device ID generation rotates **daily at midnight** (UTC). This means:
+
+- Device IDs remain consistent throughout a single day
+- Device IDs reset each day for privacy purposes
+- The system maintains both the current and previous day's salt to handle events that may arrive slightly after midnight
+
+```typescript:apps/worker/src/jobs/cron.salt.ts
+// Salt rotation happens daily at midnight (pattern: '0 0 * * *')
+```
+
+When the salt rotates, all device IDs change, effectively anonymizing tracking data on a daily basis while still allowing session continuity within a 24-hour period.
+
+## Session ID
+
+A **session** represents a continuous period of user activity. Sessions are used to group related events together and understand user behavior patterns.
+
+### Session Duration
+
+Sessions have a **30-minute timeout**. If no events are received for 30 minutes, the session automatically ends. Each new event resets this 30-minute timer.
+
+```typescript:apps/worker/src/utils/session-handler.ts
+export const SESSION_TIMEOUT = 1000 * 60 * 30; // 30 minutes
+```
+
+### Session Creation Rules
+
+Sessions are **only created for client events**, not server events. This means:
+
+- Events sent from browsers, mobile apps, or client-side SDKs will create sessions
+- Events sent from backend servers, scripts, or server-side SDKs will **not** create sessions
+- If you only track events from your backend, no sessions will be created
+
+Additionally, sessions are **not created for events older than 15 minutes**. This prevents historical data imports from creating artificial sessions.
+
+```typescript:apps/worker/src/jobs/events.incoming-event.ts
+// Sessions are not created if:
+// 1. The event is from a server (uaInfo.isServer === true)
+// 2. The timestamp is from the past (isTimestampFromThePast === true)
+if (uaInfo.isServer || isTimestampFromThePast) {
+  // Event is attached to existing session or no session
+}
+```
+
+## Profile ID
+
+A **profile ID** is a persistent identifier for a user across multiple devices and sessions. It allows you to track the same user across different browsers, devices, and time periods.
+
+### Profile ID Assignment
+
+If a `profileId` is provided when tracking an event, it will be used to identify the user. However, **if no `profileId` is provided, it defaults to the `deviceId`**.
+
+This means:
+- Anonymous users (without a profile ID) are tracked by their device ID
+- Once you identify a user (by providing a profile ID), all their events will be associated with that profile
+- The same user can be tracked across multiple devices by using the same profile ID
+
+```typescript:packages/db/src/services/event.service.ts
+// If no profileId is provided, it defaults to deviceId
+if (!payload.profileId && payload.deviceId) {
+  payload.profileId = payload.deviceId;
+}
+```
+
+## Client Events vs Server Events
+
+OpenPanel distinguishes between **client events** and **server events** based on the User-Agent header.
+
+### Client Events
+
+Client events are sent from:
+- Web browsers (Chrome, Firefox, Safari, etc.)
+- Mobile apps using client-side SDKs
+- Any client that sends a browser-like User-Agent
+
+Client events:
+- Create sessions
+- Generate device IDs
+- Support full session tracking
+
+### Server Events
+
+Server events are detected when the User-Agent matches server patterns, such as:
+- `Go-http-client/1.0`
+- `node-fetch/1.0`
+- Other single-name/version patterns (e.g., `LibraryName/1.0`)
+
+Server events:
+- Do **not** create sessions
+- Are attached to existing sessions if available
+- Are useful for backend tracking without session management
+
+```typescript:packages/common/server/parser-user-agent.ts
+// Server events are detected by patterns like "Go-http-client/1.0"
+function isServer(res: UAParser.IResult) {
+  if (SINGLE_NAME_VERSION_REGEX.test(res.ua)) {
+    return true;
+  }
+  // ... additional checks
+}
+```
+
+The distinction is made in the event processing pipeline:
+
+```typescript:apps/worker/src/jobs/events.incoming-event.ts
+const uaInfo = parseUserAgent(userAgent, properties);
+
+// Only client events create sessions
+if (uaInfo.isServer || isTimestampFromThePast) {
+  // Server events or old events don't create new sessions
+}
+```
+
+## Timestamps
+
+Events can include custom timestamps to track when events actually occurred, rather than when they were received by the server.
+
+### Setting Custom Timestamps
+
+You can provide a custom timestamp using the `__timestamp` property in your event properties:
+
+```javascript
+track('page_view', {
+  __timestamp: '2024-01-15T10:30:00Z'
+});
+```
+
+### Timestamp Validation
+
+The system validates timestamps to prevent abuse and ensure data quality:
+
+1. **Future timestamps**: If a timestamp is more than **1 minute in the future**, the server timestamp is used instead
+2. **Past timestamps**: If a timestamp is older than **15 minutes**, it's marked as `isTimestampFromThePast: true`
+
+```typescript:apps/api/src/controllers/track.controller.ts
+// Timestamp validation logic
+const ONE_MINUTE_MS = 60 * 1000;
+const FIFTEEN_MINUTES_MS = 15 * ONE_MINUTE_MS;
+
+// Future check: more than 1 minute ahead
+if (clientTimestampNumber > safeTimestamp + ONE_MINUTE_MS) {
+  return { timestamp: safeTimestamp, isTimestampFromThePast: false };
+}
+
+// Past check: older than 15 minutes
+const isTimestampFromThePast =
+  clientTimestampNumber < safeTimestamp - FIFTEEN_MINUTES_MS;
+```
+
+### Timestamp Impact on Sessions
+
+**Important**: Events with timestamps older than 15 minutes (`isTimestampFromThePast: true`) will **not create new sessions**. This prevents historical data imports from creating artificial sessions in your analytics.
+
+```typescript:apps/worker/src/jobs/events.incoming-event.ts
+// Events from the past don't create sessions
+if (uaInfo.isServer || isTimestampFromThePast) {
+  // Attach to existing session or track without session
+}
+```
+
+This ensures that:
+- Real-time tracking creates proper sessions
+- Historical data imports don't interfere with session analytics
+- Backdated events are still tracked but don't affect session metrics

apps/public/content/docs/(tracking)/meta.json

@@ -0,0 +1,3 @@
+{
+  "pages": ["sdks", "how-it-works", "..."]
+}

apps/public/content/docs/(tracking)/revenue-tracking.mdx

@@ -0,0 +1,364 @@
+---
+title: Revenue tracking
+description: Learn how to easily track your revenue with OpenPanel and how to get it shown directly in your dashboard.
+---
+
+import { FlowStep } from '@/components/flow-step';
+
+Revenue tracking is a great way to get a better understanding of what your best revenue source is. On this page we'll break down how to get started.
+
+Before we start, we need to know some fundamentals about how OpenPanel and your payment provider work and how we can link a payment to a visitor.
+
+### Payment providers
+
+Usually, you create your checkout from your backend, which then returns a payment link that your visitor will be redirected to. When creating the checkout link, you usually add additional fields such as metadata, customer information, or order details. We'll add the device ID information in this metadata field to be able to link your payment to a visitor.
+
+### OpenPanel
+
+OpenPanel is a cookieless analytics tool that identifies visitors using a `device_id`. To link a payment to a visitor, you need to capture their `device_id` before they complete checkout. This `device_id` will be stored in your payment provider's metadata, and when the payment webhook arrives, you'll use it to associate the revenue with the correct visitor.
+
+## Some typical flows
+
+- [Revenue tracking from your backend (not identified)](#revenue-tracking-from-your-backend-webhook)
+- [Revenue tracking from your backend (identified)](#revenue-tracking-from-your-backend-webhook-identified)
+- [Revenue tracking from your frontend](#revenue-tracking-from-your-frontend)
+- [Revenue tracking without linking it to a identity or device](#revenue-tracking-without-linking-it-to-an-identity-or-device)
+
+### Revenue tracking from your backend (webhook)
+
+This is the most common flow and most secure one. Your backend receives webhooks from your payment provider, and here is the best opportunity to do revenue tracking. 
+
+<FlowStep step={1} actor="Visitor" description="Visits your website" icon="visitor" />
+
+<FlowStep step={2} actor="Visitor" description="Makes a purchase" icon="visitor" />
+
+<FlowStep step={3} actor="Your website" description="Does a POST request to get the checkout URL" icon="website">
+When you create the checkout, you should first call `op.fetchDeviceId()`, which will return your visitor's current `deviceId`. Pass this to your checkout endpoint.
+
+```javascript
+fetch('https://domain.com/api/checkout', {
+  method: 'POST',
+  headers: {
+    'Content-Type': 'application/json',
+  },
+  body: JSON.stringify({
+    deviceId: await op.fetchDeviceId(), // ✅ since deviceId is here we can link the payment now
+    // ... other checkout data
+  }),
+})
+  .then(response => response.json())
+  .then(data => {
+    // Handle checkout response, e.g., redirect to payment link
+    window.location.href = data.paymentUrl;
+  })
+```
+</FlowStep>
+
+<FlowStep step={4} actor="Your backend" description="Will generate and return the checkout URL" icon="backend">
+```javascript
+import Stripe from 'stripe';
+
+const stripe = new Stripe(process.env.STRIPE_SECRET_KEY);
+
+export async function POST(req: Request) {
+  const { deviceId, amount, currency } = await req.json();
+  
+  const session = await stripe.checkout.sessions.create({
+    payment_method_types: ['card'],
+    line_items: [
+      {
+        price_data: {
+          currency: currency,
+          product_data: { name: 'Product Name' },
+          unit_amount: amount * 100, // Convert to cents
+        },
+        quantity: 1,
+      },
+    ],
+    mode: 'payment',
+    metadata: {
+      deviceId: deviceId, // ✅ since deviceId is here we can link the payment now
+    },
+    success_url: 'https://domain.com/success',
+    cancel_url: 'https://domain.com/cancel',
+  });
+  
+  return Response.json({
+    paymentUrl: session.url,
+  });
+} 
+```
+</FlowStep>
+
+<FlowStep step={5} actor="Visitor" description="Gets redirected to payment link" icon="visitor" />
+
+<FlowStep step={6} actor="Visitor" description="Pays on your payment provider" icon="payment" />
+
+<FlowStep step={7} actor="Your backend" description="Receives a webhook for a successful payment" icon="backend">
+```javascript
+export async function POST(req: Request) {
+  const event = await req.json();
+  
+  // Stripe sends events with type and data.object structure
+  if (event.type === 'checkout.session.completed') {
+    const session = event.data.object;
+    const deviceId = session.metadata.deviceId;
+    const amount = session.amount_total;
+    
+    op.revenue(amount, { deviceId }); // ✅ since deviceId is here we can link the payment now
+  }
+  
+  return Response.json({ received: true });
+}
+```
+</FlowStep>
+
+<FlowStep step={8} actor="Visitor" description="Redirected to your website with payment confirmation" icon="success" isLast />
+
+---
+
+### Revenue tracking from your backend (webhook) - Identified users
+
+If your visitors are identified (meaning you have called `identify` with a `profileId`), this process gets a bit easier. You don't need to pass the `deviceId` when creating your checkout, and you only need to provide the `profileId` (in backend) to the revenue call.
+
+<FlowStep step={1} actor="Visitor" description="Visits your website" icon="visitor" />
+
+<FlowStep step={2} actor="Your website" description="Identifies the visitor" icon="website">
+When a visitor logs in or is identified, call `op.identify()` with their unique `profileId`.
+
+```javascript
+op.identify({
+  profileId: 'user-123', // Unique identifier for this user
+  email: 'user@example.com',
+  firstName: 'John',
+  lastName: 'Doe',
+});
+```
+</FlowStep>
+
+<FlowStep step={3} actor="Visitor" description="Makes a purchase" icon="visitor" />
+
+<FlowStep step={4} actor="Your website" description="Does a POST request to get the checkout URL" icon="website">
+Since the visitor is already identified, you don't need to fetch or pass the `deviceId`. Just send the checkout data.
+
+```javascript
+fetch('https://domain.com/api/checkout', {
+  method: 'POST',
+  headers: {
+    'Content-Type': 'application/json',
+  },
+  body: JSON.stringify({
+    // ✅ No deviceId needed - user is already identified
+    // ... other checkout data
+  }),
+})
+  .then(response => response.json())
+  .then(data => {
+    // Handle checkout response, e.g., redirect to payment link
+    window.location.href = data.paymentUrl;
+  })
+```
+</FlowStep>
+
+<FlowStep step={5} actor="Your backend" description="Will generate and return the checkout URL" icon="backend">
+Since the user is authenticated, you can get their `profileId` from the session and store it in metadata for easy retrieval in the webhook.
+
+```javascript
+import Stripe from 'stripe';
+
+const stripe = new Stripe(process.env.STRIPE_SECRET_KEY);
+
+export async function POST(req: Request) {
+  const { amount, currency } = await req.json();
+  
+  // Get profileId from authenticated session
+  const profileId = req.session.userId; // or however you get the user ID
+  
+  const session = await stripe.checkout.sessions.create({
+    payment_method_types: ['card'],
+    line_items: [
+      {
+        price_data: {
+          currency: currency,
+          product_data: { name: 'Product Name' },
+          unit_amount: amount * 100, // Convert to cents
+        },
+        quantity: 1,
+      },
+    ],
+    mode: 'payment',
+    metadata: {
+      profileId: profileId, // ✅ Store profileId instead of deviceId
+    },
+    success_url: 'https://domain.com/success',
+    cancel_url: 'https://domain.com/cancel',
+  });
+  
+  return Response.json({
+    paymentUrl: session.url,
+  });
+} 
+```
+</FlowStep>
+
+<FlowStep step={6} actor="Visitor" description="Gets redirected to payment link" icon="visitor" />
+
+<FlowStep step={7} actor="Visitor" description="Pays on your payment provider" icon="payment" />
+
+<FlowStep step={8} actor="Your backend" description="Receives a webhook for a successful payment" icon="backend">
+In the webhook handler, retrieve the `profileId` from the session metadata.
+
+```javascript
+export async function POST(req: Request) {
+  const event = await req.json();
+  
+  // Stripe sends events with type and data.object structure
+  if (event.type === 'checkout.session.completed') {
+    const session = event.data.object;
+    const profileId = session.metadata.profileId;
+    const amount = session.amount_total;
+    
+    op.revenue(amount, { profileId }); // ✅ Use profileId instead of deviceId
+  }
+  
+  return Response.json({ received: true });
+}
+```
+</FlowStep>
+
+<FlowStep step={9} actor="Visitor" description="Redirected to your website with payment confirmation" icon="success" isLast />
+
+---
+
+### Revenue tracking from your frontend
+
+This flow tracks revenue directly from your frontend. Since the success page doesn't have access to the payment amount (payment happens on Stripe's side), we track revenue when checkout is initiated and then confirm it on the success page.
+
+<FlowStep step={1} actor="Visitor" description="Visits your website" icon="visitor" />
+
+<FlowStep step={2} actor="Visitor" description="Clicks to purchase" icon="visitor" />
+
+<FlowStep step={3} actor="Your website" description="Track revenue when checkout is initiated" icon="website">
+When the visitor clicks the checkout button, track the revenue with the amount.
+
+```javascript
+async function handleCheckout() {
+  const amount = 2000; // Amount in cents
+
+  // Create a pending revenue (stored in sessionStorage)
+  op.pendingRevenue(amount, {
+    productId: '123',
+    // ... other properties
+  });
+   
+  // Redirect to Stripe checkout
+  window.location.href = 'https://checkout.stripe.com/...';
+}
+```
+</FlowStep>
+
+<FlowStep step={4} actor="Visitor" description="Gets redirected to payment link" icon="visitor" />
+
+<FlowStep step={5} actor="Visitor" description="Pays on your payment provider" icon="payment" />
+
+<FlowStep step={6} actor="Visitor" description="Redirected back to your success page" icon="visitor" />
+
+<FlowStep step={7} actor="Your website" description="Confirm/flush the revenue on success page" icon="website" isLast>
+On your success page, flush all pending revenue events. This will send all pending revenues tracked during checkout and clear them from sessionStorage.
+
+```javascript
+// Flush all pending revenues
+await op.flushRevenue();
+
+// Or if you want to clear without sending (e.g., payment was cancelled)
+op.clearRevenue();
+```
+</FlowStep>
+
+#### Pros:
+- Quick way to get going
+- No backend required
+- Can track revenue immediately when checkout starts
+
+#### Cons:
+- Less accurate (visitor might not complete payment)
+- Less "secure" meaning anyone could post revenue data
+
+---
+
+### Revenue tracking without linking it to an identity or device
+
+If you simply want to track revenue totals without linking payments to specific visitors or devices, you can call `op.revenue()` directly from your backend without providing a `deviceId` or `profileId`. This is the simplest approach and works well when you only need aggregate revenue data.
+
+<FlowStep step={1} actor="Visitor" description="Makes a purchase" icon="visitor" />
+
+<FlowStep step={2} actor="Visitor" description="Pays on your payment provider" icon="payment" />
+
+<FlowStep step={3} actor="Your backend" description="Receives a webhook for a successful payment" icon="backend" isLast>
+Simply call `op.revenue()` with the amount. No `deviceId` or `profileId` is needed.
+
+```javascript
+export async function POST(req: Request) {
+  const event = await req.json();
+  
+  // Stripe sends events with type and data.object structure
+  if (event.type === 'checkout.session.completed') {
+    const session = event.data.object;
+    const amount = session.amount_total;
+    
+    op.revenue(amount); // ✅ Simple revenue tracking without linking to a visitor
+  }
+  
+  return Response.json({ received: true });
+}
+```
+</FlowStep>
+
+#### Pros:
+- Simplest implementation
+- No need to capture or pass device IDs
+- Works well for aggregate revenue tracking
+
+#### Cons:
+- **You can't dive deeper into where this revenue came from.** For instance, you won't be able to see which source generates the best revenue, which campaigns are most profitable, or which visitors are your highest-value customers.
+- Revenue events won't be linked to specific user journeys or sessions
+
+## Available methods
+
+### Revenue 
+
+The revenue method will create a revenue event. It's important to know that this method will not work if your OpenPanel instance didn't receive a client secret (for security reasons). You can enable frontend revenue tracking within your project settings.
+
+```javascript
+op.revenue(amount: number, properties: Record<string, unknown>): Promise<void>
+```
+
+### Add a pending revenue
+
+This method will create a pending revenue item and store it in sessionStorage. It will not be sent to OpenPanel until you call `flushRevenue()`. Pending revenues are automatically restored from sessionStorage when the SDK initializes.
+
+```javascript
+op.pendingRevenue(amount: number, properties?: Record<string, unknown>): void
+```
+
+### Send all pending revenues
+
+This method will send all pending revenues to OpenPanel and then clear them from sessionStorage. Returns a Promise that resolves when all revenues have been sent.
+
+```javascript
+await op.flushRevenue(): Promise<void>
+```
+
+### Clear any pending revenue
+
+This method will clear all pending revenues from memory and sessionStorage without sending them to OpenPanel. Useful if a payment was cancelled or you want to discard pending revenues.
+
+```javascript
+op.clearRevenue(): void
+```
+
+### Fetch your current users device id
+
+```javascript
+op.fetchDeviceId(): Promise<string>
+```

apps/public/content/docs/(tracking)/sdks/meta.json

@@ -0,0 +1,20 @@
+{
+  "title": "SDKs",
+  "pages": [
+    "script",
+    "web",
+    "javascript",
+    "nextjs",
+    "react",
+    "vue",
+    "astro",
+    "remix",
+    "express",
+    "python",
+    "react-native",
+    "swift",
+    "kotlin",
+    "..."
+  ],
+  "defaultOpen": false
+}

apps/public/content/docs/(tracking)/sdks/nextjs.mdx

@@ -273,19 +273,21 @@ export function GET() {
 
 ### Proxy events
 
-With `createNextRouteHandler` you can proxy your events through your server, this will ensure all events are tracked since there is a lot of adblockers that block requests to third party domains.
+With `createNextRouteHandler` you can proxy your events through your server, this will ensure all events are tracked since there is a lot of adblockers that block requests to third party domains. You'll also need to either host our tracking script or you can use `createScriptHandler` function which proxies this as well.
 
 ```typescript title="/app/api/[...op]/route.ts"
-import { createNextRouteHandler } from '@openpanel/nextjs/server';
+import { createNextRouteHandler, createScriptHandler } from '@openpanel/nextjs/server';
 
 export const POST = createNextRouteHandler();
+export const GET = createScriptHandler()
 ```
 
-Remember to change the `apiUrl` in the `OpenPanelComponent` to your own server.
+Remember to change the `apiUrl` and `cdnUrl` in the `OpenPanelComponent` to your own server. 
 
 ```tsx
 <OpenPanelComponent
   apiUrl="/api/op" // [!code highlight]
+  cdnUrl="/api/op/op1.js" // [!code highlight]
   clientId="your-client-id"
   trackScreenViews={true}
 />

apps/public/content/docs/(tracking)/sdks/script.mdx

@@ -15,7 +15,7 @@ Just insert this snippet and replace `YOUR_CLIENT_ID` with your client id.
 
 ```html title="index.html" /clientId: 'YOUR_CLIENT_ID'/
 <script>
-  window.op = window.op||function(...args){(window.op.q=window.op.q||[]).push(args);};
+  window.op=window.op||function(){var n=[],o=new Proxy((function(){arguments.length>0&&n.push(Array.prototype.slice.call(arguments))}),{get:function(o,t){return"q"===t?n:function(){n.push([t].concat(Array.prototype.slice.call(arguments)))}}});return o}();
   window.op('init', {
     clientId: 'YOUR_CLIENT_ID',
     trackScreenViews: true,

apps/public/content/docs/get-started/identify-users.mdx

@@ -0,0 +1,47 @@
+---
+title: Identify Users
+description: Connect anonymous events to specific users.
+---
+
+By default, OpenPanel tracks visitors anonymously. To connect these events to a specific user in your database, you need to identify them.
+
+## How it works
+
+When a user logs in or signs up, you should call the `identify` method. This associates their current session and all future events with their unique ID from your system.
+
+```javascript
+op.identify({
+  profileId: 'user_123'
+});
+```
+
+## Adding user traits
+
+You can also pass user traits (like name, email, or plan type) when you identify them. These traits will appear in the user's profile in your dashboard.
+
+```javascript
+op.identify({
+  profileId: 'user_123',
+  firstName: 'Jane',
+  lastName: 'Doe',
+  email: 'jane@example.com',
+  company: 'Acme Inc'
+});
+```
+
+### Standard traits
+
+We recommend using these standard keys for common user information so they display correctly in the OpenPanel dashboard:
+
+- `firstName`
+- `lastName`
+- `email`
+- `phone`
+- `avatar`
+
+## Best Practices
+
+1.  **Call on login**: Always identify the user immediately after they log in.
+2.  **Call on update**: If a user updates their profile, call identify again with the new information.
+3.  **Unique IDs**: Use a stable, unique ID from your database (like a UUID) rather than an email address or username that might change.
+

apps/public/content/docs/get-started/install-openpanel.mdx

@@ -0,0 +1,81 @@
+---
+title: Install OpenPanel
+description: Get started with OpenPanel in less than 2 minutes.
+---
+
+import { Cards, Card } from 'fumadocs-ui/components/card';
+import { Code, Globe, Layout, Smartphone, FileJson } from 'lucide-react';
+
+The quickest way to get started with OpenPanel is to use our Web SDK. It works with any website.
+
+## Quick Start
+
+Simply add this script tag to your website's `<head>` section.
+
+```html title="index.html"
+<script>
+  window.op=window.op||function(){var n=[],o=new Proxy((function(){arguments.length>0&&n.push(Array.prototype.slice.call(arguments))}),{get:function(o,t){return"q"===t?n:function(){n.push([t].concat(Array.prototype.slice.call(arguments)))}}});return o}();
+  window.op('init', {
+    clientId: 'YOUR_CLIENT_ID',
+    trackScreenViews: true,
+    trackOutgoingLinks: true,
+    trackAttributes: true,
+  });
+</script>
+<script src="https://openpanel.dev/op1.js" defer async></script>
+```
+
+That's it! OpenPanel will now automatically track:
+- Page views
+- Visit duration
+- Referrers
+- Device and browser information
+- Location
+
+## Using a Framework?
+
+If you are using a specific framework or platform, we have dedicated SDKs that provide a better developer experience.
+
+<Cards>
+  <Card
+    href="/docs/sdks/nextjs"
+    title="Next.js"
+    icon={<Globe />}
+    description="Optimized for App Router and Server Components"
+  />
+  <Card
+    href="/docs/sdks/react"
+    title="React"
+    icon={<Layout />}
+    description="Components and hooks for React applications"
+  />
+  <Card
+    href="/docs/sdks/vue"
+    title="Vue"
+    icon={<Layout />}
+    description="Integration for Vue.js applications"
+  />
+  <Card
+    href="/docs/sdks/javascript"
+    title="JavaScript"
+    icon={<FileJson />}
+    description="Universal JavaScript/TypeScript SDK"
+  />
+  <Card
+    href="/docs/sdks/react-native"
+    title="React Native"
+    icon={<Smartphone />}
+    description="Track mobile apps with React Native"
+  />
+  <Card
+    href="/docs/sdks/python"
+    title="Python"
+    icon={<Code />}
+    description="Server-side tracking for Python"
+  />
+</Cards>
+
+## Explore all SDKs
+
+We support many more platforms. Check out our [SDKs Overview](/docs/sdks) for the full list.
+

apps/public/content/docs/get-started/meta.json

@@ -0,0 +1,8 @@
+{
+  "pages": [
+    "install-openpanel",
+    "track-events",
+    "identify-users",
+    "revenue-tracking"
+  ]
+}

apps/public/content/docs/get-started/track-events.mdx

@@ -0,0 +1,48 @@
+---
+title: Track Events
+description: Learn how to track custom events to measure user actions.
+---
+
+Events are the core of OpenPanel. They allow you to measure specific actions users take on your site, like clicking a button, submitting a form, or completing a purchase.
+
+## Tracking an event
+
+To track an event, simply call the `track` method with an event name.
+
+```javascript
+op.track('button_clicked');
+```
+
+## Adding properties
+
+You can add additional context to your events by passing a properties object. This helps you understand the details of the interaction.
+
+```javascript
+op.track('signup_button_clicked', {
+  location: 'header',
+  color: 'blue',
+  variant: 'primary'
+});
+```
+
+### Common property types
+
+- **Strings**: Text values like names, categories, or IDs.
+- **Numbers**: Numeric values like price, quantity, or score.
+- **Booleans**: True or false values.
+
+## Using Data Attributes
+
+If you prefer not to write JavaScript, you can use data attributes to track clicks automatically.
+
+```html
+<button 
+  data-track="signup_clicked" 
+  data-location="header"
+>
+  Sign Up
+</button>
+```
+
+When a user clicks this button, OpenPanel will automatically track a `signup_clicked` event with the property `location: 'header'`.
+

apps/public/content/docs/index.mdx

@@ -1,111 +1,83 @@
 ---
-title: Introduction to OpenPanel
-description: Get started with OpenPanel's powerful analytics platform that combines the best of product and web analytics in one simple solution.
+title: What is OpenPanel?
+description: OpenPanel is an open-source web and product analytics platform that combines the power of Mixpanel with the ease of Plausible. Whether you're tracking website visitors or analyzing user behavior in your app, OpenPanel provides the insights you need without the complexity.
 ---
 
-## What is OpenPanel?
+import { UserIcon,HardDriveIcon } from 'lucide-react'
 
-OpenPanel is an open-source analytics platform that combines product analytics (like Mixpanel) with web analytics (like Plausible) into one simple solution. Whether you're tracking website visitors or analyzing user behavior in your app, OpenPanel provides the insights you need without the complexity.
+## ✨ Key Features
 
-## Key Features
+- **🔍 Advanced Analytics**: Funnels, cohorts, user profiles, and session history
+- **📊 Real-time Dashboards**: Live data updates and interactive charts
+- **🎯 A/B Testing**: Built-in variant testing with detailed breakdowns
+- **🔔 Smart Notifications**: Event and funnel-based alerts
+- **🌍 Privacy-First**: Cookieless tracking and GDPR compliance
+- **🚀 Developer-Friendly**: Comprehensive SDKs and API access
+- **📦 Self-Hosted**: Full control over your data and infrastructure
+- **💸 Transparent Pricing**: No hidden costs
+- **🛠️ Custom Dashboards**: Flexible chart creation and data visualization
+- **📱 Multi-Platform**: Web, mobile (iOS/Android), and server-side tracking
 
-### Web Analytics
-- **Real-time data**: See visitor activity as it happens
-- **Traffic sources**: Understand where your visitors come from
-- **Geographic insights**: Track visitor locations and trends
-- **Device analytics**: Monitor usage across different devices
-- **Page performance**: Analyze your most visited pages
+## 📊 Analytics Platform Comparison
 
-### Product Analytics
-- **Event tracking**: Monitor user actions and interactions
-- **User profiles**: Build detailed user journey insights
-- **Funnels**: Analyze conversion paths
-- **Retention**: Track user engagement over time
-- **Custom properties**: Add context to your events
+| Feature                                | OpenPanel | Mixpanel | GA4       | Plausible |
+|----------------------------------------|-----------|----------|-----------|-----------|
+| ✅ Open-source                         | ✅         | ❌        | ❌        | ✅         |
+| 🧩 Self-hosting supported              | ✅         | ❌        | ❌        | ✅         |
+| 🔒 Cookieless by default               | ✅         | ❌        | ❌        | ✅         |
+| 🔁 Real-time dashboards                | ✅         | ✅        | ❌        | ✅         |
+| 🔍 Funnels & cohort analysis           | ✅         | ✅        | ✅*       | ✅***         |
+| 👤 User profiles & session history     | ✅         | ✅        | ❌        | ❌         |
+| 📈 Custom dashboards & charts          | ✅         | ✅        | ✅        | ❌         |
+| 💬 Event & funnel notifications        | ✅         | ✅        | ❌        | ❌         |
+| 🌍 GDPR-compliant tracking             | ✅         | ✅        | ❌**      | ✅         |
+| 📦 SDKs (Web, Swift, Kotlin, ReactNative) | ✅      | ✅        | ✅        | ❌         |
+| 💸 Transparent pricing                 | ✅         | ❌        | ✅*       | ✅         |
+| 🚀 Built for developers                | ✅         | ✅        | ❌        | ✅         |
+| 🔧 A/B testing & variant breakdowns    | ✅         | ✅        | ❌        | ❌         |
 
-## Getting Started
+✅* GA4 has a free tier but often requires BigQuery (paid) for raw data access.  
+❌** GA4 has faced GDPR bans in several EU countries due to data transfers to US-based servers.  
+✅*** Plausible has simple goals
 
-1. **Installation**: Choose your preferred method:
-   - [Script tag](/docs/sdks/script) - Quickest way to get started
-   - [Web SDK](/docs/sdks/web) - For more control and TypeScript support
-   - [React](/docs/sdks/react) - Native React integration
-   - [Next.js](/docs/sdks/nextjs) - Optimized for Next.js apps
+## 🚀 Quick Start
 
-2. **Core Methods**:
-   ```js
-   // Track an event
-   track('button_clicked', { 
-     buttonId: 'signup',
-     location: 'header'
-   });
+Before you can start tracking your events you'll need to create an account or spin up your own instance of OpenPanel.
 
-   // Identify a user
-   identify({
-     profileId: 'user123',
-     email: 'user@example.com',
-     firstName: 'John'
-   });
-   ```
+<Cards>
+  <Card
+    href="https://dashboard.openpanel.dev/onboarding"
+    title="Create an account"
+    icon={<UserIcon />}
+    description="Create your account and workspace"
+  />
+  <Card
+    href="/docs/self-hosting/self-hosting"
+    title="Self-hosted OpenPanel"
+    icon={<HardDriveIcon />}
+    description="Get full control and start self-host"
+  />
+</Cards>
 
-## Privacy First
+1. **[Install OpenPanel](/docs/get-started/install-openpanel)** - Add the script tag or use one of our SDKs
+2. **[Track Events](/docs/get-started/track-events)** - Start measuring user actions
+3. **[Identify Users](/docs/get-started/identify-users)** - Connect events to specific users
+4. **[Track Revenue](/docs/get-started/revenue-tracking)** - Monitor purchases and subscriptions
+
+## 🔒 Privacy First
 
 OpenPanel is built with privacy in mind:
-- No cookies required
-- GDPR and CCPA compliant
-- Self-hosting option available
-- Full control over your data
+- **No cookies required** - Cookieless tracking by default
+- **GDPR and CCPA compliant** - Built for privacy regulations
+- **Self-hosting option** - Full control over your data
+- **Transparent data handling** - You own your data
 
-## Open Source
+## 🌐 Open Source
 
 OpenPanel is fully open-source and available on [GitHub](https://github.com/Openpanel-dev/openpanel). We believe in transparency and community-driven development.
 
-## Need Help?
+## 💬 Need Help?
 
 - Join our [Discord community](https://go.openpanel.dev/discord)
 - Check our [GitHub issues](https://github.com/Openpanel-dev/openpanel/issues)
 - Email us at [hello@openpanel.dev](mailto:hello@openpanel.dev)
-
-## Core Methods
-
-### Set global properties
-
-Sets global properties that will be included with every subsequent event.
-
-### Track
-
-Tracks a custom event with the given name and optional properties. 
-
-#### Tips
-
-You can identify the user directly with this method.
-
-```js title="Example shown in JavaScript"
-track('your_event_name', {
-  foo: 'bar',
-  baz: 'qux',
-  // reserved property name
-  __identify: {
-    profileId: 'your_user_id', // required
-    email: 'your_user_email',
-    firstName: 'your_user_name',
-    lastName: 'your_user_name',
-    avatar: 'your_user_avatar',
-  }
-});
-```
-
-### Identify
-
-Associates the current user with a unique identifier and optional traits.
-
-### Increment
-
-Increments a numeric property for a user.
-
-### Decrement
-
-Decrements a numeric property for a user.
-
-### Clear
-
-Clears the current user identifier and ends the session.

apps/public/content/docs/meta.json

@@ -0,0 +1,16 @@
+{
+  "pages": [
+    "---Introduction---",
+    "index",
+    "---Get started---",
+    "...get-started",
+    "---Tracking---",
+    "...(tracking)",
+    "---API---",
+    "...api",
+    "---Self-hosting---",
+    "...self-hosting",
+    "---Migration---",
+    "...migration"
+  ]
+}

apps/public/content/docs/sdks/meta.json

@@ -1,5 +0,0 @@
-{
-  "title": "SDKs",
-  "pages": ["script", "web", "javascript", "nextjs", "react", "vue", "astro", "remix", "express", "python", "react-native", "swift", "kotlin"],
-  "defaultOpen": true
-}

apps/public/content/docs/self-hosting/self-hosting.mdx

@@ -76,7 +76,7 @@ The path should be `/api` and the domain should be your domain.
 
 ```html title="index.html"
 <script>
-  window.op = window.op||function(...args){(window.op.q=window.op.q||[]).push(args);};
+  window.op=window.op||function(){var n=[],o=new Proxy((function(){arguments.length>0&&n.push(Array.prototype.slice.call(arguments))}),{get:function(o,t){return"q"===t?n:function(){n.push([t].concat(Array.prototype.slice.call(arguments)))}}});return o}();
   window.op('init', {
     apiUrl: 'https://your-domain.com/api', // [!code highlight]
     clientId: 'YOUR_CLIENT_ID',

apps/public/package.json

@@ -3,7 +3,7 @@
   "version": "0.0.0",
   "private": true,
   "scripts": {
-    "dev": "pnpm with-env next dev",
+    "dev": "pnpm with-env next dev --port 3001",
     "build": "pnpm with-env next build",
     "start": "next start",
     "postinstall": "fumadocs-mdx",
@@ -13,7 +13,8 @@
   "dependencies": {
     "@hyperdx/node-opentelemetry": "^0.8.1",
     "@number-flow/react": "0.3.5",
-    "@openpanel/nextjs": "^1.0.5",
+    "@openpanel/common": "workspace:*",
+    "@openpanel/nextjs": "^1.0.15",
     "@openpanel/payments": "workspace:^",
     "@openpanel/sdk-info": "workspace:^",
     "@openstatus/react": "0.0.3",

apps/start/package.json

@@ -19,7 +19,6 @@
   },
   "dependencies": {
     "@ai-sdk/react": "^1.2.5",
-    "@clickhouse/client": "^1.2.0",
     "@dnd-kit/core": "^6.3.1",
     "@dnd-kit/sortable": "^10.0.0",
     "@dnd-kit/utilities": "^3.2.2",
@@ -104,7 +103,6 @@
     "lodash.throttle": "^4.1.1",
     "lottie-react": "^2.4.0",
     "lucide-react": "^0.476.0",
-    "mathjs": "^12.3.2",
     "mitt": "^3.0.1",
     "nuqs": "^2.5.2",
     "prisma-error-enum": "^0.1.3",

apps/start/src/components/chart-ssr.tsx

@@ -1,112 +0,0 @@
-import * as d3 from 'd3';
-
-export function ChartSSR({
-  data,
-  dots = false,
-  color = 'blue',
-}: {
-  dots?: boolean;
-  color?: 'blue' | 'green' | 'red';
-  data: { value: number; date: Date }[];
-}) {
-  if (data.length === 0) {
-    return null;
-  }
-
-  const xScale = d3
-    .scaleTime()
-    .domain([data[0]!.date, data[data.length - 1]!.date])
-    .range([0, 100]);
-  const yScale = d3
-    .scaleLinear()
-    .domain([0, d3.max(data.map((d) => d.value)) ?? 0])
-    .range([100, 0]);
-
-  const line = d3
-    .line<(typeof data)[number]>()
-    .curve(d3.curveMonotoneX)
-    .x((d) => xScale(d.date))
-    .y((d) => yScale(d.value));
-
-  const area = d3
-    .area<(typeof data)[number]>()
-    .curve(d3.curveMonotoneX)
-    .x((d) => xScale(d.date))
-    .y0(yScale(0))
-    .y1((d) => yScale(d.value));
-
-  const pathLine = line(data);
-  const pathArea = area(data);
-
-  if (!pathLine) {
-    return null;
-  }
-
-  const gradientId = `gradient-${color}`;
-
-  return (
-    <div className="relative h-full w-full">
-      {/* Chart area */}
-      <svg className="absolute inset-0 h-full w-full overflow-visible">
-        <svg
-          viewBox="0 0 100 100"
-          className="overflow-visible"
-          preserveAspectRatio="none"
-        >
-          <defs>
-            <linearGradient
-              id={gradientId}
-              x1="0"
-              y1="0"
-              x2="0"
-              y2="100%"
-              gradientUnits="userSpaceOnUse"
-            >
-              <stop offset="0%" stopColor={color} stopOpacity={0.2} />
-              <stop offset="50%" stopColor={color} stopOpacity={0.05} />
-              <stop offset="100%" stopColor={color} stopOpacity={0} />
-            </linearGradient>
-          </defs>
-          {/* Gradient area */}
-          {pathArea && (
-            <path
-              d={pathArea}
-              fill={`url(#${gradientId})`}
-              vectorEffect="non-scaling-stroke"
-            />
-          )}
-          {/* Line */}
-          <path
-            d={pathLine}
-            fill="none"
-            className={
-              color === 'green'
-                ? 'text-green-600'
-                : color === 'red'
-                  ? 'text-red-600'
-                  : 'text-highlight'
-            }
-            stroke="currentColor"
-            strokeWidth="2"
-            vectorEffect="non-scaling-stroke"
-          />
-
-          {/* Circles */}
-          {dots &&
-            data.map((d) => (
-              <path
-                key={d.date.toString()}
-                d={`M ${xScale(d.date)} ${yScale(d.value)} l 0.0001 0`}
-                vectorEffect="non-scaling-stroke"
-                strokeWidth="8"
-                strokeLinecap="round"
-                fill="none"
-                stroke="currentColor"
-                className="text-gray-400"
-              />
-            ))}
-        </svg>
-      </svg>
-    </div>
-  );
-}

apps/start/src/components/charts/chart-tooltip.tsx

@@ -1,7 +1,43 @@
+import { cn } from '@/utils/cn';
 import { createContext, useContext as useBaseContext } from 'react';
 
 import { Tooltip as RechartsTooltip, type TooltipProps } from 'recharts';
 
+export const ChartTooltipContainer = ({
+  children,
+}: { children: React.ReactNode }) => {
+  return (
+    <div className="min-w-[180px] col gap-2 rounded-xl border bg-background/80 p-3  shadow-xl backdrop-blur-sm">
+      {children}
+    </div>
+  );
+};
+
+export const ChartTooltipHeader = ({
+  children,
+}: { children: React.ReactNode }) => {
+  return <div className="flex justify-between gap-8">{children}</div>;
+};
+
+export const ChartTooltipItem = ({
+  children,
+  color,
+  className,
+  innerClassName,
+}: {
+  children: React.ReactNode;
+  color: string;
+  className?: string;
+  innerClassName?: string;
+}) => {
+  return (
+    <div className={cn('flex gap-2', className)}>
+      <div className="w-[3px] rounded-full" style={{ background: color }} />
+      <div className={cn('col flex-1 gap-1', innerClassName)}>{children}</div>
+    </div>
+  );
+};
+
 export function createChartTooltip<
   PropsFromTooltip,
   PropsFromContext extends Record<string, unknown>,
@@ -31,9 +67,9 @@ export function createChartTooltip<
     }
 
     return (
-      <div className="flex min-w-[180px] flex-col gap-2 rounded-xl border bg-background/80 p-3  shadow-xl backdrop-blur-sm">
+      <ChartTooltipContainer>
         <Tooltip data={data} context={context} {...tooltip} />
-      </div>
+      </ChartTooltipContainer>
     );
   };
 

apps/start/src/components/charts/common-bar.tsx

@@ -77,6 +77,15 @@ export const BarShapeBlue = BarWithBorder({
     fill: 'rgba(59, 121, 255, 0.4)',
   },
 });
+export const BarShapeGreen = BarWithBorder({
+  borderHeight: 2,
+  border: 'rgba(59, 169, 116, 1)',
+  fill: 'rgba(59, 169, 116, 0.3)',
+  active: {
+    border: 'rgba(59, 169, 116, 1)',
+    fill: 'rgba(59, 169, 116, 0.4)',
+  },
+});
 export const BarShapeProps = BarWithBorder({
   borderHeight: 2,
   border: 'props',

apps/start/src/components/events/event-icon.tsx

@@ -48,6 +48,10 @@ export const EventIconRecords: Record<
     icon: 'ExternalLinkIcon',
     color: 'indigo',
   },
+  revenue: {
+    icon: 'DollarSignIcon',
+    color: 'green',
+  },
 };
 
 export const EventIconMapper: Record<string, LucideIcon> = {

apps/start/src/components/events/table/item.tsx

@@ -54,7 +54,7 @@ export const EventItem = memo<EventItemProps>(
           }}
           data-slot="inner"
           className={cn(
-            'col gap-2 flex-1 p-2',
+            'col gap-1 flex-1 p-2',
             // Desktop
             '@lg:row @lg:items-center',
             'cursor-pointer',
@@ -63,7 +63,7 @@ export const EventItem = memo<EventItemProps>(
               : 'hover:bg-def-200',
           )}
         >
-          <div className="min-w-0 flex-1 row items-center gap-4">
+          <div className="min-w-0 flex-1 row items-center gap-2">
             <button
               type="button"
               className="transition-transform hover:scale-105"
@@ -77,7 +77,7 @@ export const EventItem = memo<EventItemProps>(
             >
               <EventIcon name={event.name} size="sm" meta={event.meta} />
             </button>
-            <span className="min-w-0 whitespace-break-spaces wrap-break-word break-all">
+            <span className="min-w-0 whitespace-break-spaces wrap-break-word break-all text-sm leading-normal">
               {event.name === 'screen_view' ? (
                 <>
                   <span className="text-muted-foreground mr-2">Visit:</span>
@@ -87,13 +87,12 @@ export const EventItem = memo<EventItemProps>(
                 </>
               ) : (
                 <>
-                  <span className="text-muted-foreground mr-2">Event:</span>
                   <span className="font-medium">{event.name}</span>
                 </>
               )}
             </span>
           </div>
-          <div className="row gap-2 items-center @max-lg:pl-10">
+          <div className="row gap-2 items-center @max-lg:pl-8">
             {event.referrerName && viewOptions.referrerName !== false && (
               <Pill
                 icon={<SerieIcon className="mr-2" name={event.referrerName} />}

apps/start/src/components/feedback-button.tsx

@@ -8,7 +8,7 @@ export function FeedbackButton() {
   return (
     <Button
       variant={'outline'}
-      className="text-left justify-start"
+      className="text-left justify-start text-[13px]"
       icon={SparklesIcon}
       onClick={() => {
         op.track('feedback_button_clicked');

apps/start/src/components/onboarding/connect-web.tsx

@@ -24,7 +24,7 @@ const ConnectWeb = ({ client }: Props) => {
         <Syntax
           className="border"
           code={`<script>
-  window.op = window.op||function(...args){(window.op.q=window.op.q||[]).push(args);};
+  window.op=window.op||function(){var n=[],o=new Proxy((function(){arguments.length>0&&n.push(Array.prototype.slice.call(arguments))}),{get:function(o,t){return"q"===t?n:function(){n.push([t].concat(Array.prototype.slice.call(arguments)))}}});return o}();
   window.op('init', {
     clientId: '${client?.id ?? 'YOUR_CLIENT_ID'}',
     trackScreenViews: true,

apps/start/src/components/organization/billing-faq.tsx

@@ -10,7 +10,7 @@ const questions = [
   {
     question: 'Does OpenPanel have a free tier?',
     answer: [
-      'For our Cloud plan we offer a 14 days free trial, this is mostly for you to be able to try out OpenPanel before committing to a paid plan.',
+      'For our Cloud plan we offer a 30 days free trial, this is mostly for you to be able to try out OpenPanel before committing to a paid plan.',
       'OpenPanel is also open-source and you can self-host it for free!',
       '',
       'Why does OpenPanel not have a free tier?',
@@ -37,13 +37,19 @@ const questions = [
       'You can change your billing information by clicking the "Manage your subscription" button in the billing section.',
     ],
   },
+  {
+    question: 'We need a custom plan, can you help us?',
+    answer: [
+      'Yes, we can help you with that. Please contact us at hello@openpanel.com to request a quote.',
+    ],
+  },
 ];
 
 export function BillingFaq() {
   return (
     <Widget className="w-full">
       <WidgetHead className="flex items-center justify-between">
-        <span className="title">Usage</span>
+        <span className="title">Frequently asked questions</span>
       </WidgetHead>
       <Accordion
         type="single"

apps/start/src/components/organization/billing-prompt.tsx

@@ -0,0 +1,201 @@
+import { PageHeader } from '@/components/page-header';
+import { Button, LinkButton } from '@/components/ui/button';
+import { useNumber } from '@/hooks/use-numer-formatter';
+import { useTRPC } from '@/integrations/trpc/react';
+import { op } from '@/utils/op';
+import type { IServiceOrganization } from '@openpanel/db';
+import { useMutation, useQuery } from '@tanstack/react-query';
+import {
+  BarChart3Icon,
+  DollarSignIcon,
+  InfinityIcon,
+  type LucideIcon,
+  MapIcon,
+  ShieldCheckIcon,
+  TrendingUpIcon,
+} from 'lucide-react';
+import { useEffect } from 'react';
+import { toast } from 'sonner';
+
+const COPY = {
+  expired: {
+    title: 'Subscription expired',
+    description:
+      'Reactivate your subscription to regain access to your analytics data and insights.',
+    body: [
+      "Your subscription has expired, but your data is safe and waiting for you. Reactivate now to continue tracking your users' behavior and making data-driven decisions.",
+      "Don't let gaps in your analytics cost you valuable insights. Every day without data is a day of missed opportunities to understand and grow your audience.",
+    ],
+  },
+  trialEnded: {
+    title: 'Trial ended',
+    description:
+      'Upgrade now to keep the momentum going and continue optimizing your product.',
+    body: [
+      "You've experienced the power of OpenPanel. Keep the insights flowing and maintain continuity in your analytics data.",
+      "We'll still process all your incoming events for the coming 30 days.",
+    ],
+  },
+  freePlan: {
+    title: 'Free plan is removed',
+    description:
+      "We've removed the free plan to focus on delivering exceptional value to our paid customers.",
+    body: [
+      "We've evolved our offering to provide better features, faster performance, and dedicated support. Our paid plans ensure we can continue building the analytics platform you deserve.",
+      'Simple, transparent pricing with no hidden fees. Pay for what you use, and scale as you grow. Your investment in analytics pays for itself through better decisions and improved user experiences.',
+    ],
+  },
+};
+
+export default function BillingPrompt({
+  organization,
+  type,
+}: {
+  organization: IServiceOrganization;
+  type: keyof typeof COPY;
+}) {
+  const number = useNumber();
+  const trpc = useTRPC();
+  const { data: products, isLoading: isLoadingProducts } = useQuery(
+    trpc.subscription.products.queryOptions({
+      organizationId: organization.id,
+    }),
+  );
+  const checkout = useMutation(
+    trpc.subscription.checkout.mutationOptions({
+      onSuccess(data) {
+        if (data?.url) {
+          window.location.href = data.url;
+        } else {
+          toast.success('Subscription updated', {
+            description: 'It might take a few seconds to update',
+          });
+        }
+      },
+    }),
+  );
+  const { title, description, body } = COPY[type];
+
+  const bestProductFit = products?.find(
+    (product) =>
+      typeof product.metadata.eventsLimit === 'number' &&
+      product.metadata.eventsLimit >=
+        organization.subscriptionPeriodEventsCount,
+  );
+
+  useEffect(() => {
+    op.track('billing_prompt_viewed', {
+      type,
+    });
+  }, [type]);
+
+  const price = bestProductFit
+    ? new Intl.NumberFormat('en-US', {
+        style: 'currency',
+        currency: 'usd',
+        minimumFractionDigits: 0,
+        maximumFractionDigits: 1,
+      }).format(
+        bestProductFit.prices[0] && 'priceAmount' in bestProductFit.prices[0]
+          ? bestProductFit.prices[0].priceAmount / 100
+          : 0,
+      )
+    : null;
+
+  return (
+    <div className="p-4 md:p-20 max-w-7xl mx-auto">
+      <div className="border rounded-lg overflow-hidden bg-def-200 p-2 items-center">
+        <div className="md:row">
+          <div className="p-6 bg-background rounded-md border col gap-4 flex-1">
+            <PageHeader title={title} description={description} />
+            {body.map((paragraph) => (
+              <p key={paragraph}>
+                {paragraph.replace(
+                  '{{events}}',
+                  number.format(
+                    organization.subscriptionPeriodEventsCount ?? 0,
+                  ),
+                )}
+              </p>
+            ))}
+            <div className="col gap-2 mt-auto">
+              {bestProductFit && (
+                <div className="text-sm text-muted-foreground leading-normal">
+                  Based on your usage (
+                  {number.format(
+                    organization.subscriptionPeriodEventsCount ?? 0,
+                  )}{' '}
+                  events) we recommend upgrading <br />
+                  to the <strong>{bestProductFit.name}</strong> plan for{' '}
+                  <strong>{price}</strong> per month.
+                </div>
+              )}
+              <div className="col md:row gap-2">
+                <Button
+                  size="lg"
+                  loading={isLoadingProducts}
+                  disabled={!bestProductFit}
+                  onClick={() => {
+                    if (bestProductFit) {
+                      op.track('billing_prompt_upgrade_clicked', {
+                        type,
+                        price:
+                          bestProductFit.prices[0] &&
+                          'priceAmount' in bestProductFit.prices[0]
+                            ? bestProductFit.prices[0].priceAmount / 100
+                            : 0,
+                      });
+                      checkout.mutate({
+                        organizationId: organization.id,
+                        productPriceId: bestProductFit.prices[0].id,
+                        productId: bestProductFit.id,
+                      });
+                    }
+                  }}
+                >
+                  Upgrade to {price}
+                </Button>
+                <LinkButton
+                  size="lg"
+                  variant="outline"
+                  to="/$organizationId/billing"
+                  params={{ organizationId: organization.id }}
+                >
+                  View pricing
+                </LinkButton>
+              </div>
+            </div>
+          </div>
+          <div className="shrink-0 flex-1 p-6 gap-4 col min-w-[200px] max-w-[300px]">
+            <Point icon={DollarSignIcon}>Plans start at just $2.5/month</Point>
+            <Point icon={InfinityIcon}>
+              Unlimited reports, members and projects
+            </Point>
+            <Point icon={BarChart3Icon}>Advanced funnels and conversions</Point>
+            <Point icon={MapIcon}>Real-time analytics</Point>
+            <Point icon={TrendingUpIcon}>
+              Track KPIs and custom events (revenue soon)
+            </Point>
+            <Point icon={ShieldCheckIcon}>
+              Privacy-focused and GDPR compliant
+            </Point>
+          </div>
+        </div>
+      </div>
+    </div>
+  );
+}
+
+function Point({
+  icon: Icon,
+  children,
+}: { icon: LucideIcon; children: React.ReactNode }) {
+  return (
+    <div className="row gap-2">
+      <div className="size-6 shrink-0 center-center rounded-full bg-amber-500 text-white">
+        <Icon className="size-4" />
+      </div>
+      <h3 className="font-medium mt-[1.5px]">{children}</h3>
+    </div>
+  );
+}

apps/start/src/components/organization/billing-usage.tsx

@@ -18,7 +18,6 @@ import {
   BarChart,
   CartesianGrid,
   Tooltip as RechartTooltip,
-  ReferenceLine,
   ResponsiveContainer,
   XAxis,
   YAxis,
@@ -38,7 +37,7 @@ function Card({ title, value }: { title: string; value: string }) {
   );
 }
 
-export default function Usage({ organization }: Props) {
+export default function BillingUsage({ organization }: Props) {
   const number = useNumber();
   const trpc = useTRPC();
   const usageQuery = useQuery(
@@ -82,6 +81,7 @@ export default function Usage({ organization }: Props) {
       </div>,
     );
   }
+
   if (usageQuery.isError) {
     return wrapper(
       <div className="center-center p-8 font-medium">
@@ -90,6 +90,12 @@ export default function Usage({ organization }: Props) {
     );
   }
 
+  if (usageQuery.data?.length === 0) {
+    return wrapper(
+      <div className="center-center p-8 font-medium">No usage data yet</div>,
+    );
+  }
+
   const subscriptionPeriodEventsLimit = organization.hasSubscription
     ? organization.subscriptionPeriodEventsLimit
     : 0;
@@ -159,7 +165,7 @@ export default function Usage({ organization }: Props) {
 
   return wrapper(
     <>
-      <div className="border-b divide-x divide-border -m-4 mb-4 grid grid-cols-2 md:grid-cols-4">
+      <div className="-m-4 mb-4 grid grid-cols-2 [&>div]:shadow-[0_0_0_0.5px] [&_div]:shadow-border border-b">
         {organization.hasSubscription ? (
           <>
             <Card
@@ -171,14 +177,6 @@ export default function Usage({ organization }: Props) {
                   : '🤷‍♂️'
               }
             />
-            <Card
-              title="Limit"
-              value={number.format(subscriptionPeriodEventsLimit)}
-            />
-            <Card
-              title="Events count"
-              value={number.format(subscriptionPeriodEventsCount)}
-            />
             <Card
               title="Left to use"
               value={
@@ -192,6 +190,14 @@ export default function Usage({ organization }: Props) {
                     )
               }
             />
+            <Card
+              title="Events count"
+              value={number.format(subscriptionPeriodEventsCount)}
+            />
+            <Card
+              title="Limit"
+              value={number.format(subscriptionPeriodEventsLimit)}
+            />
           </>
         ) : (
           <>
@@ -209,95 +215,36 @@ export default function Usage({ organization }: Props) {
           </>
         )}
       </div>
-      <div className="grid grid-cols-1 lg:grid-cols-2 gap-6">
-        {/* Events Chart */}
-        <div className="space-y-2">
-          <h3 className="text-sm font-medium text-muted-foreground">
-            {useWeeklyIntervals ? 'Weekly Events' : 'Daily Events'}
-          </h3>
-          <div className="max-h-[300px] h-[250px] w-full p-4">
-            <ResponsiveContainer>
-              <BarChart data={chartData} barSize={useWeeklyIntervals ? 20 : 8}>
-                <RechartTooltip
-                  content={<EventsTooltip useWeekly={useWeeklyIntervals} />}
-                />
-                <Bar
-                  dataKey="count"
-                  isAnimationActive={false}
-                  shape={BarShapeBlue}
-                />
-                <XAxis {...xAxisProps} dataKey="date" />
-                <YAxis {...yAxisProps} domain={[0, 'dataMax']} />
-                <CartesianGrid
-                  horizontal={true}
-                  vertical={false}
-                  strokeDasharray="3 3"
-                  strokeOpacity={0.5}
-                />
-              </BarChart>
-            </ResponsiveContainer>
-          </div>
-        </div>
-
-        {/* Total Events vs Limit Chart */}
-        <div className="space-y-2">
-          <h3 className="text-sm font-medium text-muted-foreground">
-            Total Events vs Limit
-          </h3>
-          <div className="max-h-[300px] h-[250px] w-full p-4">
-            <ResponsiveContainer>
-              <BarChart
-                data={[
-                  {
-                    name: 'Total Events',
-                    count: subscriptionPeriodEventsCount,
-                    limit: subscriptionPeriodEventsLimit,
-                  },
-                ]}
-              >
-                <RechartTooltip content={<TotalTooltip />} cursor={false} />
-                {organization.hasSubscription &&
-                  subscriptionPeriodEventsLimit > 0 && (
-                    <ReferenceLine
-                      y={subscriptionPeriodEventsLimit}
-                      stroke={getChartColor(1)}
-                      strokeWidth={2}
-                      strokeDasharray="3 3"
-                      strokeOpacity={0.8}
-                      strokeLinecap="round"
-                      label={{
-                        value: `Limit (${number.format(subscriptionPeriodEventsLimit)})`,
-                        fill: getChartColor(1),
-                        position: 'insideTopRight',
-                        fontSize: 12,
-                      }}
-                    />
-                  )}
-                <Bar
-                  dataKey="count"
-                  isAnimationActive={false}
-                  shape={BarShapeBlue}
-                />
-                <XAxis {...X_AXIS_STYLE_PROPS} dataKey="name" />
-                <YAxis
-                  {...yAxisProps}
-                  domain={[
-                    0,
-                    Math.max(
-                      subscriptionPeriodEventsLimit,
-                      subscriptionPeriodEventsCount,
-                    ) * 1.1,
-                  ]}
-                />
-                <CartesianGrid
-                  horizontal={true}
-                  vertical={false}
-                  strokeDasharray="3 3"
-                  strokeOpacity={0.5}
-                />
-              </BarChart>
-            </ResponsiveContainer>
-          </div>
+      {/* Events Chart */}
+      <div className="space-y-2">
+        <h3 className="text-sm font-medium text-muted-foreground">
+          {useWeeklyIntervals ? 'Weekly Events' : 'Daily Events'}
+        </h3>
+        <div className="max-h-[300px] h-[250px] w-full p-4">
+          <ResponsiveContainer>
+            <BarChart data={chartData} barSize={useWeeklyIntervals ? 20 : 8}>
+              <RechartTooltip
+                content={<EventsTooltip useWeekly={useWeeklyIntervals} />}
+                cursor={{
+                  fill: 'var(--def-200)',
+                  stroke: 'var(--def-200)',
+                }}
+              />
+              <Bar
+                dataKey="count"
+                isAnimationActive={false}
+                shape={BarShapeBlue}
+              />
+              <XAxis {...xAxisProps} dataKey="date" />
+              <YAxis {...yAxisProps} domain={[0, 'dataMax']} />
+              <CartesianGrid
+                horizontal={true}
+                vertical={false}
+                strokeDasharray="3 3"
+                strokeOpacity={0.5}
+              />
+            </BarChart>
+          </ResponsiveContainer>
         </div>
       </div>
     </>,

apps/start/src/components/organization/billing.tsx

@@ -1,45 +1,55 @@
 import { Button } from '@/components/ui/button';
-import {
-  Dialog,
-  DialogClose,
-  DialogContent,
-  DialogDescription,
-  DialogFooter,
-  DialogTitle,
-} from '@/components/ui/dialog';
-import { Slider } from '@/components/ui/slider';
-import { Switch } from '@/components/ui/switch';
-import { Tooltiper } from '@/components/ui/tooltip';
-import { Widget, WidgetBody, WidgetHead } from '@/components/widget';
-import { useAppParams } from '@/hooks/use-app-params';
+import { useNumber } from '@/hooks/use-numer-formatter';
 import useWS from '@/hooks/use-ws';
 import { useTRPC } from '@/integrations/trpc/react';
-import { showConfirm } from '@/modals';
-import { op } from '@/utils/op';
+import { pushModal, useOnPushModal } from '@/modals';
+import { formatDate } from '@/utils/date';
 import type { IServiceOrganization } from '@openpanel/db';
-import type { IPolarPrice } from '@openpanel/payments';
 import { useMutation, useQuery, useQueryClient } from '@tanstack/react-query';
-import { Loader2Icon } from 'lucide-react';
+import { differenceInDays } from 'date-fns';
 import { useQueryState } from 'nuqs';
 import { useEffect, useMemo, useState } from 'react';
 import { toast } from 'sonner';
+import { Progress } from '../ui/progress';
+import { Widget, WidgetBody, WidgetHead } from '../widget';
+import { BillingFaq } from './billing-faq';
+import BillingUsage from './billing-usage';
 
 type Props = {
   organization: IServiceOrganization;
 };
 
 export default function Billing({ organization }: Props) {
+  const [success, setSuccess] = useQueryState('customer_session_token');
   const queryClient = useQueryClient();
   const trpc = useTRPC();
-  const [customerSessionToken, setCustomerSessionToken] = useQueryState(
-    'customer_session_token',
-  );
+  const number = useNumber();
+
   const productsQuery = useQuery(
     trpc.subscription.products.queryOptions({
       organizationId: organization.id,
     }),
   );
 
+  const currentProductQuery = useQuery(
+    trpc.subscription.getCurrent.queryOptions({
+      organizationId: organization.id,
+    }),
+  );
+
+  const portalMutation = useMutation(
+    trpc.subscription.portal.mutationOptions({
+      onSuccess(data) {
+        if (data?.url) {
+          window.location.href = data.url;
+        }
+      },
+      onError(error) {
+        toast.error(error.message);
+      },
+    }),
+  );
+
   useWS(`/live/organization/${organization.id}`, () => {
     queryClient.invalidateQueries(trpc.organization.pathFilter());
   });
@@ -54,378 +64,228 @@ export default function Billing({ organization }: Props) {
       .filter((product) => product.prices.some((p) => p.amountType !== 'free'));
   }, [productsQuery.data, recurringInterval]);
 
-  useEffect(() => {
-    if (organization.subscriptionInterval) {
-      setRecurringInterval(
-        organization.subscriptionInterval as 'year' | 'month',
+  const currentProduct = currentProductQuery.data ?? null;
+  const currentPrice = currentProduct?.prices.flatMap((p) =>
+    p.type === 'recurring' && p.amountType === 'fixed' ? [p] : [],
+  )[0];
+
+  const renderStatus = () => {
+    if (organization.isActive && organization.subscriptionCurrentPeriodEnd) {
+      return (
+        <p>
+          Your subscription will be renewed on{' '}
+          {formatDate(organization.subscriptionCurrentPeriodEnd)}
+        </p>
       );
     }
-  }, [organization.subscriptionInterval]);
+
+    if (organization.isCanceled && organization.subscriptionCanceledAt) {
+      return (
+        <p>
+          Your subscription was canceled on{' '}
+          {formatDate(organization.subscriptionCanceledAt)}
+        </p>
+      );
+    }
+    if (
+      organization.isWillBeCanceled &&
+      organization.subscriptionCurrentPeriodEnd
+    ) {
+      return (
+        <p>
+          Your subscription will be canceled on{' '}
+          {formatDate(organization.subscriptionCurrentPeriodEnd)}
+        </p>
+      );
+    }
+
+    if (
+      organization.subscriptionStatus === 'expired' &&
+      organization.subscriptionCurrentPeriodEnd
+    ) {
+      return (
+        <p>
+          Your subscription expired on{' '}
+          {formatDate(organization.subscriptionCurrentPeriodEnd)}
+        </p>
+      );
+    }
+    if (
+      organization.subscriptionStatus === 'trialing' &&
+      organization.subscriptionEndsAt
+    ) {
+      return (
+        <p>
+          Your trial will end on {formatDate(organization.subscriptionEndsAt)}
+        </p>
+      );
+    }
+
+    return null;
+  };
 
   useEffect(() => {
-    if (customerSessionToken) {
-      op.track('subscription_created');
+    if (success) {
+      pushModal('BillingSuccess');
     }
-  }, [customerSessionToken]);
+  }, [success]);
 
-  const [selectedProductIndex, setSelectedProductIndex] = useState<number>(0);
-
-  // Check if organization has a custom product
-  const hasCustomProduct = useMemo(() => {
-    return products.some((product) => product.metadata?.custom === true);
-  }, [products]);
-
-  // Preferred default selection when there is no active subscription
-  const defaultSelectedIndex = useMemo(() => {
-    const defaultIndex = products.findIndex(
-      (product) => product.metadata?.eventsLimit === 100_000,
-    );
-    return defaultIndex >= 0 ? defaultIndex : 0;
-  }, [products]);
-
-  // Find current subscription index (-1 when no subscription)
-  const currentSubscriptionIndex = useMemo(() => {
-    if (!organization.subscriptionProductId) {
-      return -1;
+  // Clear query state when modal is closed
+  useOnPushModal('BillingSuccess', (open) => {
+    if (!open) {
+      setSuccess(null);
     }
-    return products.findIndex(
-      (product) => product.id === organization.subscriptionProductId,
-    );
-  }, [products, organization.subscriptionProductId]);
+  });
 
-  // Check if selected index is the "custom" option (beyond available products)
-  const isCustomOption = selectedProductIndex >= products.length;
-
-  // Find the highest event limit to make the custom option dynamic
-  const highestEventLimit = useMemo(() => {
-    const limits = products
-      .map((product) => product.metadata?.eventsLimit)
-      .filter((limit): limit is number => typeof limit === 'number');
-    return Math.max(...limits, 0);
-  }, [products]);
-
-  // Format the custom option label dynamically
-  const customOptionLabel = useMemo(() => {
-    if (highestEventLimit >= 1_000_000) {
-      return `+${(highestEventLimit / 1_000_000).toFixed(0)}M`;
-    }
-    if (highestEventLimit >= 1_000) {
-      return `+${(highestEventLimit / 1_000).toFixed(0)}K`;
-    }
-    return `+${highestEventLimit}`;
-  }, [highestEventLimit]);
-
-  // Set initial slider position to current subscription or default plan when none
-  useEffect(() => {
-    if (currentSubscriptionIndex >= 0) {
-      setSelectedProductIndex(currentSubscriptionIndex);
-    } else {
-      setSelectedProductIndex(defaultSelectedIndex);
-    }
-  }, [currentSubscriptionIndex, defaultSelectedIndex]);
-
-  const selectedProduct = products[selectedProductIndex];
-  const isUpgrade = selectedProductIndex > currentSubscriptionIndex;
-  const isDowngrade = selectedProductIndex < currentSubscriptionIndex;
-  const isCurrentPlan = selectedProductIndex === currentSubscriptionIndex;
-
-  function renderBillingSlider() {
-    if (productsQuery.isLoading) {
-      return (
-        <div className="center-center p-8">
-          <Loader2Icon className="animate-spin" />
-        </div>
-      );
-    }
-    if (productsQuery.isError) {
-      return (
-        <div className="center-center p-8 font-medium">
-          Issues loading all tiers
-        </div>
-      );
-    }
-
-    if (hasCustomProduct) {
-      return (
-        <div className="p-8 text-center">
-          <div className="text-muted-foreground">
-            Not applicable since custom product
-          </div>
-        </div>
-      );
-    }
-
-    return (
-      <div className="p-6 space-y-6">
-        <div className="space-y-4">
-          <div className="flex justify-between items-center">
-            <span className="text-sm font-medium">Select your plan</span>
-            <span className="text-sm text-muted-foreground">
-              {selectedProduct?.name || 'No plan selected'}
-            </span>
-          </div>
-
-          <Slider
-            value={[selectedProductIndex]}
-            onValueChange={([value]) => setSelectedProductIndex(value)}
-            min={0}
-            max={products.length} // +1 for the custom option
-            step={1}
-            className="w-full"
-            disabled={hasCustomProduct}
-          />
-
-          <div className="flex justify-between text-xs text-muted-foreground">
-            {products.map((product, index) => {
-              const eventsLimit = product.metadata?.eventsLimit;
-              return (
-                <div key={product.id} className="text-center">
-                  <div className="font-medium">
-                    {eventsLimit && typeof eventsLimit === 'number'
-                      ? `${(eventsLimit / 1000).toFixed(0)}K`
-                      : 'Free'}
-                  </div>
-                  <div className="text-xs">events</div>
+  return (
+    <div className="grid grid-cols-1 md:grid-cols-2 gap-8">
+      <div className="col gap-8">
+        {currentProduct && currentPrice ? (
+          <Widget className="w-full">
+            <WidgetHead className="flex items-center justify-between gap-4">
+              <div className="flex-1 title truncate">{currentProduct.name}</div>
+              <div className="text-lg">
+                <span className="font-bold">
+                  {number.currency(currentPrice.priceAmount / 100)}
+                </span>
+                <span className="text-muted-foreground">
+                  {' / '}
+                  {recurringInterval === 'year' ? 'year' : 'month'}
+                </span>
+              </div>
+            </WidgetHead>
+            <WidgetBody>
+              {renderStatus()}
+              <div className="col mt-4">
+                <div className="font-semibold mb-2">
+                  {number.format(organization.subscriptionPeriodEventsCount)} /{' '}
+                  {number.format(Number(currentProduct.metadata.eventsLimit))}
                 </div>
-              );
-            })}
-            {/* Add the custom option label */}
-            <div className="text-center">
-              <div className="font-medium">{customOptionLabel}</div>
-              <div className="text-xs">events</div>
-            </div>
-          </div>
-        </div>
-
-        {(selectedProduct || isCustomOption) && (
-          <div className="border rounded-lg p-4 space-y-4">
-            {isCustomOption ? (
-              // Custom option content
-              <>
-                <div className="flex justify-between items-center">
-                  <div>
-                    <h3 className="font-semibold">Custom Plan</h3>
-                    <p className="text-sm text-muted-foreground">
-                      {customOptionLabel} events per {recurringInterval}
-                    </p>
-                  </div>
-                  <div className="text-right">
-                    <span className="text-lg font-semibold">
-                      Custom Pricing
-                    </span>
-                  </div>
-                </div>
-                <div className="bg-muted/50 rounded-lg p-4 text-center">
-                  <p className="text-sm text-muted-foreground mb-2">
-                    Need higher limits?
-                  </p>
-                  <p className="text-sm">
-                    Reach out to{' '}
-                    <a
-                      className="underline font-medium"
-                      href="mailto:hello@openpanel.dev"
+                <Progress
+                  value={
+                    (organization.subscriptionPeriodEventsCount /
+                      Number(currentProduct.metadata.eventsLimit)) *
+                    100
+                  }
+                  size="sm"
+                />
+                <div className="row justify-between mt-4">
+                  <Button
+                    variant="outline"
+                    size="sm"
+                    onClick={() =>
+                      portalMutation.mutate({ organizationId: organization.id })
+                    }
+                  >
+                    <svg
+                      className="size-4 mr-2"
+                      width="300"
+                      height="300"
+                      viewBox="0 0 300 300"
+                      fill="none"
+                      xmlns="http://www.w3.org/2000/svg"
                     >
-                      hello@openpanel.dev
-                    </a>{' '}
-                    and we'll help you with a custom quota.
-                  </p>
+                      <g clip-path="url(#clip0_1_4)">
+                        <path
+                          fill-rule="evenodd"
+                          clip-rule="evenodd"
+                          d="M66.4284 274.26C134.876 320.593 227.925 302.666 274.258 234.219C320.593 165.771 302.666 72.7222 234.218 26.3885C165.77 -19.9451 72.721 -2.0181 26.3873 66.4297C-19.9465 134.877 -2.01938 227.927 66.4284 274.26ZM47.9555 116.67C30.8375 169.263 36.5445 221.893 59.2454 256.373C18.0412 217.361 7.27564 150.307 36.9437 92.318C55.9152 55.2362 87.5665 29.3937 122.5 18.3483C90.5911 36.7105 62.5549 71.8144 47.9555 116.67ZM175.347 283.137C211.377 272.606 244.211 246.385 263.685 208.322C293.101 150.825 282.768 84.4172 242.427 45.2673C264.22 79.7626 269.473 131.542 252.631 183.287C237.615 229.421 208.385 265.239 175.347 283.137ZM183.627 266.229C207.945 245.418 228.016 210.604 236.936 168.79C251.033 102.693 232.551 41.1978 195.112 20.6768C214.97 47.3945 225.022 99.2902 218.824 157.333C214.085 201.724 200.814 240.593 183.627 266.229ZM63.7178 131.844C49.5155 198.43 68.377 260.345 106.374 280.405C85.9962 254.009 75.5969 201.514 81.8758 142.711C86.5375 99.0536 99.4504 60.737 116.225 35.0969C92.2678 55.983 72.5384 90.4892 63.7178 131.844ZM199.834 149.561C200.908 217.473 179.59 272.878 152.222 273.309C124.853 273.742 101.797 219.039 100.724 151.127C99.6511 83.2138 120.968 27.8094 148.337 27.377C175.705 26.9446 198.762 81.648 199.834 149.561Z"
+                          fill="currentColor"
+                        />
+                      </g>
+                      <defs>
+                        <clipPath id="clip0_1_4">
+                          <rect width="300" height="300" fill="white" />
+                        </clipPath>
+                      </defs>
+                    </svg>
+                    Customer portal
+                  </Button>
+                  <Button
+                    size="sm"
+                    onClick={() =>
+                      pushModal('SelectBillingPlan', {
+                        organization,
+                        currentProduct,
+                      })
+                    }
+                  >
+                    {organization.isWillBeCanceled
+                      ? 'Reactivate subscription'
+                      : 'Change subscription'}
+                  </Button>
                 </div>
-              </>
-            ) : (
-              // Regular product content
-              <>
-                <div className="flex justify-between items-center">
-                  <div>
-                    <h3 className="font-semibold">{selectedProduct.name}</h3>
-                    <p className="text-sm text-muted-foreground">
-                      {selectedProduct.metadata?.eventsLimit
-                        ? `${selectedProduct.metadata.eventsLimit.toLocaleString()} events per ${recurringInterval}`
-                        : 'Free tier'}
-                    </p>
-                  </div>
-                  <div className="text-right">
-                    {selectedProduct.prices[0]?.amountType === 'free' ? (
-                      <span className="text-lg font-semibold">Free</span>
-                    ) : (
-                      <span className="text-lg font-semibold">
-                        {new Intl.NumberFormat('en-US', {
-                          style: 'currency',
-                          currency:
-                            selectedProduct.prices[0]?.priceCurrency || 'USD',
-                          minimumFractionDigits: 0,
-                          maximumFractionDigits: 1,
-                        }).format(
-                          (selectedProduct.prices[0] &&
-                          'priceAmount' in selectedProduct.prices[0]
-                            ? selectedProduct.prices[0].priceAmount
-                            : 0) / 100,
-                        )}
-                        <span className="text-sm text-muted-foreground">
-                          {' / '}
-                          {recurringInterval === 'year' ? 'year' : 'month'}
-                        </span>
-                      </span>
-                    )}
-                  </div>
+              </div>
+            </WidgetBody>
+          </Widget>
+        ) : (
+          <Widget className="w-full">
+            <WidgetHead className="flex items-center justify-between">
+              <div className="font-bold text-lg flex-1">
+                {organization.isTrial
+                  ? 'Get started'
+                  : 'No active subscription'}
+              </div>
+              <div className="text-lg">
+                <span className="">
+                  {organization.isTrial ? '30 days free trial' : ''}
+                </span>
+              </div>
+            </WidgetHead>
+            <WidgetBody>
+              {organization.isTrial && organization.subscriptionEndsAt ? (
+                <p>
+                  Your trial will end on{' '}
+                  {formatDate(organization.subscriptionEndsAt)} (
+                  {differenceInDays(
+                    organization.subscriptionEndsAt,
+                    new Date(),
+                  ) + 1}{' '}
+                  days left)
+                </p>
+              ) : (
+                <p>
+                  Your trial has expired. Please upgrade your account to
+                  continue using Openpanel.
+                </p>
+              )}
+              <div className="col mt-4">
+                <div className="font-semibold mb-2">
+                  {number.format(organization.subscriptionPeriodEventsCount)} /{' '}
+                  {number.format(
+                    Number(organization.subscriptionPeriodEventsLimit),
+                  )}
                 </div>
-
-                {!isCurrentPlan && selectedProduct.prices[0] && (
-                  <div className="flex justify-end">
-                    <CheckoutButton
-                      disabled={selectedProduct.disabled}
-                      key={selectedProduct.prices[0].id}
-                      price={selectedProduct.prices[0]}
-                      organization={organization}
-                      buttonText={
-                        isUpgrade
-                          ? 'Upgrade'
-                          : isDowngrade
-                            ? 'Downgrade'
-                            : 'Activate'
-                      }
-                    />
-                  </div>
-                )}
-
-                {isCurrentPlan && (
-                  <div className="flex justify-end">
-                    <Button variant="outline" disabled>
-                      Current Plan
-                    </Button>
-                  </div>
-                )}
-              </>
-            )}
-          </div>
+                <Progress
+                  value={
+                    (organization.subscriptionPeriodEventsCount /
+                      Number(organization.subscriptionPeriodEventsLimit)) *
+                    100
+                  }
+                  size="sm"
+                />
+                <div className="row justify-end mt-4">
+                  <Button
+                    size="sm"
+                    onClick={() =>
+                      pushModal('SelectBillingPlan', {
+                        organization,
+                        currentProduct,
+                      })
+                    }
+                  >
+                    Upgrade
+                  </Button>
+                </div>
+              </div>
+            </WidgetBody>
+          </Widget>
         )}
+
+        <BillingUsage organization={organization} />
       </div>
-    );
-  }
 
-  return (
-    <>
-      <Widget className="w-full">
-        <WidgetHead className="flex items-center justify-between">
-          <span className="title">Billing</span>
-          <div className="flex items-center gap-2">
-            <span className="text-sm text-muted-foreground">
-              {recurringInterval === 'year'
-                ? 'Yearly (2 months free)'
-                : 'Monthly'}
-            </span>
-            <Switch
-              checked={recurringInterval === 'year'}
-              onCheckedChange={(checked) =>
-                setRecurringInterval(checked ? 'year' : 'month')
-              }
-            />
-          </div>
-        </WidgetHead>
-        <WidgetBody>
-          <div className="-m-4">{renderBillingSlider()}</div>
-        </WidgetBody>
-      </Widget>
-      <Dialog
-        open={!!customerSessionToken}
-        onOpenChange={(open) => {
-          setCustomerSessionToken(null);
-          if (!open) {
-            queryClient.invalidateQueries(trpc.organization.pathFilter());
-          }
-        }}
-      >
-        <DialogContent>
-          <DialogTitle>Subscription created</DialogTitle>
-          <DialogDescription>
-            We have registered your subscription. It'll be activated within a
-            couple of seconds.
-          </DialogDescription>
-          <DialogFooter>
-            <DialogClose asChild>
-              <Button>OK</Button>
-            </DialogClose>
-          </DialogFooter>
-        </DialogContent>
-      </Dialog>
-    </>
-  );
-}
-
-function CheckoutButton({
-  price,
-  organization,
-  disabled,
-  buttonText,
-}: {
-  price: IPolarPrice;
-  organization: IServiceOrganization;
-  disabled?: string | null;
-  buttonText?: string;
-}) {
-  const trpc = useTRPC();
-  const isCurrentPrice = organization.subscriptionPriceId === price.id;
-  const checkout = useMutation(
-    trpc.subscription.checkout.mutationOptions({
-      onSuccess(data) {
-        if (data?.url) {
-          window.location.href = data.url;
-        } else {
-          toast.success('Subscription updated', {
-            description: 'It might take a few seconds to update',
-          });
-        }
-      },
-    }),
-  );
-
-  const isCanceled =
-    organization.subscriptionStatus === 'active' &&
-    isCurrentPrice &&
-    organization.subscriptionCanceledAt;
-  const isActive =
-    organization.subscriptionStatus === 'active' && isCurrentPrice;
-
-  return (
-    <Tooltiper
-      content={disabled}
-      tooltipClassName="max-w-xs"
-      side="left"
-      disabled={!disabled}
-    >
-      <Button
-        disabled={disabled !== null || (isActive && !isCanceled)}
-        key={price.id}
-        onClick={() => {
-          const createCheckout = () =>
-            checkout.mutate({
-              organizationId: organization.id,
-              productPriceId: price!.id,
-              productId: price.productId,
-            });
-
-          if (organization.subscriptionStatus === 'active') {
-            showConfirm({
-              title: 'Are you sure?',
-              text: `You're about the change your subscription.`,
-              onConfirm: () => {
-                op.track('subscription_change');
-                createCheckout();
-              },
-            });
-          } else {
-            op.track('subscription_checkout', {
-              product: price.productId,
-            });
-            createCheckout();
-          }
-        }}
-        loading={checkout.isPending}
-        className="w-28"
-        variant={isActive ? 'outline' : 'default'}
-      >
-        {buttonText ||
-          (isCanceled ? 'Reactivate' : isActive ? 'Active' : 'Activate')}
-      </Button>
-    </Tooltiper>
+      <BillingFaq />
+    </div>
   );
 }

apps/start/src/components/organization/current-subscription.tsx

@@ -1,283 +0,0 @@
-import { Alert, AlertDescription, AlertTitle } from '@/components/ui/alert';
-import { Button } from '@/components/ui/button';
-import { Widget, WidgetBody, WidgetHead } from '@/components/widget';
-import { useAppParams } from '@/hooks/use-app-params';
-import { useNumber } from '@/hooks/use-numer-formatter';
-import useWS from '@/hooks/use-ws';
-import { useTRPC } from '@/integrations/trpc/react';
-import { showConfirm } from '@/modals';
-import { cn } from '@/utils/cn';
-import type { IServiceOrganization } from '@openpanel/db';
-import { FREE_PRODUCT_IDS } from '@openpanel/payments';
-import { useMutation, useQuery, useQueryClient } from '@tanstack/react-query';
-import { format } from 'date-fns';
-import { Loader2Icon } from 'lucide-react';
-import { toast } from 'sonner';
-
-type Props = {
-  organization: IServiceOrganization;
-};
-
-export default function CurrentSubscription({ organization }: Props) {
-  const { projectId } = useAppParams();
-  const queryClient = useQueryClient();
-  const number = useNumber();
-  const trpc = useTRPC();
-  const productQuery = useQuery(
-    trpc.subscription.getCurrent.queryOptions({
-      organizationId: organization.id,
-    }),
-  );
-  const cancelSubscription = useMutation(
-    trpc.subscription.cancelSubscription.mutationOptions({
-      onSuccess() {
-        toast.success('Subscription cancelled', {
-          description: 'It might take a few seconds to update',
-        });
-      },
-      onError(error) {
-        toast.error(error.message);
-      },
-    }),
-  );
-  const portalMutation = useMutation(
-    trpc.subscription.portal.mutationOptions({
-      onSuccess(data) {
-        if (data?.url) {
-          window.location.href = data.url;
-        }
-      },
-    }),
-  );
-  const checkout = useMutation(
-    trpc.subscription.checkout.mutationOptions({
-      onSuccess(data) {
-        if (data?.url) {
-          window.location.href = data.url;
-        } else {
-          toast.success('Subscription updated', {
-            description: 'It might take a few seconds to update',
-          });
-        }
-      },
-    }),
-  );
-
-  useWS(`/live/organization/${organization.id}`, () => {
-    queryClient.invalidateQueries(
-      trpc.subscription.getCurrent.queryOptions({
-        organizationId: organization.id,
-      }),
-    );
-  });
-
-  function render() {
-    if (productQuery.isLoading) {
-      return (
-        <div className="center-center p-8">
-          <Loader2Icon className="animate-spin" />
-        </div>
-      );
-    }
-    if (productQuery.isError) {
-      return (
-        <div className="center-center p-8 font-medium">
-          Issues loading all tiers
-        </div>
-      );
-    }
-
-    if (!productQuery.data) {
-      return (
-        <div className="center-center p-8 font-medium">
-          No subscription found
-        </div>
-      );
-    }
-
-    const product = productQuery.data;
-    const price = product.prices[0]!;
-    return (
-      <>
-        <div className="gap-4 col">
-          {price.amountType === 'free' && (
-            <Alert variant="warning">
-              <AlertTitle>Free plan is removed</AlertTitle>
-              <AlertDescription>
-                We've removed the free plan. You can upgrade to a paid plan to
-                continue using OpenPanel.
-              </AlertDescription>
-            </Alert>
-          )}
-          <div className="row justify-between">
-            <div>Name</div>
-            <div className="text-right font-medium">{product.name}</div>
-          </div>
-          {price.amountType === 'fixed' ? (
-            <>
-              <div className="row justify-between">
-                <div>Price</div>
-                <div className="text-right font-medium font-mono">
-                  {number.currency(price.priceAmount / 100)}
-                </div>
-              </div>
-            </>
-          ) : (
-            <>
-              <div className="row justify-between">
-                <div>Price</div>
-                <div className="text-right font-medium font-mono">FREE</div>
-              </div>
-            </>
-          )}
-          <div className="row justify-between">
-            <div>Billing Cycle</div>
-            <div className="text-right font-medium">
-              {price.recurringInterval === 'month' ? 'Monthly' : 'Yearly'}
-            </div>
-          </div>
-          {typeof product.metadata.eventsLimit === 'number' && (
-            <div className="row justify-between">
-              <div>Events per mount</div>
-              <div className="text-right font-medium font-mono">
-                {number.format(product.metadata.eventsLimit)}
-              </div>
-            </div>
-          )}
-        </div>
-        {organization.subscriptionProductId &&
-          !FREE_PRODUCT_IDS.includes(organization.subscriptionProductId) && (
-            <div className="col gap-2">
-              {organization.isWillBeCanceled || organization.isCanceled ? (
-                <Button
-                  loading={checkout.isPending}
-                  onClick={() => {
-                    checkout.mutate({
-                      projectId,
-                      organizationId: organization.id,
-                      productPriceId: price!.id,
-                      productId: price.productId,
-                    });
-                  }}
-                >
-                  Reactivate subscription
-                </Button>
-              ) : (
-                <Button
-                  variant="destructive"
-                  loading={cancelSubscription.isPending}
-                  onClick={() => {
-                    showConfirm({
-                      title: 'Cancel subscription',
-                      text: 'Are you sure you want to cancel your subscription?',
-                      onConfirm() {
-                        cancelSubscription.mutate({
-                          organizationId: organization.id,
-                        });
-                      },
-                    });
-                  }}
-                >
-                  Cancel subscription
-                </Button>
-              )}
-            </div>
-          )}
-      </>
-    );
-  }
-
-  return (
-    <div className="col gap-2 md:w-72 shrink-0">
-      <Widget className="w-full">
-        <WidgetHead className="flex items-center justify-between">
-          <span className="title">Current Subscription</span>
-          <div className="flex items-center gap-2">
-            <div className="relative">
-              <div
-                className={cn(
-                  'h-3 w-3 animate-ping rounded-full bg-emerald-500 opacity-100 transition-all',
-                  organization.isExceeded ||
-                    organization.isExpired ||
-                    (organization.subscriptionStatus !== 'active' &&
-                      'bg-destructive'),
-                  organization.isWillBeCanceled && 'bg-orange-400',
-                )}
-              />
-              <div
-                className={cn(
-                  'absolute left-0 top-0 h-3 w-3 rounded-full bg-emerald-500 transition-all',
-                  organization.isExceeded ||
-                    organization.isExpired ||
-                    (organization.subscriptionStatus !== 'active' &&
-                      'bg-destructive'),
-                  organization.isWillBeCanceled && 'bg-orange-400',
-                )}
-              />
-            </div>
-          </div>
-        </WidgetHead>
-        <WidgetBody className="col gap-8">
-          {organization.isTrial && organization.subscriptionEndsAt && (
-            <Alert variant="warning">
-              <AlertTitle>Free trial</AlertTitle>
-              <AlertDescription>
-                Your organization is on a free trial. It ends on{' '}
-                {format(organization.subscriptionEndsAt, 'PPP')}
-              </AlertDescription>
-            </Alert>
-          )}
-          {organization.isExpired && organization.subscriptionEndsAt && (
-            <Alert variant="destructive">
-              <AlertTitle>Subscription expired</AlertTitle>
-              <AlertDescription>
-                Your subscription has expired. You can reactivate it by choosing
-                a new plan below.
-              </AlertDescription>
-              <AlertDescription>
-                It expired on {format(organization.subscriptionEndsAt, 'PPP')}
-              </AlertDescription>
-            </Alert>
-          )}
-          {organization.isWillBeCanceled && (
-            <Alert variant="warning">
-              <AlertTitle>Subscription canceled</AlertTitle>
-              <AlertDescription>
-                You have canceled your subscription. You can reactivate it by
-                choosing a new plan below.
-              </AlertDescription>
-              <AlertDescription className="font-medium">
-                It'll expire on{' '}
-                {format(organization.subscriptionEndsAt!, 'PPP')}
-              </AlertDescription>
-            </Alert>
-          )}
-          {organization.isCanceled && (
-            <Alert variant="warning">
-              <AlertTitle>Subscription canceled</AlertTitle>
-              <AlertDescription>
-                Your subscription was canceled on{' '}
-                {format(organization.subscriptionCanceledAt!, 'PPP')}
-              </AlertDescription>
-            </Alert>
-          )}
-          {render()}
-        </WidgetBody>
-      </Widget>
-      {organization.hasSubscription && (
-        <button
-          className="text-center mt-2 w-2/3 hover:underline self-center"
-          type="button"
-          onClick={() =>
-            portalMutation.mutate({
-              organizationId: organization.id,
-            })
-          }
-        >
-          Manage your subscription with
-          <span className="font-medium ml-1">Polar Customer Portal</span>
-        </button>
-      )}
-    </div>
-  );
-}

apps/start/src/components/organization/supporter-prompt.tsx

@@ -0,0 +1,147 @@
+import { Button, LinkButton } from '@/components/ui/button';
+import { useAppContext } from '@/hooks/use-app-context';
+import { useCookieStore } from '@/hooks/use-cookie-store';
+import { AnimatePresence, motion } from 'framer-motion';
+import {
+  AwardIcon,
+  HeartIcon,
+  type LucideIcon,
+  MessageCircleIcon,
+  RocketIcon,
+  SparklesIcon,
+  XIcon,
+  ZapIcon,
+} from 'lucide-react';
+
+const PERKS = [
+  {
+    icon: RocketIcon,
+    text: 'Latest Docker Images',
+    description: 'Bleeding-edge builds on every commit',
+  },
+  {
+    icon: MessageCircleIcon,
+    text: 'Prioritized Support',
+    description: 'Get help faster with priority Discord support',
+  },
+  {
+    icon: SparklesIcon,
+    text: 'Feature Requests',
+    description: 'Your ideas get prioritized in our roadmap',
+  },
+  {
+    icon: AwardIcon,
+    text: 'Exclusive Discord Role',
+    description: 'Special badge and recognition in our community',
+  },
+  {
+    icon: ZapIcon,
+    text: 'Early Access',
+    description: 'Try new features before public release',
+  },
+  {
+    icon: HeartIcon,
+    text: 'Direct Impact',
+    description: 'Your support directly funds development',
+  },
+] as const;
+
+function PerkPoint({
+  icon: Icon,
+  text,
+  description,
+}: {
+  icon: LucideIcon;
+  text: string;
+  description: string;
+}) {
+  return (
+    <div className="row gap-4 items-center">
+      <Icon className="size-4" />
+      <div className="flex-1 min-w-0 col gap-1.5">
+        <h3 className="font-medium text-sm">{text}</h3>
+        <p className="text-xs text-muted-foreground">{description}</p>
+      </div>
+    </div>
+  );
+}
+
+export default function SupporterPrompt() {
+  const { isSelfHosted } = useAppContext();
+  const [supporterPromptClosed, setSupporterPromptClosed] = useCookieStore(
+    'supporter-prompt-closed',
+    false,
+  );
+
+  if (!isSelfHosted) {
+    return null;
+  }
+
+  return (
+    <AnimatePresence>
+      {!supporterPromptClosed && (
+        <motion.div
+          initial={{ opacity: 0, x: 100, scale: 0.95 }}
+          animate={{ opacity: 1, x: 0, scale: 1 }}
+          exit={{ opacity: 0, x: 100, scale: 0.95 }}
+          transition={{
+            type: 'spring',
+            stiffness: 300,
+            damping: 30,
+          }}
+          className="fixed bottom-0 right-0 z-50 p-4 max-w-md"
+        >
+          <div className="bg-card border p-6 rounded-lg shadow-lg col gap-4">
+            <div>
+              <div className="row items-center justify-between">
+                <h2 className="text-xl font-semibold">Support OpenPanel</h2>
+                <Button
+                  variant="ghost"
+                  size="icon"
+                  className="rounded-full"
+                  onClick={() => setSupporterPromptClosed(true)}
+                >
+                  <XIcon className="size-4" />
+                </Button>
+              </div>
+              <p className="text-sm text-muted-foreground">
+                Help us build the future of open analytics
+              </p>
+            </div>
+
+            <div className="col gap-3">
+              {PERKS.map((perk) => (
+                <PerkPoint
+                  key={perk.text}
+                  icon={perk.icon}
+                  text={perk.text}
+                  description={perk.description}
+                />
+              ))}
+            </div>
+
+            <div className="pt-2">
+              <LinkButton
+                className="w-full"
+                href="https://buy.polar.sh/polar_cl_Az1CruNFzQB2bYdMOZmGHqTevW317knWqV44W1FqZmV"
+              >
+                Become a Supporter
+              </LinkButton>
+              <p className="text-xs text-muted-foreground text-center mt-4">
+                Starting at $20/month • Cancel anytime •{' '}
+                <a
+                  href="https://openpanel.dev/supporter"
+                  target="_blank"
+                  rel="noreferrer"
+                  className="text-primary underline-offset-4 hover:underline"
+                >
+                  Learn more
+                </a>
+              </p>
+            </div>
+          </div>
+        </motion.div>
+      )}
+    </AnimatePresence>
+  );
+}

apps/start/src/components/overview/overview-live-histogram.tsx

@@ -108,8 +108,8 @@ function Wrapper({ children, count, icons }: WrapperProps) {
   return (
     <div className="flex h-full flex-col">
       <div className="row gap-2 justify-between">
-        <div className="relative mb-1 text-sm font-medium text-muted-foreground">
-          {count} sessions last 30 minutes
+        <div className="relative mb-1 text-xs font-medium text-muted-foreground">
+          {count} sessions last 30 min
         </div>
         <div>{icons}</div>
       </div>

apps/start/src/components/overview/overview-metric-card.tsx

@@ -1,10 +1,17 @@
 import { fancyMinutes, useNumber } from '@/hooks/use-numer-formatter';
 import { cn } from '@/utils/cn';
 import AutoSizer from 'react-virtualized-auto-sizer';
-import { Area, AreaChart } from 'recharts';
+import { Area, AreaChart, Tooltip } from 'recharts';
 
 import { formatDate, timeAgo } from '@/utils/date';
+import { getChartColor } from '@/utils/theme';
 import { getPreviousMetric } from '@openpanel/common';
+import { useEffect, useRef, useState } from 'react';
+import {
+  ChartTooltipContainer,
+  ChartTooltipHeader,
+  ChartTooltipItem,
+} from '../charts/chart-tooltip';
 import {
   PreviousDiffIndicatorPure,
   getDiffIndicator,
@@ -17,12 +24,13 @@ interface MetricCardProps {
   data: {
     current: number;
     previous?: number;
+    date: string;
   }[];
   metric: {
     current: number;
     previous?: number | null;
   };
-  unit?: '' | 'date' | 'timeAgo' | 'min' | '%';
+  unit?: '' | 'date' | 'timeAgo' | 'min' | '%' | 'currency';
   label: string;
   onClick?: () => void;
   active?: boolean;
@@ -41,8 +49,28 @@ export function OverviewMetricCard({
   inverted = false,
   isLoading = false,
 }: MetricCardProps) {
+  const [currentIndex, setCurrentIndex] = useState<number | null>(null);
   const number = useNumber();
   const { current, previous } = metric;
+  const timer = useRef<NodeJS.Timeout | null>(null);
+
+  useEffect(() => {
+    if (timer.current) {
+      clearTimeout(timer.current);
+    }
+
+    if (currentIndex) {
+      timer.current = setTimeout(() => {
+        setCurrentIndex(null);
+      }, 1000);
+    }
+
+    return () => {
+      if (timer.current) {
+        clearTimeout(timer.current);
+      }
+    };
+  }, [currentIndex]);
 
   const renderValue = (value: number, unitClassName?: string, short = true) => {
     if (unit === 'date') {
@@ -57,6 +85,11 @@ export function OverviewMetricCard({
       return <>{fancyMinutes(value)}</>;
     }
 
+    if (unit === 'currency') {
+      // Revenue is stored in cents, convert to dollars
+      return <>{number.currency(value / 100)}</>;
+    }
+
     return (
       <>
         {short ? number.short(value) : number.format(value)}
@@ -73,19 +106,33 @@ export function OverviewMetricCard({
     '#93c5fd', // blue
   );
 
-  return (
-    <Tooltiper
-      content={
+  const renderTooltip = () => {
+    if (currentIndex) {
+      return (
         <span>
-          {label}:{' '}
+          {formatDate(new Date(data[currentIndex]?.date))}:{' '}
           <span className="font-semibold">
-            {renderValue(current, 'ml-1 font-light text-xl', false)}
+            {renderValue(
+              data[currentIndex].current,
+              'ml-1 font-light text-xl',
+              false,
+            )}
           </span>
         </span>
-      }
-      asChild
-      sideOffset={-20}
-    >
+      );
+    }
+
+    return (
+      <span>
+        {label}:{' '}
+        <span className="font-semibold">
+          {renderValue(metric.current, 'ml-1 font-light text-xl', false)}
+        </span>
+      </span>
+    );
+  };
+  return (
+    <Tooltiper content={renderTooltip()} asChild sideOffset={-20}>
       <button
         type="button"
         className={cn(
@@ -97,7 +144,7 @@ export function OverviewMetricCard({
         <div className={cn('group relative p-4')}>
           <div
             className={cn(
-              'pointer-events-none absolute -left-1 -right-1 bottom-0 top-0 z-0 opacity-50 transition-opacity duration-300 group-hover:opacity-100',
+              'absolute -left-1 -right-1 bottom-0 top-0 z-0 opacity-50 transition-opacity duration-300 group-hover:opacity-100',
             )}
           >
             <AutoSizer>
@@ -107,6 +154,9 @@ export function OverviewMetricCard({
                   height={height / 4}
                   data={data}
                   style={{ marginTop: (height / 4) * 3 }}
+                  onMouseMove={(event) => {
+                    setCurrentIndex(event.activeTooltipIndex ?? null);
+                  }}
                 >
                   <defs>
                     <linearGradient
@@ -128,6 +178,7 @@ export function OverviewMetricCard({
                       />
                     </linearGradient>
                   </defs>
+                  <Tooltip content={() => null} />
                   <Area
                     dataKey={'current'}
                     type="step"

apps/start/src/components/overview/overview-metrics.tsx

@@ -2,7 +2,6 @@ import { useOverviewOptions } from '@/components/overview/useOverviewOptions';
 import { useEventQueryFilters } from '@/hooks/use-event-query-filters';
 import { cn } from '@/utils/cn';
 
-import { useCookieStore } from '@/hooks/use-cookie-store';
 import { useDashedStroke } from '@/hooks/use-dashed-stroke';
 import { useFormatDateInterval } from '@/hooks/use-format-date-interval';
 import { useNumber } from '@/hooks/use-numer-formatter';
@@ -13,24 +12,22 @@ import { getPreviousMetric } from '@openpanel/common';
 import type { IInterval } from '@openpanel/validation';
 import { useQuery } from '@tanstack/react-query';
 import { isSameDay, isSameHour, isSameMonth, isSameWeek } from 'date-fns';
-import { last, omit } from 'ramda';
+import { last } from 'ramda';
 import React, { useState } from 'react';
 import {
+  Area,
   Bar,
-  BarChart,
   CartesianGrid,
+  Cell,
   ComposedChart,
   Customized,
   Line,
-  LineChart,
   ReferenceLine,
   ResponsiveContainer,
   XAxis,
   YAxis,
 } from 'recharts';
-import { useLocalStorage } from 'usehooks-ts';
 import { createChartTooltip } from '../charts/chart-tooltip';
-import { BarShapeBlue, BarShapeGrey } from '../charts/common-bar';
 import { useXAxisProps, useYAxisProps } from '../report-chart/common/axis';
 import { PreviousDiffIndicatorPure } from '../report-chart/common/previous-diff-indicator';
 import { Skeleton } from '../skeleton';
@@ -78,6 +75,12 @@ const TITLES = [
     unit: 'min',
     inverted: false,
   },
+  {
+    title: 'Revenue',
+    key: 'total_revenue',
+    unit: 'currency',
+    inverted: false,
+  },
 ] as const;
 
 export default function OverviewMetrics({ projectId }: OverviewMetricsProps) {
@@ -86,11 +89,6 @@ export default function OverviewMetrics({ projectId }: OverviewMetricsProps) {
   const [filters] = useEventQueryFilters();
   const trpc = useTRPC();
 
-  const [chartType, setChartType] = useCookieStore<'bars' | 'lines'>(
-    'chartType',
-    'bars',
-  );
-
   const activeMetric = TITLES[metric]!;
   const overviewQuery = useQuery(
     trpc.overview.stats.queryOptions({
@@ -125,6 +123,7 @@ export default function OverviewMetrics({ projectId }: OverviewMetricsProps) {
               }}
               unit={title.unit}
               data={data.map((item) => ({
+                date: item.date,
                 current: item[title.key],
                 previous: item[`prev_${title.key}`],
               }))}
@@ -136,7 +135,7 @@ export default function OverviewMetrics({ projectId }: OverviewMetricsProps) {
 
           <div
             className={cn(
-              'col-span-4 min-h-16 flex-1 p-4 pb-0 shadow-[0_0_0_0.5px] shadow-border max-md:row-start-1 md:col-span-2',
+              'col-span-4 min-h-16 flex-1 p-4 pb-0 shadow-[0_0_0_0.5px] shadow-border max-md:row-start-1 md:col-span-1',
             )}
           >
             <OverviewLiveHistogram projectId={projectId} />
@@ -148,32 +147,6 @@ export default function OverviewMetrics({ projectId }: OverviewMetricsProps) {
             <div className="text-sm font-medium text-muted-foreground">
               {activeMetric.title}
             </div>
-            <div className="flex items-center gap-1">
-              <button
-                type="button"
-                onClick={() => setChartType('bars')}
-                className={cn(
-                  'px-2 py-1 text-xs rounded transition-colors',
-                  chartType === 'bars'
-                    ? 'bg-primary text-primary-foreground'
-                    : 'text-muted-foreground hover:text-foreground',
-                )}
-              >
-                Bars
-              </button>
-              <button
-                type="button"
-                onClick={() => setChartType('lines')}
-                className={cn(
-                  'px-2 py-1 text-xs rounded transition-colors',
-                  chartType === 'lines'
-                    ? 'bg-primary text-primary-foreground'
-                    : 'text-muted-foreground hover:text-foreground',
-                )}
-              >
-                Lines
-              </button>
-            </div>
           </div>
           <div className="w-full h-[150px]">
             {overviewQuery.isLoading && <Skeleton className="h-full w-full" />}
@@ -181,7 +154,6 @@ export default function OverviewMetrics({ projectId }: OverviewMetricsProps) {
               activeMetric={activeMetric}
               interval={interval}
               data={data}
-              chartType={chartType}
               projectId={projectId}
             />
           </div>
@@ -194,18 +166,25 @@ export default function OverviewMetrics({ projectId }: OverviewMetricsProps) {
 const { Tooltip, TooltipProvider } = createChartTooltip<
   RouterOutputs['overview']['stats']['series'][number],
   {
+    anyMetric?: boolean;
     metric: (typeof TITLES)[number];
     interval: IInterval;
   }
->(({ context: { metric, interval }, data: dataArray }) => {
+>(({ context: { metric, interval, anyMetric }, data: dataArray }) => {
   const data = dataArray[0];
-  const formatDate = useFormatDateInterval(interval);
+  const formatDate = useFormatDateInterval({
+    interval,
+    short: false,
+  });
   const number = useNumber();
 
   if (!data) {
     return null;
   }
 
+  const revenue = data.total_revenue ?? 0;
+  const prevRevenue = data.prev_total_revenue ?? 0;
+
   return (
     <>
       <div className="flex justify-between gap-8 text-muted-foreground">
@@ -215,16 +194,25 @@ const { Tooltip, TooltipProvider } = createChartTooltip<
         <div className="flex gap-2">
           <div
             className="w-[3px] rounded-full"
-            style={{ background: getChartColor(0) }}
+            style={{ background: anyMetric ? getChartColor(0) : '#3ba974' }}
           />
           <div className="col flex-1 gap-1">
             <div className="flex items-center gap-1">{metric.title}</div>
             <div className="flex justify-between gap-8 font-mono font-medium">
               <div className="row gap-1">
-                {number.formatWithUnit(data[metric.key])}
+                {metric.unit === 'currency'
+                  ? number.currency((data[metric.key] ?? 0) / 100)
+                  : number.formatWithUnit(data[metric.key], metric.unit)}
                 {!!data[`prev_${metric.key}`] && (
                   <span className="text-muted-foreground">
-                    ({number.formatWithUnit(data[`prev_${metric.key}`])})
+                    (
+                    {metric.unit === 'currency'
+                      ? number.currency((data[`prev_${metric.key}`] ?? 0) / 100)
+                      : number.formatWithUnit(
+                          data[`prev_${metric.key}`],
+                          metric.unit,
+                        )}
+                    )
                   </span>
                 )}
               </div>
@@ -238,6 +226,32 @@ const { Tooltip, TooltipProvider } = createChartTooltip<
             </div>
           </div>
         </div>
+        {anyMetric && revenue > 0 && (
+          <div className="flex gap-2 mt-2">
+            <div
+              className="w-[3px] rounded-full"
+              style={{ background: '#3ba974' }}
+            />
+            <div className="col flex-1 gap-1">
+              <div className="flex items-center gap-1">Revenue</div>
+              <div className="flex justify-between gap-8 font-mono font-medium">
+                <div className="row gap-1">
+                  {number.currency(revenue / 100)}
+                  {prevRevenue > 0 && (
+                    <span className="text-muted-foreground">
+                      ({number.currency(prevRevenue / 100)})
+                    </span>
+                  )}
+                </div>
+                {prevRevenue > 0 && (
+                  <PreviousDiffIndicatorPure
+                    {...getPreviousMetric(revenue, prevRevenue)}
+                  />
+                )}
+              </div>
+            </div>
+          </div>
+        )}
       </React.Fragment>
     </>
   );
@@ -247,17 +261,19 @@ function Chart({
   activeMetric,
   interval,
   data,
-  chartType,
   projectId,
 }: {
   activeMetric: (typeof TITLES)[number];
   interval: IInterval;
   data: RouterOutputs['overview']['stats']['series'];
-  chartType: 'bars' | 'lines';
   projectId: string;
 }) {
   const xAxisProps = useXAxisProps({ interval });
   const yAxisProps = useYAxisProps();
+  const number = useNumber();
+  const revenueYAxisProps = useYAxisProps({
+    tickFormatter: (value) => number.short(value / 100),
+  });
   const [activeBar, setActiveBar] = useState(-1);
   const { range, startDate, endDate } = useOverviewOptions();
 
@@ -278,13 +294,11 @@ function Chart({
 
   // Line chart specific logic
   let dotIndex = undefined;
-  if (chartType === 'lines') {
-    if (interval === 'hour') {
-      // Find closest index based on times
-      dotIndex = data.findIndex((item) => {
-        return isSameHour(item.date, new Date());
-      });
-    }
+  if (interval === 'hour') {
+    // Find closest index based on times
+    dotIndex = data.findIndex((item) => {
+      return isSameHour(item.date, new Date());
+    });
   }
 
   const { calcStrokeDasharray, handleAnimationEnd, getStrokeDasharray } =
@@ -294,6 +308,10 @@ function Chart({
 
   const lastSerieDataItem = last(data)?.date || new Date();
   const useDashedLastLine = (() => {
+    if (range === 'today') {
+      return true;
+    }
+
     if (interval === 'hour') {
       return isSameHour(lastSerieDataItem, new Date());
     }
@@ -313,11 +331,11 @@ function Chart({
     return false;
   })();
 
-  if (chartType === 'lines') {
+  if (activeMetric.key === 'total_revenue') {
     return (
       <TooltipProvider metric={activeMetric} interval={interval}>
         <ResponsiveContainer width="100%" height="100%">
-          <LineChart data={data}>
+          <ComposedChart data={data}>
             <Customized component={calcStrokeDasharray} />
             <Line
               dataKey="calcStrokeDasharray"
@@ -326,13 +344,8 @@ function Chart({
               onAnimationEnd={handleAnimationEnd}
             />
             <Tooltip />
-            <YAxis
-              {...yAxisProps}
-              domain={[0, activeMetric.key === 'bounce_rate' ? 100 : 'dataMax']}
-              width={25}
-            />
+            <YAxis {...yAxisProps} domain={[0, 'dataMax']} width={25} />
             <XAxis {...xAxisProps} />
-
             <CartesianGrid
               strokeDasharray="3 3"
               horizontal={true}
@@ -340,10 +353,30 @@ function Chart({
               className="stroke-border"
             />
 
+            <defs>
+              <filter
+                id="rainbow-line-glow"
+                x="-20%"
+                y="-20%"
+                width="140%"
+                height="140%"
+              >
+                <feGaussianBlur stdDeviation="5" result="blur" />
+                <feComponentTransfer in="blur" result="dimmedBlur">
+                  <feFuncA type="linear" slope="0.5" />
+                </feComponentTransfer>
+                <feComposite
+                  in="SourceGraphic"
+                  in2="dimmedBlur"
+                  operator="over"
+                />
+              </filter>
+            </defs>
+
             <Line
-              key={`prev_${activeMetric.key}`}
-              type="linear"
-              dataKey={`prev_${activeMetric.key}`}
+              key={'prev_total_revenue'}
+              type="monotone"
+              dataKey={'prev_total_revenue'}
               stroke={'oklch(from var(--foreground) l c h / 0.1)'}
               strokeWidth={2}
               isAnimationActive={false}
@@ -352,24 +385,26 @@ function Chart({
                   ? false
                   : {
                       stroke: 'oklch(from var(--foreground) l c h / 0.1)',
-                      fill: 'var(--def-100)',
+                      fill: 'transparent',
                       strokeWidth: 1.5,
                       r: 2,
                     }
               }
               activeDot={{
                 stroke: 'oklch(from var(--foreground) l c h / 0.2)',
-                fill: 'var(--def-100)',
+                fill: 'transparent',
                 strokeWidth: 1.5,
                 r: 3,
               }}
             />
 
-            <Line
-              key={activeMetric.key}
-              type="linear"
-              dataKey={activeMetric.key}
-              stroke={getChartColor(0)}
+            <Area
+              key={'total_revenue'}
+              type="monotone"
+              dataKey={'total_revenue'}
+              stroke={'#3ba974'}
+              fill={'#3ba974'}
+              fillOpacity={0.05}
               strokeWidth={2}
               strokeDasharray={
                 useDashedLastLine
@@ -381,18 +416,19 @@ function Chart({
                 data.length > 90
                   ? false
                   : {
-                      stroke: getChartColor(0),
-                      fill: 'var(--def-100)',
+                      stroke: '#3ba974',
+                      fill: '#3ba974',
                       strokeWidth: 1.5,
                       r: 3,
                     }
               }
               activeDot={{
-                stroke: getChartColor(0),
+                stroke: '#3ba974',
                 fill: 'var(--def-100)',
                 strokeWidth: 2,
                 r: 4,
               }}
+              filter="url(#rainbow-line-glow)"
             />
 
             {references.data?.map((ref) => (
@@ -410,36 +446,48 @@ function Chart({
                 fontSize={10}
               />
             ))}
-          </LineChart>
+          </ComposedChart>
         </ResponsiveContainer>
       </TooltipProvider>
     );
   }
 
-  // Bar chart (default)
   return (
-    <TooltipProvider metric={activeMetric} interval={interval}>
+    <TooltipProvider metric={activeMetric} interval={interval} anyMetric={true}>
       <ResponsiveContainer width="100%" height="100%">
-        <BarChart
+        <ComposedChart
           data={data}
-          margin={{ top: 0, right: 0, left: 0, bottom: 10 }}
           onMouseMove={(e) => {
             setActiveBar(e.activeTooltipIndex ?? -1);
           }}
-          barCategoryGap={2}
         >
-          <Tooltip
-            cursor={{
-              stroke: 'var(--def-200)',
-              fill: 'var(--def-200)',
-            }}
+          <Customized component={calcStrokeDasharray} />
+          <Line
+            dataKey="calcStrokeDasharray"
+            legendType="none"
+            animationDuration={0}
+            onAnimationEnd={handleAnimationEnd}
           />
+          <Tooltip />
           <YAxis
             {...yAxisProps}
-            domain={[0, activeMetric.key === 'bounce_rate' ? 100 : 'auto']}
+            domain={[0, activeMetric.key === 'bounce_rate' ? 100 : 'dataMax']}
             width={25}
           />
-          <XAxis {...omit(['scale', 'type'], xAxisProps)} />
+          <YAxis
+            {...revenueYAxisProps}
+            yAxisId="right"
+            orientation="right"
+            domain={[
+              0,
+              data.reduce(
+                (max, item) => Math.max(max, item.total_revenue ?? 0),
+                0,
+              ) * 2,
+            ]}
+            width={30}
+          />
+          <XAxis {...xAxisProps} />
 
           <CartesianGrid
             strokeDasharray="3 3"
@@ -448,21 +496,103 @@ function Chart({
             className="stroke-border"
           />
 
-          <Bar
+          <defs>
+            <filter
+              id="rainbow-line-glow"
+              x="-20%"
+              y="-20%"
+              width="140%"
+              height="140%"
+            >
+              <feGaussianBlur stdDeviation="5" result="blur" />
+              <feComponentTransfer in="blur" result="dimmedBlur">
+                <feFuncA type="linear" slope="0.5" />
+              </feComponentTransfer>
+              <feComposite
+                in="SourceGraphic"
+                in2="dimmedBlur"
+                operator="over"
+              />
+            </filter>
+          </defs>
+
+          <Line
             key={`prev_${activeMetric.key}`}
+            type="monotone"
             dataKey={`prev_${activeMetric.key}`}
+            stroke={'oklch(from var(--foreground) l c h / 0.1)'}
+            strokeWidth={2}
             isAnimationActive={false}
-            shape={(props: any) => (
-              <BarShapeGrey isActive={activeBar === props.index} {...props} />
-            )}
+            dot={
+              data.length > 90
+                ? false
+                : {
+                    stroke: 'oklch(from var(--foreground) l c h / 0.1)',
+                    fill: 'transparent',
+                    strokeWidth: 1.5,
+                    r: 2,
+                  }
+            }
+            activeDot={{
+              stroke: 'oklch(from var(--foreground) l c h / 0.2)',
+              fill: 'transparent',
+              strokeWidth: 1.5,
+              r: 3,
+            }}
           />
           <Bar
-            key={activeMetric.key}
-            dataKey={activeMetric.key}
+            key="total_revenue"
+            dataKey="total_revenue"
+            yAxisId="right"
+            stackId="revenue"
             isAnimationActive={false}
-            shape={(props: any) => (
-              <BarShapeBlue isActive={activeBar === props.index} {...props} />
-            )}
+            radius={5}
+            maxBarSize={20}
+          >
+            {data.map((item, index) => {
+              return (
+                <Cell
+                  key={item.date}
+                  className={cn(
+                    index === activeBar
+                      ? 'fill-emerald-700/100'
+                      : 'fill-emerald-700/80',
+                  )}
+                />
+              );
+            })}
+          </Bar>
+          <Area
+            key={activeMetric.key}
+            type="monotone"
+            dataKey={activeMetric.key}
+            stroke={getChartColor(0)}
+            fill={getChartColor(0)}
+            fillOpacity={0.05}
+            strokeWidth={2}
+            strokeDasharray={
+              useDashedLastLine
+                ? getStrokeDasharray(activeMetric.key)
+                : undefined
+            }
+            isAnimationActive={false}
+            dot={
+              data.length > 90
+                ? false
+                : {
+                    stroke: getChartColor(0),
+                    fill: 'transparent',
+                    strokeWidth: 1.5,
+                    r: 3,
+                  }
+            }
+            activeDot={{
+              stroke: getChartColor(0),
+              fill: 'var(--def-100)',
+              strokeWidth: 2,
+              r: 4,
+            }}
+            filter="url(#rainbow-line-glow)"
           />
 
           {references.data?.map((ref) => (
@@ -480,7 +610,7 @@ function Chart({
               fontSize={10}
             />
           ))}
-        </BarChart>
+        </ComposedChart>
       </ResponsiveContainer>
     </TooltipProvider>
   );

apps/start/src/components/overview/overview-top-devices.tsx

@@ -45,8 +45,9 @@ export default function OverviewTopDevices({
           projectId,
           startDate,
           endDate,
-          events: [
+          series: [
             {
+              type: 'event',
               segment: 'user',
               filters,
               id: 'A',
@@ -81,8 +82,9 @@ export default function OverviewTopDevices({
           projectId,
           startDate,
           endDate,
-          events: [
+          series: [
             {
+              type: 'event',
               segment: 'user',
               filters,
               id: 'A',
@@ -120,8 +122,9 @@ export default function OverviewTopDevices({
           projectId,
           startDate,
           endDate,
-          events: [
+          series: [
             {
+              type: 'event',
               segment: 'user',
               filters,
               id: 'A',
@@ -160,8 +163,9 @@ export default function OverviewTopDevices({
           projectId,
           startDate,
           endDate,
-          events: [
+          series: [
             {
+              type: 'event',
               segment: 'user',
               filters,
               id: 'A',
@@ -199,8 +203,9 @@ export default function OverviewTopDevices({
           projectId,
           startDate,
           endDate,
-          events: [
+          series: [
             {
+              type: 'event',
               segment: 'user',
               filters,
               id: 'A',
@@ -239,8 +244,9 @@ export default function OverviewTopDevices({
           projectId,
           startDate,
           endDate,
-          events: [
+          series: [
             {
+              type: 'event',
               segment: 'user',
               filters,
               id: 'A',
@@ -278,8 +284,9 @@ export default function OverviewTopDevices({
           projectId,
           startDate,
           endDate,
-          events: [
+          series: [
             {
+              type: 'event',
               segment: 'user',
               filters,
               id: 'A',

apps/start/src/components/overview/overview-top-events.tsx

@@ -37,8 +37,9 @@ export default function OverviewTopEvents({
           projectId,
           startDate,
           endDate,
-          events: [
+          series: [
             {
+              type: 'event',
               segment: 'event',
               filters: [
                 ...filters,
@@ -78,8 +79,9 @@ export default function OverviewTopEvents({
           projectId,
           startDate,
           endDate,
-          events: [
+          series: [
             {
+              type: 'event',
               segment: 'event',
               filters: [...filters],
               id: 'A',
@@ -112,8 +114,9 @@ export default function OverviewTopEvents({
           projectId,
           startDate,
           endDate,
-          events: [
+          series: [
             {
+              type: 'event',
               segment: 'event',
               filters: [
                 ...filters,

apps/start/src/components/overview/overview-top-geo.tsx

@@ -146,8 +146,9 @@ export default function OverviewTopGeo({ projectId }: OverviewTopGeoProps) {
               projectId,
               startDate,
               endDate,
-              events: [
+              series: [
                 {
+                  type: 'event',
                   segment: 'event',
                   filters,
                   id: 'A',

apps/start/src/components/overview/overview-widget-table.tsx

@@ -8,6 +8,43 @@ import { Skeleton } from '../skeleton';
 import { Tooltiper } from '../ui/tooltip';
 import { WidgetTable, type Props as WidgetTableProps } from '../widget-table';
 
+function RevenuePieChart({ percentage }: { percentage: number }) {
+  const size = 16;
+  const strokeWidth = 2;
+  const radius = (size - strokeWidth) / 2;
+  const circumference = 2 * Math.PI * radius;
+  const offset = circumference - percentage * circumference;
+
+  return (
+    <svg width={size} height={size} className="flex-shrink-0">
+      {/* Background circle */}
+      <circle
+        cx={size / 2}
+        cy={size / 2}
+        r={radius}
+        fill="none"
+        stroke="currentColor"
+        strokeWidth={strokeWidth}
+        className="text-def-200"
+      />
+      {/* Revenue arc */}
+      <circle
+        cx={size / 2}
+        cy={size / 2}
+        r={radius}
+        fill="none"
+        stroke="#3ba974"
+        strokeWidth={strokeWidth}
+        strokeDasharray={circumference}
+        strokeDashoffset={offset}
+        strokeLinecap="round"
+        transform={`rotate(-90 ${size / 2} ${size / 2})`}
+        className="transition-all"
+      />
+    </svg>
+  );
+}
+
 type Props<T> = WidgetTableProps<T> & {
   getColumnPercentage: (item: T) => number;
 };
@@ -45,9 +82,7 @@ export const OverviewWidgetTable = <T,>({
               index === 0
                 ? 'text-left w-full font-medium min-w-0'
                 : 'text-right font-mono',
-              index !== 0 &&
-                index !== columns.length - 1 &&
-                'hidden @[310px]:table-cell',
+              // Remove old responsive logic - now handled by responsive prop
               column.className,
             ),
           };
@@ -119,12 +154,15 @@ export function OverviewWidgetTablePages({
     avg_duration: number;
     bounce_rate: number;
     sessions: number;
+    revenue: number;
   }[];
   showDomain?: boolean;
 }) {
   const [_filters, setFilter] = useEventQueryFilters();
   const number = useNumber();
   const maxSessions = Math.max(...data.map((item) => item.sessions));
+  const totalRevenue = data.reduce((sum, item) => sum + item.revenue, 0);
+  const hasRevenue = data.some((item) => item.revenue > 0);
   return (
     <OverviewWidgetTable
       className={className}
@@ -135,6 +173,7 @@ export function OverviewWidgetTablePages({
         {
           name: 'Path',
           width: 'w-full',
+          responsive: { priority: 1 }, // Always visible
           render(item) {
             return (
               <Tooltiper asChild content={item.origin + item.path} side="left">
@@ -178,6 +217,7 @@ export function OverviewWidgetTablePages({
         {
           name: 'BR',
           width: '60px',
+          responsive: { priority: 6 }, // Hidden when space is tight
           render(item) {
             return number.shortWithUnit(item.bounce_rate, '%');
           },
@@ -185,13 +225,41 @@ export function OverviewWidgetTablePages({
         {
           name: 'Duration',
           width: '75px',
+          responsive: { priority: 7 }, // Hidden when space is tight
           render(item) {
             return number.shortWithUnit(item.avg_duration, 'min');
           },
         },
+        ...(hasRevenue
+          ? [
+              {
+                name: 'Revenue',
+                width: '100px',
+                responsive: { priority: 3 }, // Always show if possible
+                render(item: (typeof data)[number]) {
+                  const revenuePercentage =
+                    totalRevenue > 0 ? item.revenue / totalRevenue : 0;
+                  return (
+                    <div className="row gap-2 items-center justify-end">
+                      <span
+                        className="font-semibold"
+                        style={{ color: '#3ba974' }}
+                      >
+                        {item.revenue > 0
+                          ? number.currency(item.revenue / 100)
+                          : '-'}
+                      </span>
+                      <RevenuePieChart percentage={revenuePercentage} />
+                    </div>
+                  );
+                },
+              } as const,
+            ]
+          : []),
         {
           name: lastColumnName,
           width: '84px',
+          responsive: { priority: 2 }, // Always show if possible
           render(item) {
             return (
               <div className="row gap-2 justify-end">
@@ -303,20 +371,24 @@ export function OverviewWidgetTableGeneric({
 }) {
   const number = useNumber();
   const maxSessions = Math.max(...data.map((item) => item.sessions));
+  const totalRevenue = data.reduce((sum, item) => sum + (item.revenue ?? 0), 0);
+  const hasRevenue = data.some((item) => (item.revenue ?? 0) > 0);
   return (
     <OverviewWidgetTable
       className={className}
       data={data ?? []}
-      keyExtractor={(item) => item.name}
+      keyExtractor={(item) => item.prefix + item.name}
       getColumnPercentage={(item) => item.sessions / maxSessions}
       columns={[
         {
           ...column,
           width: 'w-full',
+          responsive: { priority: 1 }, // Always visible
         },
         {
           name: 'BR',
           width: '60px',
+          responsive: { priority: 6 }, // Hidden when space is tight
           render(item) {
             return number.shortWithUnit(item.bounce_rate, '%');
           },
@@ -327,9 +399,38 @@ export function OverviewWidgetTableGeneric({
         //     return number.shortWithUnit(item.avg_session_duration, 'min');
         //   },
         // },
+
+        ...(hasRevenue
+          ? [
+              {
+                name: 'Revenue',
+                width: '100px',
+                responsive: { priority: 3 }, // Always show if possible
+                render(item: RouterOutputs['overview']['topGeneric'][number]) {
+                  const revenue = item.revenue ?? 0;
+                  const revenuePercentage =
+                    totalRevenue > 0 ? revenue / totalRevenue : 0;
+                  return (
+                    <div className="row gap-2 items-center justify-end">
+                      <span
+                        className="font-semibold"
+                        style={{ color: '#3ba974' }}
+                      >
+                        {revenue > 0
+                          ? number.currency(revenue / 100, { short: true })
+                          : '-'}
+                      </span>
+                      <RevenuePieChart percentage={revenuePercentage} />
+                    </div>
+                  );
+                },
+              } as const,
+            ]
+          : []),
         {
           name: 'Sessions',
           width: '84px',
+          responsive: { priority: 2 }, // Always show if possible
           render(item) {
             return (
               <div className="row gap-2 justify-end">

apps/start/src/components/profiles/profile-charts.tsx

@@ -15,8 +15,9 @@ export const ProfileCharts = memo(
     const pageViewsChart: IChartProps = {
       projectId,
       chartType: 'linear',
-      events: [
+      series: [
         {
+          type: 'event',
           segment: 'event',
           filters: [
             {
@@ -48,8 +49,9 @@ export const ProfileCharts = memo(
     const eventsChart: IChartProps = {
       projectId,
       chartType: 'linear',
-      events: [
+      series: [
         {
+          type: 'event',
           segment: 'event',
           filters: [
             {

apps/start/src/components/profiles/profile-metrics.tsx

@@ -12,72 +12,91 @@ const PROFILE_METRICS = [
     key: 'totalEvents',
     unit: '',
     inverted: false,
+    hideOnZero: false,
   },
   {
     title: 'Sessions',
     key: 'sessions',
     unit: '',
     inverted: false,
+    hideOnZero: false,
   },
   {
     title: 'Page Views',
     key: 'screenViews',
     unit: '',
     inverted: false,
+    hideOnZero: false,
   },
   {
     title: 'Avg Events/Session',
     key: 'avgEventsPerSession',
     unit: '',
     inverted: false,
+    hideOnZero: false,
   },
   {
     title: 'Bounce Rate',
     key: 'bounceRate',
     unit: '%',
     inverted: true,
+    hideOnZero: false,
   },
   {
     title: 'Session Duration (Avg)',
     key: 'durationAvg',
     unit: 'min',
     inverted: false,
+    hideOnZero: false,
   },
   {
     title: 'Session Duration (P90)',
     key: 'durationP90',
     unit: 'min',
     inverted: false,
+    hideOnZero: false,
   },
   {
     title: 'First seen',
     key: 'firstSeen',
     unit: 'timeAgo',
     inverted: false,
+    hideOnZero: false,
   },
   {
     title: 'Last seen',
     key: 'lastSeen',
     unit: 'timeAgo',
     inverted: false,
+    hideOnZero: false,
   },
   {
     title: 'Days Active',
     key: 'uniqueDaysActive',
     unit: '',
     inverted: false,
+    hideOnZero: false,
   },
   {
     title: 'Conversion Events',
     key: 'conversionEvents',
     unit: '',
     inverted: false,
+    hideOnZero: false,
   },
   {
     title: 'Avg Time Between Sessions (h)',
     key: 'avgTimeBetweenSessions',
     unit: 'min',
     inverted: false,
+    hideOnZero: false,
+  },
+  {
+    title: 'Revenue',
+    key: 'revenue',
+    unit: 'currency',
+    inverted: false,
+    hideOnZero: true,
   },
 ] as const;
 
@@ -85,7 +104,12 @@ export const ProfileMetrics = ({ data }: Props) => {
   return (
     <div className="relative col-span-6 -m-4 mb-0 mt-0 md:m-0">
       <div className="card grid grid-cols-2 overflow-hidden rounded-md md:grid-cols-4 lg:grid-cols-6">
-        {PROFILE_METRICS.map((metric) => (
+        {PROFILE_METRICS.filter((metric) => {
+          if (metric.hideOnZero && data[metric.key] === 0) {
+            return false;
+          }
+          return true;
+        }).map((metric) => (
           <OverviewMetricCard
             key={metric.key}
             id={metric.key}

apps/start/src/components/projects/project-card.tsx

@@ -1,4 +1,4 @@
-import { shortNumber } from '@/hooks/use-numer-formatter';
+import { useNumber } from '@/hooks/use-numer-formatter';
 import { useTRPC } from '@/integrations/trpc/react';
 import { useQuery } from '@tanstack/react-query';
 import { Link } from '@tanstack/react-router';
@@ -7,11 +7,11 @@ import type { IServiceProject } from '@openpanel/db';
 
 import { cn } from '@/utils/cn';
 import { SettingsIcon, TrendingDownIcon, TrendingUpIcon } from 'lucide-react';
-import { ChartSSR } from '../chart-ssr';
 import { FadeIn } from '../fade-in';
 import { SerieIcon } from '../report-chart/common/serie-icon';
 import { Skeleton } from '../skeleton';
 import { LinkButton } from '../ui/button';
+import { ProjectChart } from './project-chart';
 
 export function ProjectCardRoot({
   children,
@@ -60,7 +60,7 @@ function ProjectCard({ id, domain, name, organizationId }: IServiceProject) {
           </div>
         </div>
         <div className="-mx-4 aspect-[8/1] mb-4">
-          <ProjectChart id={id} />
+          <ProjectChartOuter id={id} />
         </div>
         <div className="flex flex-1 gap-4 h-9 md:h-4">
           <ProjectMetrics id={id} />
@@ -77,7 +77,7 @@ function ProjectCard({ id, domain, name, organizationId }: IServiceProject) {
   );
 }
 
-function ProjectChart({ id }: { id: string }) {
+function ProjectChartOuter({ id }: { id: string }) {
   const trpc = useTRPC();
   const { data } = useQuery(
     trpc.chart.projectCard.queryOptions({
@@ -87,7 +87,7 @@ function ProjectChart({ id }: { id: string }) {
 
   return (
     <FadeIn className="h-full w-full">
-      <ChartSSR data={data?.chart || []} color={'blue'} />
+      <ProjectChart data={data?.chart || []} color={'blue'} />
     </FadeIn>
   );
 }
@@ -102,6 +102,7 @@ function Metric({ value, label }: { value: React.ReactNode; label: string }) {
 }
 
 function ProjectMetrics({ id }: { id: string }) {
+  const number = useNumber();
   const trpc = useTRPC();
   const { data } = useQuery(
     trpc.chart.projectCard.queryOptions({
@@ -138,16 +139,18 @@ function ProjectMetrics({ id }: { id: string }) {
             }
           />
         )}
+        {!!data?.metrics?.revenue && (
+          <Metric
+            label="Revenue"
+            value={number.currency(data?.metrics?.revenue / 100, {
+              short: true,
+            })}
+          />
+        )}
       </div>
-      <Metric
-        label="3M"
-        value={shortNumber('en')(data?.metrics?.months_3 ?? 0)}
-      />
-      <Metric
-        label="30D"
-        value={shortNumber('en')(data?.metrics?.month ?? 0)}
-      />
-      <Metric label="24H" value={shortNumber('en')(data?.metrics?.day ?? 0)} />
+      <Metric label="3M" value={number.short(data?.metrics?.months_3 ?? 0)} />
+      <Metric label="30D" value={number.short(data?.metrics?.month ?? 0)} />
+      <Metric label="24H" value={number.short(data?.metrics?.day ?? 0)} />
     </FadeIn>
   );
 }

apps/start/src/components/projects/project-chart.tsx

@@ -0,0 +1,215 @@
+import {
+  ChartTooltipHeader,
+  ChartTooltipItem,
+  createChartTooltip,
+} from '@/components/charts/chart-tooltip';
+import { useNumber } from '@/hooks/use-numer-formatter';
+import { cn } from '@/utils/cn';
+import { getChartColor } from '@/utils/theme';
+import { useState } from 'react';
+import {
+  Bar,
+  Cell,
+  ComposedChart,
+  Line,
+  ResponsiveContainer,
+  XAxis,
+  YAxis,
+} from 'recharts';
+
+type ChartDataItem = {
+  value: number;
+  date: Date;
+  revenue: number;
+  timestamp: number;
+};
+
+const { Tooltip, TooltipProvider } = createChartTooltip<
+  ChartDataItem,
+  {
+    color: 'blue' | 'green' | 'red';
+  }
+>(
+  ({
+    context,
+    data: dataArray,
+  }: {
+    context: { color: 'blue' | 'green' | 'red' };
+    data: ChartDataItem[];
+  }) => {
+    const { color } = context;
+    const data = dataArray[0];
+    const number = useNumber();
+
+    if (!data) {
+      return null;
+    }
+
+    const getColorValue = () => {
+      if (color === 'green') return '#16a34a';
+      if (color === 'red') return '#dc2626';
+      return getChartColor(0);
+    };
+
+    const formatDate = (date: Date) => {
+      return new Intl.DateTimeFormat('en-GB', {
+        weekday: 'short',
+        day: '2-digit',
+        month: 'short',
+      }).format(date);
+    };
+
+    return (
+      <>
+        <ChartTooltipHeader>
+          <div className="text-muted-foreground">{formatDate(data.date)}</div>
+        </ChartTooltipHeader>
+        <ChartTooltipItem
+          color={getColorValue()}
+          innerClassName="row justify-between"
+        >
+          <div className="flex items-center gap-1">Sessions</div>
+          <div className="font-mono font-bold">{number.format(data.value)}</div>
+        </ChartTooltipItem>
+        {data.revenue > 0 && (
+          <ChartTooltipItem color="#3ba974">
+            <div className="flex items-center gap-1">Revenue</div>
+            <div className="font-mono font-medium">
+              {number.currency(data.revenue / 100)}
+            </div>
+          </ChartTooltipItem>
+        )}
+      </>
+    );
+  },
+);
+
+export function ProjectChart({
+  data,
+  dots = false,
+  color = 'blue',
+}: {
+  dots?: boolean;
+  color?: 'blue' | 'green' | 'red';
+  data: { value: number; date: Date; revenue: number }[];
+}) {
+  const [activeBar, setActiveBar] = useState(-1);
+
+  if (data.length === 0) {
+    return null;
+  }
+
+  // Transform data for Recharts (needs timestamp for time-based x-axis)
+  const chartData = data.map((item) => ({
+    ...item,
+    timestamp: item.date.getTime(),
+  }));
+
+  const maxValue = Math.max(...data.map((d) => d.value), 0);
+  const maxRevenue = Math.max(...data.map((d) => d.revenue), 0);
+
+  const getColorValue = () => {
+    if (color === 'green') return '#16a34a';
+    if (color === 'red') return '#dc2626';
+    return getChartColor(0);
+  };
+
+  return (
+    <div className="relative h-full w-full">
+      <TooltipProvider color={color}>
+        <ResponsiveContainer width="100%" height="100%">
+          <ComposedChart
+            data={chartData}
+            margin={{ top: 10, right: 10, bottom: 10, left: 10 }}
+            onMouseMove={(e) => {
+              setActiveBar(e.activeTooltipIndex ?? -1);
+            }}
+          >
+            <XAxis
+              dataKey="timestamp"
+              type="number"
+              scale="time"
+              domain={['dataMin', 'dataMax']}
+              hide
+            />
+            <YAxis domain={[0, maxValue || 'dataMax']} hide width={0} />
+            <YAxis
+              yAxisId="right"
+              orientation="right"
+              domain={[0, maxRevenue * 2 || 'dataMax']}
+              hide
+              width={0}
+            />
+
+            <Tooltip />
+
+            <defs>
+              <filter
+                id="rainbow-line-glow"
+                x="-20%"
+                y="-20%"
+                width="140%"
+                height="140%"
+              >
+                <feGaussianBlur stdDeviation="5" result="blur" />
+                <feComponentTransfer in="blur" result="dimmedBlur">
+                  <feFuncA type="linear" slope="0.5" />
+                </feComponentTransfer>
+                <feComposite
+                  in="SourceGraphic"
+                  in2="dimmedBlur"
+                  operator="over"
+                />
+              </filter>
+            </defs>
+
+            <Line
+              type="monotone"
+              dataKey="value"
+              stroke={getColorValue()}
+              strokeWidth={2}
+              isAnimationActive={false}
+              dot={
+                dots && data.length <= 90
+                  ? {
+                      stroke: getColorValue(),
+                      fill: 'transparent',
+                      strokeWidth: 1.5,
+                      r: 3,
+                    }
+                  : false
+              }
+              activeDot={{
+                stroke: getColorValue(),
+                fill: 'var(--def-100)',
+                strokeWidth: 2,
+                r: 4,
+              }}
+              filter="url(#rainbow-line-glow)"
+            />
+
+            <Bar
+              dataKey="revenue"
+              yAxisId="right"
+              stackId="revenue"
+              isAnimationActive={false}
+              radius={5}
+              maxBarSize={20}
+            >
+              {chartData.map((item, index) => (
+                <Cell
+                  key={item.timestamp}
+                  className={cn(
+                    index === activeBar
+                      ? 'fill-emerald-700/100'
+                      : 'fill-emerald-700/80',
+                  )}
+                />
+              ))}
+            </Bar>
+          </ComposedChart>
+        </ResponsiveContainer>
+      </TooltipProvider>
+    </div>
+  );
+}

apps/start/src/components/realtime/realtime-geo.tsx

@@ -75,7 +75,7 @@ export function RealtimeGeo({ projectId }: RealtimeGeoProps) {
           },
           {
             name: 'Events',
-            width: '84px',
+            width: '60px',
             render(item) {
               return (
                 <div className="row gap-2 justify-end">
@@ -86,6 +86,19 @@ export function RealtimeGeo({ projectId }: RealtimeGeoProps) {
               );
             },
           },
+          {
+            name: 'Sessions',
+            width: '82px',
+            render(item) {
+              return (
+                <div className="row gap-2 justify-end">
+                  <span className="font-semibold">
+                    {number.short(item.unique_sessions)}
+                  </span>
+                </div>
+              );
+            },
+          },
         ]}
       />
     </div>

apps/start/src/components/realtime/realtime-live-histogram.tsx

@@ -1,126 +1,99 @@
-import {
-  Tooltip,
-  TooltipContent,
-  TooltipTrigger,
-} from '@/components/ui/tooltip';
 import { useTRPC } from '@/integrations/trpc/react';
-import { cn } from '@/utils/cn';
 import { useQuery } from '@tanstack/react-query';
 
-import type { IChartProps } from '@openpanel/validation';
+import { useNumber } from '@/hooks/use-numer-formatter';
+import { getChartColor } from '@/utils/theme';
+import * as Portal from '@radix-ui/react-portal';
+import { bind } from 'bind-event-listener';
+import throttle from 'lodash.throttle';
+import React, { useEffect, useState } from 'react';
+import {
+  Bar,
+  BarChart,
+  ResponsiveContainer,
+  Tooltip,
+  XAxis,
+  YAxis,
+} from 'recharts';
 import { AnimatedNumber } from '../animated-number';
+import { BarShapeBlue } from '../charts/common-bar';
+import { SerieIcon } from '../report-chart/common/serie-icon';
 
 interface RealtimeLiveHistogramProps {
   projectId: string;
 }
 
-export const getReport = (projectId: string): IChartProps => {
-  return {
-    projectId,
-    events: [
-      {
-        segment: 'user',
-        filters: [],
-        name: '*',
-        displayName: 'Active users',
-      },
-    ],
-    chartType: 'histogram',
-    interval: 'minute',
-    range: '30min',
-    name: '',
-    metric: 'sum',
-    breakdowns: [],
-    lineType: 'monotone',
-    previous: false,
-  };
-};
-
-export const getCountReport = (projectId: string): IChartProps => {
-  return {
-    name: '',
-    projectId,
-    events: [
-      {
-        segment: 'user',
-        filters: [],
-        id: 'A',
-        name: 'session_start',
-      },
-    ],
-    breakdowns: [],
-    chartType: 'metric',
-    lineType: 'monotone',
-    interval: 'minute',
-    range: '30min',
-    previous: false,
-    metric: 'sum',
-  };
-};
-
 export function RealtimeLiveHistogram({
   projectId,
 }: RealtimeLiveHistogramProps) {
-  const report = getReport(projectId);
-  const countReport = getCountReport(projectId);
-
   const trpc = useTRPC();
-  const res = useQuery(trpc.chart.chart.queryOptions(report));
-  const countRes = useQuery(trpc.chart.chart.queryOptions(countReport));
 
-  const metrics = res.data?.series[0]?.metrics;
-  const minutes = (res.data?.series[0]?.data || []).slice(-30);
-  const liveCount = countRes.data?.series[0]?.metrics?.sum ?? 0;
+  // Use the same liveData endpoint as overview
+  const { data: liveData, isLoading } = useQuery(
+    trpc.overview.liveData.queryOptions({ projectId }),
+  );
 
-  if (res.isInitialLoading || countRes.isInitialLoading || liveCount === 0) {
-    const staticArray = [
-      10, 25, 30, 45, 20, 5, 55, 18, 40, 12, 50, 35, 8, 22, 38, 42, 15, 28, 52,
-      5, 48, 14, 32, 58, 7, 19, 33, 56, 24, 5,
-    ];
+  const chartData = liveData?.minuteCounts ?? [];
+  // Calculate total unique visitors (sum of unique visitors per minute)
+  // Note: This is an approximation - ideally we'd want unique visitors across all minutes
+  const totalVisitors = liveData?.totalSessions ?? 0;
 
+  if (isLoading) {
     return (
       <Wrapper count={0}>
-        {staticArray.map((percent, i) => (
-          <div
-            key={i as number}
-            className="flex-1 animate-pulse rounded-sm bg-def-200"
-            style={{ height: `${percent}%` }}
-          />
-        ))}
+        <div className="h-full w-full animate-pulse bg-def-200 rounded" />
       </Wrapper>
     );
   }
 
-  if (!res.isSuccess && !countRes.isSuccess) {
+  if (!liveData) {
     return null;
   }
 
+  const maxDomain =
+    Math.max(...chartData.map((item) => item.visitorCount), 0) * 1.2 || 1;
+
   return (
-    <Wrapper count={liveCount}>
-      {minutes.map((minute) => {
-        return (
-          <Tooltip key={minute.date}>
-            <TooltipTrigger asChild>
+    <Wrapper
+      count={totalVisitors}
+      icons={
+        liveData.referrers && liveData.referrers.length > 0 ? (
+          <div className="row gap-2">
+            {liveData.referrers.slice(0, 3).map((ref, index) => (
               <div
-                className={cn(
-                  'flex-1 rounded-sm transition-all ease-in-out hover:scale-110',
-                  minute.count === 0 ? 'bg-def-200' : 'bg-highlight',
-                )}
-                style={{
-                  height:
-                    minute.count === 0
-                      ? '20%'
-                      : `${(minute.count / metrics!.max) * 100}%`,
-                }}
-              />
-            </TooltipTrigger>
-            <TooltipContent side="top">
-              <div>{minute.count} active users</div>
-              <div>@ {new Date(minute.date).toLocaleTimeString()}</div>
-            </TooltipContent>
-          </Tooltip>
-        );
-      })}
+                key={`${ref.referrer}-${ref.count}-${index}`}
+                className="font-bold text-xs row gap-1 items-center"
+              >
+                <SerieIcon name={ref.referrer} />
+                <span>{ref.count}</span>
+              </div>
+            ))}
+          </div>
+        ) : null
+      }
+    >
+      <ResponsiveContainer width="100%" height="100%">
+        <BarChart
+          data={chartData}
+          margin={{ top: 0, right: 0, left: 0, bottom: 0 }}
+        >
+          <Tooltip
+            content={CustomTooltip}
+            cursor={{
+              fill: 'var(--def-200)',
+            }}
+          />
+          <XAxis dataKey="time" axisLine={false} tickLine={false} hide />
+          <YAxis hide domain={[0, maxDomain]} />
+          <Bar
+            dataKey="visitorCount"
+            fill="rgba(59, 121, 255, 0.2)"
+            isAnimationActive={false}
+            shape={BarShapeBlue}
+            activeBar={BarShapeBlue}
+          />
+        </BarChart>
+      </ResponsiveContainer>
     </Wrapper>
   );
 }
@@ -128,22 +101,144 @@ export function RealtimeLiveHistogram({
 interface WrapperProps {
   children: React.ReactNode;
   count: number;
+  icons?: React.ReactNode;
 }
 
-function Wrapper({ children, count }: WrapperProps) {
+function Wrapper({ children, count, icons }: WrapperProps) {
   return (
     <div className="flex flex-col">
-      <div className="col gap-2 p-4">
-        <div className="font-medium text-muted-foreground">
-          Unique vistors last 30 minutes
+      <div className="row gap-2 justify-between mb-2">
+        <div className="relative text-sm font-medium text-muted-foreground leading-normal">
+          Unique visitors {icons ? <br /> : null}
+          last 30 min
         </div>
+        <div>{icons}</div>
+      </div>
+      <div className="col gap-2 mb-4">
         <div className="font-mono text-6xl font-bold">
           <AnimatedNumber value={count} />
         </div>
       </div>
-      <div className="relative flex aspect-[6/1] w-full flex-1 items-end gap-0.5">
-        {children}
-      </div>
+      <div className="relative aspect-[6/1] w-full">{children}</div>
     </div>
   );
 }
+
+// Custom tooltip component that uses portals to escape overflow hidden
+const CustomTooltip = ({ active, payload, coordinate }: any) => {
+  const number = useNumber();
+  const [position, setPosition] = useState<{ x: number; y: number } | null>(
+    null,
+  );
+
+  const inactive = !active || !payload?.length;
+  useEffect(() => {
+    const setPositionThrottled = throttle(setPosition, 50);
+    const unsubMouseMove = bind(window, {
+      type: 'mousemove',
+      listener(event) {
+        if (!inactive) {
+          setPositionThrottled({ x: event.clientX, y: event.clientY + 20 });
+        }
+      },
+    });
+    const unsubDragEnter = bind(window, {
+      type: 'pointerdown',
+      listener() {
+        setPosition(null);
+      },
+    });
+
+    return () => {
+      unsubMouseMove();
+      unsubDragEnter();
+    };
+  }, [inactive]);
+
+  if (inactive) {
+    return null;
+  }
+
+  if (!active || !payload || !payload.length) {
+    return null;
+  }
+
+  const data = payload[0].payload;
+
+  const tooltipWidth = 200;
+  const correctXPosition = (x: number | undefined) => {
+    if (!x) {
+      return undefined;
+    }
+
+    const screenWidth = window.innerWidth;
+    const newX = x;
+
+    if (newX + tooltipWidth > screenWidth) {
+      return screenWidth - tooltipWidth;
+    }
+    return newX;
+  };
+
+  return (
+    <Portal.Portal
+      style={{
+        position: 'fixed',
+        top: position?.y,
+        left: correctXPosition(position?.x),
+        zIndex: 1000,
+        width: tooltipWidth,
+      }}
+      className="bg-background/80 p-3 rounded-md border shadow-xl backdrop-blur-sm"
+    >
+      <div className="flex justify-between gap-8 text-muted-foreground">
+        <div>{data.time}</div>
+      </div>
+      <React.Fragment>
+        <div className="flex gap-2">
+          <div
+            className="w-[3px] rounded-full"
+            style={{ background: getChartColor(0) }}
+          />
+          <div className="col flex-1 gap-1">
+            <div className="flex items-center gap-1">Active users</div>
+            <div className="flex justify-between gap-8 font-mono font-medium">
+              <div className="row gap-1">
+                {number.formatWithUnit(data.visitorCount)}
+              </div>
+            </div>
+          </div>
+        </div>
+        {data.referrers && data.referrers.length > 0 && (
+          <div className="mt-2 pt-2 border-t border-border">
+            <div className="text-xs text-muted-foreground mb-2">Referrers:</div>
+            <div className="space-y-1">
+              {data.referrers.slice(0, 3).map((ref: any, index: number) => (
+                <div
+                  key={`${ref.referrer}-${ref.count}-${index}`}
+                  className="row items-center justify-between text-xs"
+                >
+                  <div className="row items-center gap-1">
+                    <SerieIcon name={ref.referrer} />
+                    <span
+                      className="truncate max-w-[120px]"
+                      title={ref.referrer}
+                    >
+                      {ref.referrer}
+                    </span>
+                  </div>
+                  <span className="font-mono">{ref.count}</span>
+                </div>
+              ))}
+              {data.referrers.length > 3 && (
+                <div className="text-xs text-muted-foreground">
+                  +{data.referrers.length - 3} more
+                </div>
+              )}
+            </div>
+          </div>
+        )}
+      </React.Fragment>
+    </Portal.Portal>
+  );
+};

apps/start/src/components/realtime/realtime-paths.tsx

@@ -82,7 +82,7 @@ export function RealtimePaths({ projectId }: RealtimePathsProps) {
           },
           {
             name: 'Events',
-            width: '84px',
+            width: '60px',
             render(item) {
               return (
                 <div className="row gap-2 justify-end">
@@ -93,6 +93,19 @@ export function RealtimePaths({ projectId }: RealtimePathsProps) {
               );
             },
           },
+          {
+            name: 'Sessions',
+            width: '82px',
+            render(item) {
+              return (
+                <div className="row gap-2 justify-end">
+                  <span className="font-semibold">
+                    {number.short(item.unique_sessions)}
+                  </span>
+                </div>
+              );
+            },
+          },
         ]}
       />
     </div>