fix

* wip

* wip

* wip

* fix coderabbit comments

* remove template

.claude/CLAUDE.md

@@ -0,0 +1,170 @@
+# CLAUDE.md
+
+NEVER CALL FORMAT! WE'LL FORMAT IN THE FUTURE WHEN WE HAVE MERGED ALL BIG PRS!
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+
+## Project Overview
+
+Openpanel is an open-source web/product analytics platform (Mixpanel alternative). It's a **pnpm monorepo** with apps, packages, tooling, and SDKs.
+
+## Common Commands
+
+```bash
+# Development
+pnpm dev                    # Run all services (api, worker, dashboard) in parallel
+pnpm dev:public             # Run public/docs site only
+pnpm dock:up / dock:down    # Start/stop Docker (PostgreSQL, Redis, ClickHouse)
+
+# Code quality
+pnpm check                  # Lint check (Biome via Ultracite)
+pnpm fix                    # Auto-fix lint/format issues
+pnpm typecheck              # Typecheck all packages
+
+# Testing
+pnpm test                   # Run all tests (vitest)
+pnpm vitest run <path>      # Run a single test file
+# Workspace: packages/* and apps/* (excluding apps/start)
+
+# Database
+pnpm codegen                # Generate Prisma types + geo data
+pnpm migrate                # Run Prisma migrations (dev)
+pnpm migrate:deploy         # Deploy migrations (production - never run this)
+
+# Docker utilities
+pnpm dock:ch                # ClickHouse CLI
+pnpm dock:redis             # Redis CLI
+```
+
+## Architecture
+
+### Apps
+
+| App | Stack | Port | Purpose |
+|-----|-------|------|---------|
+| `apps/api` | Fastify + tRPC | 3333 | REST/RPC API server |
+| `apps/start` | TanStack Start (Vite + React 19) | 3000 | Dashboard SPA |
+| `apps/public` | Next.js 16 + Fumadocs | - | Marketing/docs site |
+| `apps/worker` | Express + BullMQ | 9999 | Background job processor |
+
+### Key Packages
+
+| Package | Purpose |
+|---------|---------|
+| `packages/db` | Prisma ORM (PostgreSQL) + ClickHouse client |
+| `packages/trpc` | tRPC router definitions, context, middleware |
+| `packages/auth` | Authentication (Arctic OAuth, Oslo sessions, argon2) |
+| `packages/queue` | BullMQ + GroupMQ job queue definitions |
+| `packages/redis` | Redis client + LRU caching |
+| `packages/validation` | Zod schemas shared across apps |
+| `packages/common` | Shared utilities (date-fns, ua-parser, nanoid) |
+| `packages/email` | React Email templates via Resend |
+| `packages/sdks/*` | Client SDKs (web, react, next, express, react-native, etc.) |
+
+### Data Flow
+
+1. **Event ingestion**: Client SDKs → `apps/api` (track routes) → Redis queue
+2. **Processing**: `apps/worker` picks up jobs from BullMQ, batches events into ClickHouse
+3. **Dashboard queries**: `apps/start` → tRPC → `apps/api` → ClickHouse (analytics) / PostgreSQL (config)
+4. **Real-time**: WebSocket via Fastify, pub/sub via Redis
+
+### Three-Database Strategy
+
+- **PostgreSQL**: Relational data (users, orgs, projects, dashboards). Managed by Prisma.
+- **ClickHouse**: Analytics event storage (OLAP). High-volume reads/writes.
+- **Redis**: Caching, job queues (BullMQ), rate limiting, pub/sub.
+
+### Dashboard (apps/start)
+
+Uses TanStack Router with file-based routing (`src/routes/`). State management via Redux Toolkit. UI built on Radix primitives + Tailwind v4. Charts via Recharts. Modals in `src/modals/`.
+
+### API (apps/api)
+
+Fastify server with tRPC integration. Route files in `src/routes/`. Hooks for IP extraction, request logging, timestamps. Built with `tsdown`.
+---
+
+## Core Principles
+
+Write code that is **accessible, performant, type-safe, and maintainable**. Focus on clarity and explicit intent over brevity.
+
+### Type Safety & Explicitness
+
+- Use explicit types for function parameters and return values when they enhance clarity
+- Prefer `unknown` over `any` when the type is genuinely unknown
+- Use const assertions (`as const`) for immutable values and literal types
+- Leverage TypeScript's type narrowing instead of type assertions
+- Use meaningful variable names instead of magic numbers - extract constants with descriptive names
+
+### Modern JavaScript/TypeScript
+
+- Use arrow functions for callbacks and short functions
+- Prefer `for...of` loops over `.forEach()` and indexed `for` loops
+- Use optional chaining (`?.`) and nullish coalescing (`??`) for safer property access
+- Prefer template literals over string concatenation
+- Use destructuring for object and array assignments
+- Use `const` by default, `let` only when reassignment is needed, never `var`
+
+### Async & Promises
+
+- Always `await` promises in async functions - don't forget to use the return value
+- Use `async/await` syntax instead of promise chains for better readability
+- Handle errors appropriately in async code with try-catch blocks
+- Don't use async functions as Promise executors
+
+### React & JSX
+
+- Use function components over class components
+- Call hooks at the top level only, never conditionally
+- Specify all dependencies in hook dependency arrays correctly
+- Use the `key` prop for elements in iterables (prefer unique IDs over array indices)
+- Nest children between opening and closing tags instead of passing as props
+- Don't define components inside other components
+- Use semantic HTML and ARIA attributes for accessibility:
+  - Provide meaningful alt text for images
+  - Use proper heading hierarchy
+  - Add labels for form inputs
+  - Include keyboard event handlers alongside mouse events
+  - Use semantic elements (`<button>`, `<nav>`, etc.) instead of divs with roles
+
+### Error Handling & Debugging
+
+- Remove `console.log`, `debugger`, and `alert` statements from production code
+- Throw `Error` objects with descriptive messages, not strings or other values
+- Use `try-catch` blocks meaningfully - don't catch errors just to rethrow them
+- Prefer early returns over nested conditionals for error cases
+
+### Code Organization
+
+- Keep functions focused and under reasonable cognitive complexity limits
+- Extract complex conditions into well-named boolean variables
+- Use early returns to reduce nesting
+- Prefer simple conditionals over nested ternary operators
+- Group related code together and separate concerns
+
+### Security
+
+- Add `rel="noopener"` when using `target="_blank"` on links
+- Avoid `dangerouslySetInnerHTML` unless absolutely necessary
+- Don't use `eval()` or assign directly to `document.cookie`
+- Validate and sanitize user input
+
+### Performance
+
+- Avoid spread syntax in accumulators within loops
+- Use top-level regex literals instead of creating them in loops
+- Prefer specific imports over namespace imports
+- Avoid barrel files (index files that re-export everything)
+- Use proper image components (e.g., Next.js `<Image>`) over `<img>` tags
+
+### Framework-Specific Guidance
+
+**Next.js:**
+- Use Next.js `<Image>` component for images
+- Use `next/head` or App Router metadata API for head elements
+- Use Server Components for async data fetching instead of async Client Components
+
+**React 19+:**
+- Use ref as a prop instead of `React.forwardRef`
+
+**Solid/Svelte/Vue/Qwik:**
+- Use `class` and `for` attributes (not `className` or `htmlFor`)

.github/workflows/docker-build.yml

@@ -8,6 +8,7 @@ on:
       - "apps/api/**"
       - "apps/worker/**"
       - "apps/public/**"
+      - "apps/start/**"
       - "packages/**"
       - "!packages/sdks/**"
       - "**Dockerfile"

.zed/settings.json

@@ -0,0 +1,50 @@
+{
+  "formatter": "language_server",
+  "format_on_save": "on",
+  "lsp": {
+    "typescript-language-server": {
+      "settings": {
+        "typescript": {
+          "preferences": {
+            "includePackageJsonAutoImports": "on"
+          }
+        }
+      }
+    }
+  },
+  "languages": {
+    "JavaScript": {
+      "formatter": {
+        "language_server": {
+          "name": "biome"
+        }
+      },
+      "code_actions_on_format": {
+        "source.fixAll.biome": true,
+        "source.organizeImports.biome": true
+      }
+    },
+    "TypeScript": {
+      "formatter": {
+        "language_server": {
+          "name": "biome"
+        }
+      },
+      "code_actions_on_format": {
+        "source.fixAll.biome": true,
+        "source.organizeImports.biome": true
+      }
+    },
+    "TSX": {
+      "formatter": {
+        "language_server": {
+          "name": "biome"
+        }
+      },
+      "code_actions_on_format": {
+        "source.fixAll.biome": true,
+        "source.organizeImports.biome": true
+      }
+    }
+  }
+}

admin/tsconfig.json

@@ -5,7 +5,10 @@
     "rootDir": "src",
     "target": "ES2022",
     "lib": ["ES2022"],
-    "types": ["node"]
+    "types": [
+      "node"
+    ],
+    "strictNullChecks": true
   },
   "include": ["src"]
 }

apps/api/Dockerfile

@@ -41,6 +41,7 @@ COPY packages/payments/package.json packages/payments/
 COPY packages/constants/package.json packages/constants/
 COPY packages/validation/package.json packages/validation/
 COPY packages/integrations/package.json packages/integrations/
+COPY packages/js-runtime/package.json packages/js-runtime/
 COPY patches ./patches
 
 # BUILD
@@ -108,6 +109,7 @@ COPY --from=build /app/packages/payments ./packages/payments
 COPY --from=build /app/packages/constants ./packages/constants
 COPY --from=build /app/packages/validation ./packages/validation
 COPY --from=build /app/packages/integrations ./packages/integrations
+COPY --from=build /app/packages/js-runtime ./packages/js-runtime
 COPY --from=build /app/tooling/typescript ./tooling/typescript
 RUN pnpm db:codegen
 

apps/api/package.json

@@ -8,6 +8,7 @@
     "start": "dotenv -e ../../.env node dist/index.js",
     "build": "rm -rf dist && tsdown",
     "gen:bots": "jiti scripts/get-bots.ts && biome format --write src/bots/bots.ts",
+    "test:manage": "jiti scripts/test-manage-api.ts",
     "typecheck": "tsc --noEmit"
   },
   "dependencies": {
@@ -46,7 +47,7 @@
     "sqlstring": "^2.3.3",
     "superjson": "^1.13.3",
     "svix": "^1.24.0",
-    "url-metadata": "^4.1.1",
+    "url-metadata": "^5.4.1",
     "uuid": "^9.0.1",
     "zod": "catalog:"
   },

apps/api/scripts/test-manage-api.ts

@@ -0,0 +1,340 @@
+/**
+ * One-off script to test all /manage/ API endpoints
+ *
+ * Usage:
+ *   pnpm test:manage
+ *   or
+ *   pnpm jiti scripts/test-manage-api.ts
+ *
+ * Set API_URL environment variable to test against a different server:
+ *   API_URL=http://localhost:3000 pnpm test:manage
+ */
+
+const CLIENT_ID = process.env.CLIENT_ID!;
+const CLIENT_SECRET = process.env.CLIENT_SECRET!;
+const API_BASE_URL = process.env.API_URL || 'http://localhost:3333';
+
+if (!CLIENT_ID || !CLIENT_SECRET) {
+  console.error('CLIENT_ID and CLIENT_SECRET must be set');
+  process.exit(1);
+}
+
+interface TestResult {
+  name: string;
+  method: string;
+  url: string;
+  status: number;
+  success: boolean;
+  error?: string;
+  data?: any;
+}
+
+const results: TestResult[] = [];
+
+async function makeRequest(
+  method: string,
+  path: string,
+  body?: any,
+): Promise<TestResult> {
+  const url = `${API_BASE_URL}${path}`;
+  const headers: Record<string, string> = {
+    'openpanel-client-id': CLIENT_ID,
+    'openpanel-client-secret': CLIENT_SECRET,
+  };
+
+  // Only set Content-Type if there's a body
+  if (body) {
+    headers['Content-Type'] = 'application/json';
+  }
+
+  try {
+    const response = await fetch(url, {
+      method,
+      headers,
+      body: body ? JSON.stringify(body) : undefined,
+    });
+
+    const data = await response.json().catch(() => ({}));
+
+    return {
+      name: `${method} ${path}`,
+      method,
+      url,
+      status: response.status,
+      success: response.ok,
+      error: response.ok ? undefined : data.message || 'Request failed',
+      data: response.ok ? data : undefined,
+    };
+  } catch (error) {
+    return {
+      name: `${method} ${path}`,
+      method,
+      url,
+      status: 0,
+      success: false,
+      error: error instanceof Error ? error.message : 'Unknown error',
+    };
+  }
+}
+
+async function testProjects() {
+  console.log('\n📁 Testing Projects endpoints...\n');
+
+  // Create project
+  const createResult = await makeRequest('POST', '/manage/projects', {
+    name: `Test Project ${Date.now()}`,
+    domain: 'https://example.com',
+    cors: ['https://example.com', 'https://www.example.com'],
+    crossDomain: false,
+    types: ['website'],
+  });
+  results.push(createResult);
+  console.log(
+    `✓ POST /manage/projects: ${createResult.success ? '✅' : '❌'} ${createResult.status}`,
+  );
+  if (createResult.error) console.log(`  Error: ${createResult.error}`);
+
+  const projectId = createResult.data?.data?.id;
+  const clientId = createResult.data?.data?.client?.id;
+  const clientSecret = createResult.data?.data?.client?.secret;
+
+  if (projectId) {
+    console.log(`  Created project: ${projectId}`);
+    if (clientId) console.log(`  Created client: ${clientId}`);
+    if (clientSecret) console.log(`  Client secret: ${clientSecret}`);
+  }
+
+  // List projects
+  const listResult = await makeRequest('GET', '/manage/projects');
+  results.push(listResult);
+  console.log(
+    `✓ GET /manage/projects: ${listResult.success ? '✅' : '❌'} ${listResult.status}`,
+  );
+  if (listResult.data?.data?.length) {
+    console.log(`  Found ${listResult.data.data.length} projects`);
+  }
+
+  if (projectId) {
+    // Get project
+    const getResult = await makeRequest('GET', `/manage/projects/${projectId}`);
+    results.push(getResult);
+    console.log(
+      `✓ GET /manage/projects/:id: ${getResult.success ? '✅' : '❌'} ${getResult.status}`,
+    );
+
+    // Update project
+    const updateResult = await makeRequest(
+      'PATCH',
+      `/manage/projects/${projectId}`,
+      {
+        name: 'Updated Test Project',
+        crossDomain: true,
+      },
+    );
+    results.push(updateResult);
+    console.log(
+      `✓ PATCH /manage/projects/:id: ${updateResult.success ? '✅' : '❌'} ${updateResult.status}`,
+    );
+
+    // Delete project (soft delete)
+    const deleteResult = await makeRequest(
+      'DELETE',
+      `/manage/projects/${projectId}`,
+    );
+    results.push(deleteResult);
+    console.log(
+      `✓ DELETE /manage/projects/:id: ${deleteResult.success ? '✅' : '❌'} ${deleteResult.status}`,
+    );
+  }
+
+  return { projectId, clientId };
+}
+
+async function testClients(projectId?: string) {
+  console.log('\n🔑 Testing Clients endpoints...\n');
+
+  // Create client
+  const createResult = await makeRequest('POST', '/manage/clients', {
+    name: `Test Client ${Date.now()}`,
+    projectId: projectId || undefined,
+    type: 'read',
+  });
+  results.push(createResult);
+  console.log(
+    `✓ POST /manage/clients: ${createResult.success ? '✅' : '❌'} ${createResult.status}`,
+  );
+  if (createResult.error) console.log(`  Error: ${createResult.error}`);
+
+  const clientId = createResult.data?.data?.id;
+  const clientSecret = createResult.data?.data?.secret;
+
+  if (clientId) {
+    console.log(`  Created client: ${clientId}`);
+    if (clientSecret) console.log(`  Client secret: ${clientSecret}`);
+  }
+
+  // List clients
+  const listResult = await makeRequest(
+    'GET',
+    projectId ? `/manage/clients?projectId=${projectId}` : '/manage/clients',
+  );
+  results.push(listResult);
+  console.log(
+    `✓ GET /manage/clients: ${listResult.success ? '✅' : '❌'} ${listResult.status}`,
+  );
+  if (listResult.data?.data?.length) {
+    console.log(`  Found ${listResult.data.data.length} clients`);
+  }
+
+  if (clientId) {
+    // Get client
+    const getResult = await makeRequest('GET', `/manage/clients/${clientId}`);
+    results.push(getResult);
+    console.log(
+      `✓ GET /manage/clients/:id: ${getResult.success ? '✅' : '❌'} ${getResult.status}`,
+    );
+
+    // Update client
+    const updateResult = await makeRequest(
+      'PATCH',
+      `/manage/clients/${clientId}`,
+      {
+        name: 'Updated Test Client',
+      },
+    );
+    results.push(updateResult);
+    console.log(
+      `✓ PATCH /manage/clients/:id: ${updateResult.success ? '✅' : '❌'} ${updateResult.status}`,
+    );
+
+    // Delete client
+    const deleteResult = await makeRequest(
+      'DELETE',
+      `/manage/clients/${clientId}`,
+    );
+    results.push(deleteResult);
+    console.log(
+      `✓ DELETE /manage/clients/:id: ${deleteResult.success ? '✅' : '❌'} ${deleteResult.status}`,
+    );
+  }
+}
+
+async function testReferences(projectId?: string) {
+  console.log('\n📚 Testing References endpoints...\n');
+
+  if (!projectId) {
+    console.log('  ⚠️  Skipping references tests - no project ID available');
+    return;
+  }
+
+  // Create reference
+  const createResult = await makeRequest('POST', '/manage/references', {
+    projectId,
+    title: `Test Reference ${Date.now()}`,
+    description: 'This is a test reference',
+    datetime: new Date().toISOString(),
+  });
+  results.push(createResult);
+  console.log(
+    `✓ POST /manage/references: ${createResult.success ? '✅' : '❌'} ${createResult.status}`,
+  );
+  if (createResult.error) console.log(`  Error: ${createResult.error}`);
+
+  const referenceId = createResult.data?.data?.id;
+
+  if (referenceId) {
+    console.log(`  Created reference: ${referenceId}`);
+  }
+
+  // List references
+  const listResult = await makeRequest(
+    'GET',
+    `/manage/references?projectId=${projectId}`,
+  );
+  results.push(listResult);
+  console.log(
+    `✓ GET /manage/references: ${listResult.success ? '✅' : '❌'} ${listResult.status}`,
+  );
+  if (listResult.data?.data?.length) {
+    console.log(`  Found ${listResult.data.data.length} references`);
+  }
+
+  if (referenceId) {
+    // Get reference
+    const getResult = await makeRequest(
+      'GET',
+      `/manage/references/${referenceId}`,
+    );
+    results.push(getResult);
+    console.log(
+      `✓ GET /manage/references/:id: ${getResult.success ? '✅' : '❌'} ${getResult.status}`,
+    );
+
+    // Update reference
+    const updateResult = await makeRequest(
+      'PATCH',
+      `/manage/references/${referenceId}`,
+      {
+        title: 'Updated Test Reference',
+        description: 'Updated description',
+        datetime: new Date().toISOString(),
+      },
+    );
+    results.push(updateResult);
+    console.log(
+      `✓ PATCH /manage/references/:id: ${updateResult.success ? '✅' : '❌'} ${updateResult.status}`,
+    );
+
+    // Delete reference
+    const deleteResult = await makeRequest(
+      'DELETE',
+      `/manage/references/${referenceId}`,
+    );
+    results.push(deleteResult);
+    console.log(
+      `✓ DELETE /manage/references/:id: ${deleteResult.success ? '✅' : '❌'} ${deleteResult.status}`,
+    );
+  }
+}
+
+async function main() {
+  console.log('🚀 Testing Manage API Endpoints\n');
+  console.log(`API Base URL: ${API_BASE_URL}`);
+  console.log(`Client ID: ${CLIENT_ID}\n`);
+
+  try {
+    // Test projects first (creates a project we can use for other tests)
+    const { projectId } = await testProjects();
+
+    // Test clients
+    await testClients(projectId);
+
+    // Test references (requires a project)
+    await testReferences(projectId);
+
+    // Summary
+    console.log(`\n${'='.repeat(60)}`);
+    console.log('📊 Test Summary\n');
+    const successful = results.filter((r) => r.success).length;
+    const failed = results.filter((r) => !r.success).length;
+
+    console.log(`Total tests: ${results.length}`);
+    console.log(`✅ Successful: ${successful}`);
+    console.log(`❌ Failed: ${failed}\n`);
+
+    if (failed > 0) {
+      console.log('Failed tests:');
+      results
+        .filter((r) => !r.success)
+        .forEach((r) => {
+          console.log(`  ❌ ${r.name} (${r.status})`);
+          if (r.error) console.log(`     Error: ${r.error}`);
+        });
+    }
+  } catch (error) {
+    console.error('Fatal error:', error);
+    process.exit(1);
+  }
+}
+
+main().catch(console.error);

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

@@ -1,26 +1,25 @@
-import type { FastifyReply, FastifyRequest } from 'fastify';
-
-import { generateDeviceId, parseUserAgent } from '@openpanel/common/server';
-import { getSalts } from '@openpanel/db';
-import { getEventsGroupQueueShard } from '@openpanel/queue';
-
 import { generateId, slug } from '@openpanel/common';
+import { parseUserAgent } from '@openpanel/common/server';
+import { getSalts } from '@openpanel/db';
 import { getGeoLocation } from '@openpanel/geo';
+import { getEventsGroupQueueShard } from '@openpanel/queue';
 import type { DeprecatedPostEventPayload } from '@openpanel/validation';
+import type { FastifyReply, FastifyRequest } from 'fastify';
 import { getStringHeaders, getTimestamp } from './track.controller';
+import { getDeviceId } from '@/utils/ids';
 
 export async function postEvent(
   request: FastifyRequest<{
     Body: DeprecatedPostEventPayload;
   }>,
-  reply: FastifyReply,
+  reply: FastifyReply
 ) {
   const { timestamp, isTimestampFromThePast } = getTimestamp(
     request.timestamp,
-    request.body,
+    request.body
   );
   const ip = request.clientIp;
-  const ua = request.headers['user-agent'];
+  const ua = request.headers['user-agent'] ?? 'unknown/1.0';
   const projectId = request.client?.projectId;
   const headers = getStringHeaders(request.headers);
 
@@ -30,34 +29,22 @@ export async function postEvent(
   }
 
   const [salts, geo] = await Promise.all([getSalts(), getGeoLocation(ip)]);
-  const currentDeviceId = ua
+  const { deviceId, sessionId } = await getDeviceId({
-    ? generateDeviceId({
+    projectId,
-        salt: salts.current,
+    ip,
-        origin: projectId,
+    ua,
-        ip,
+    salts,
-        ua,
+  });
-      })
-    : '';
-  const previousDeviceId = ua
-    ? generateDeviceId({
-        salt: salts.previous,
-        origin: projectId,
-        ip,
-        ua,
-      })
-    : '';
 
   const uaInfo = parseUserAgent(ua, request.body?.properties);
   const groupId = uaInfo.isServer
-    ? request.body?.profileId
+    ? `${projectId}:${request.body?.profileId ?? generateId()}`
-      ? `${projectId}:${request.body?.profileId}`
+    : deviceId;
-      : `${projectId}:${generateId()}`
-    : currentDeviceId;
   const jobId = [
     slug(request.body.name),
     timestamp,
     projectId,
-    currentDeviceId,
+    deviceId,
     groupId,
   ]
     .filter(Boolean)
@@ -74,8 +61,10 @@ export async function postEvent(
       },
       uaInfo,
       geo,
-      currentDeviceId,
+      currentDeviceId: '',
-      previousDeviceId,
+      previousDeviceId: '',
+      deviceId,
+      sessionId: sessionId ?? '',
     },
     groupId,
     jobId,

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

@@ -13,7 +13,7 @@ import {
   getSettingsForProject,
 } from '@openpanel/db';
 import { ChartEngine } from '@openpanel/db';
-import { zChartEvent, zChartInputBase } from '@openpanel/validation';
+import { zChartEvent, zReport } from '@openpanel/validation';
 import { omit } from 'ramda';
 
 async function getProjectId(
@@ -139,7 +139,7 @@ export async function events(
   });
 }
 
-const chartSchemeFull = zChartInputBase
+const chartSchemeFull = zReport
   .pick({
     breakdowns: true,
     interval: true,

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

@@ -0,0 +1,649 @@
+import crypto from 'node:crypto';
+import { HttpError } from '@/utils/errors';
+import { stripTrailingSlash } from '@openpanel/common';
+import { hashPassword } from '@openpanel/common/server';
+import {
+  db,
+  getClientByIdCached,
+  getId,
+  getProjectByIdCached,
+} from '@openpanel/db';
+import type { FastifyReply, FastifyRequest } from 'fastify';
+import { z } from 'zod';
+
+// Validation schemas
+const zCreateProject = z.object({
+  name: z.string().min(1),
+  domain: z.string().url().or(z.literal('')).or(z.null()).optional(),
+  cors: z.array(z.string()).default([]),
+  crossDomain: z.boolean().optional().default(false),
+  types: z
+    .array(z.enum(['website', 'app', 'backend']))
+    .optional()
+    .default([]),
+});
+
+const zUpdateProject = z.object({
+  name: z.string().min(1).optional(),
+  domain: z.string().url().or(z.literal('')).or(z.null()).optional(),
+  cors: z.array(z.string()).optional(),
+  crossDomain: z.boolean().optional(),
+  allowUnsafeRevenueTracking: z.boolean().optional(),
+});
+
+const zCreateClient = z.object({
+  name: z.string().min(1),
+  projectId: z.string().optional(),
+  type: z.enum(['read', 'write', 'root']).optional().default('write'),
+});
+
+const zUpdateClient = z.object({
+  name: z.string().min(1).optional(),
+});
+
+const zCreateReference = z.object({
+  projectId: z.string(),
+  title: z.string().min(1),
+  description: z.string().optional(),
+  datetime: z.string(),
+});
+
+const zUpdateReference = z.object({
+  title: z.string().min(1).optional(),
+  description: z.string().optional(),
+  datetime: z.string().optional(),
+});
+
+// Projects CRUD
+export async function listProjects(
+  request: FastifyRequest,
+  reply: FastifyReply,
+) {
+  const projects = await db.project.findMany({
+    where: {
+      organizationId: request.client!.organizationId,
+      deleteAt: null,
+    },
+    orderBy: {
+      createdAt: 'desc',
+    },
+  });
+
+  reply.send({ data: projects });
+}
+
+export async function getProject(
+  request: FastifyRequest<{ Params: { id: string } }>,
+  reply: FastifyReply,
+) {
+  const project = await db.project.findFirst({
+    where: {
+      id: request.params.id,
+      organizationId: request.client!.organizationId,
+    },
+  });
+
+  if (!project) {
+    throw new HttpError('Project not found', { status: 404 });
+  }
+
+  reply.send({ data: project });
+}
+
+export async function createProject(
+  request: FastifyRequest<{ Body: z.infer<typeof zCreateProject> }>,
+  reply: FastifyReply,
+) {
+  const parsed = zCreateProject.safeParse(request.body);
+
+  if (parsed.success === false) {
+    return reply.status(400).send({
+      error: 'Bad Request',
+      message: 'Invalid request body',
+      details: parsed.error.errors,
+    });
+  }
+
+  const { name, domain, cors, crossDomain, types } = parsed.data;
+
+  // Generate a default client secret
+  const secret = `sec_${crypto.randomBytes(10).toString('hex')}`;
+  const clientData = {
+    organizationId: request.client!.organizationId,
+    name: 'First client',
+    type: 'write' as const,
+    secret: await hashPassword(secret),
+  };
+
+  const project = await db.project.create({
+    data: {
+      id: await getId('project', name),
+      organizationId: request.client!.organizationId,
+      name,
+      domain: domain ? stripTrailingSlash(domain) : null,
+      cors: cors.map((c) => stripTrailingSlash(c)),
+      crossDomain: crossDomain ?? false,
+      allowUnsafeRevenueTracking: false,
+      filters: [],
+      types,
+      clients: {
+        create: clientData,
+      },
+    },
+    include: {
+      clients: {
+        select: {
+          id: true,
+        },
+      },
+    },
+  });
+
+  // Clear cache
+  await Promise.all([
+    getProjectByIdCached.clear(project.id),
+    project.clients.map((client) => {
+      getClientByIdCached.clear(client.id);
+    }),
+  ]);
+
+  reply.send({
+    data: {
+      ...project,
+      client: project.clients[0]
+        ? {
+            id: project.clients[0].id,
+            secret,
+          }
+        : null,
+    },
+  });
+}
+
+export async function updateProject(
+  request: FastifyRequest<{
+    Params: { id: string };
+    Body: z.infer<typeof zUpdateProject>;
+  }>,
+  reply: FastifyReply,
+) {
+  const parsed = zUpdateProject.safeParse(request.body);
+
+  if (parsed.success === false) {
+    return reply.status(400).send({
+      error: 'Bad Request',
+      message: 'Invalid request body',
+      details: parsed.error.errors,
+    });
+  }
+
+  // Verify project exists and belongs to organization
+  const existing = await db.project.findFirst({
+    where: {
+      id: request.params.id,
+      organizationId: request.client!.organizationId,
+    },
+    include: {
+      clients: {
+        select: {
+          id: true,
+        },
+      },
+    },
+  });
+
+  if (!existing) {
+    throw new HttpError('Project not found', { status: 404 });
+  }
+
+  const updateData: any = {};
+  if (parsed.data.name !== undefined) {
+    updateData.name = parsed.data.name;
+  }
+  if (parsed.data.domain !== undefined) {
+    updateData.domain = parsed.data.domain
+      ? stripTrailingSlash(parsed.data.domain)
+      : null;
+  }
+  if (parsed.data.cors !== undefined) {
+    updateData.cors = parsed.data.cors.map((c) => stripTrailingSlash(c));
+  }
+  if (parsed.data.crossDomain !== undefined) {
+    updateData.crossDomain = parsed.data.crossDomain;
+  }
+  if (parsed.data.allowUnsafeRevenueTracking !== undefined) {
+    updateData.allowUnsafeRevenueTracking =
+      parsed.data.allowUnsafeRevenueTracking;
+  }
+
+  const project = await db.project.update({
+    where: {
+      id: request.params.id,
+    },
+    data: updateData,
+  });
+
+  // Clear cache
+  await Promise.all([
+    getProjectByIdCached.clear(project.id),
+    existing.clients.map((client) => {
+      getClientByIdCached.clear(client.id);
+    }),
+  ]);
+
+  reply.send({ data: project });
+}
+
+export async function deleteProject(
+  request: FastifyRequest<{ Params: { id: string } }>,
+  reply: FastifyReply,
+) {
+  const project = await db.project.findFirst({
+    where: {
+      id: request.params.id,
+      organizationId: request.client!.organizationId,
+    },
+  });
+
+  if (!project) {
+    throw new HttpError('Project not found', { status: 404 });
+  }
+
+  await db.project.update({
+    where: {
+      id: request.params.id,
+    },
+    data: {
+      deleteAt: new Date(Date.now() + 24 * 60 * 60 * 1000),
+    },
+  });
+
+  await getProjectByIdCached.clear(request.params.id);
+
+  reply.send({ success: true });
+}
+
+// Clients CRUD
+export async function listClients(
+  request: FastifyRequest<{ Querystring: { projectId?: string } }>,
+  reply: FastifyReply,
+) {
+  const where: any = {
+    organizationId: request.client!.organizationId,
+  };
+
+  if (request.query.projectId) {
+    // Verify project belongs to organization
+    const project = await db.project.findFirst({
+      where: {
+        id: request.query.projectId,
+        organizationId: request.client!.organizationId,
+      },
+    });
+
+    if (!project) {
+      throw new HttpError('Project not found', { status: 404 });
+    }
+
+    where.projectId = request.query.projectId;
+  }
+
+  const clients = await db.client.findMany({
+    where,
+    orderBy: {
+      createdAt: 'desc',
+    },
+  });
+
+  reply.send({ data: clients });
+}
+
+export async function getClient(
+  request: FastifyRequest<{ Params: { id: string } }>,
+  reply: FastifyReply,
+) {
+  const client = await db.client.findFirst({
+    where: {
+      id: request.params.id,
+      organizationId: request.client!.organizationId,
+    },
+  });
+
+  if (!client) {
+    throw new HttpError('Client not found', { status: 404 });
+  }
+
+  reply.send({ data: client });
+}
+
+export async function createClient(
+  request: FastifyRequest<{ Body: z.infer<typeof zCreateClient> }>,
+  reply: FastifyReply,
+) {
+  const parsed = zCreateClient.safeParse(request.body);
+
+  if (parsed.success === false) {
+    return reply.status(400).send({
+      error: 'Bad Request',
+      message: 'Invalid request body',
+      details: parsed.error.errors,
+    });
+  }
+
+  const { name, projectId, type } = parsed.data;
+
+  // If projectId is provided, verify it belongs to organization
+  if (projectId) {
+    const project = await db.project.findFirst({
+      where: {
+        id: projectId,
+        organizationId: request.client!.organizationId,
+      },
+    });
+
+    if (!project) {
+      throw new HttpError('Project not found', { status: 404 });
+    }
+  }
+
+  // Generate secret
+  const secret = `sec_${crypto.randomBytes(10).toString('hex')}`;
+
+  const client = await db.client.create({
+    data: {
+      organizationId: request.client!.organizationId,
+      projectId: projectId || null,
+      name,
+      type: type || 'write',
+      secret: await hashPassword(secret),
+    },
+  });
+
+  await getClientByIdCached.clear(client.id);
+
+  reply.send({
+    data: {
+      ...client,
+      secret, // Return plain secret only once
+    },
+  });
+}
+
+export async function updateClient(
+  request: FastifyRequest<{
+    Params: { id: string };
+    Body: z.infer<typeof zUpdateClient>;
+  }>,
+  reply: FastifyReply,
+) {
+  const parsed = zUpdateClient.safeParse(request.body);
+
+  if (parsed.success === false) {
+    return reply.status(400).send({
+      error: 'Bad Request',
+      message: 'Invalid request body',
+      details: parsed.error.errors,
+    });
+  }
+
+  // Verify client exists and belongs to organization
+  const existing = await db.client.findFirst({
+    where: {
+      id: request.params.id,
+      organizationId: request.client!.organizationId,
+    },
+  });
+
+  if (!existing) {
+    throw new HttpError('Client not found', { status: 404 });
+  }
+
+  const updateData: any = {};
+  if (parsed.data.name !== undefined) {
+    updateData.name = parsed.data.name;
+  }
+
+  const client = await db.client.update({
+    where: {
+      id: request.params.id,
+    },
+    data: updateData,
+  });
+
+  await getClientByIdCached.clear(client.id);
+
+  reply.send({ data: client });
+}
+
+export async function deleteClient(
+  request: FastifyRequest<{ Params: { id: string } }>,
+  reply: FastifyReply,
+) {
+  const client = await db.client.findFirst({
+    where: {
+      id: request.params.id,
+      organizationId: request.client!.organizationId,
+    },
+  });
+
+  if (!client) {
+    throw new HttpError('Client not found', { status: 404 });
+  }
+
+  await db.client.delete({
+    where: {
+      id: request.params.id,
+    },
+  });
+
+  await getClientByIdCached.clear(request.params.id);
+
+  reply.send({ success: true });
+}
+
+// References CRUD
+export async function listReferences(
+  request: FastifyRequest<{ Querystring: { projectId?: string } }>,
+  reply: FastifyReply,
+) {
+  const where: any = {};
+
+  if (request.query.projectId) {
+    // Verify project belongs to organization
+    const project = await db.project.findFirst({
+      where: {
+        id: request.query.projectId,
+        organizationId: request.client!.organizationId,
+      },
+    });
+
+    if (!project) {
+      throw new HttpError('Project not found', { status: 404 });
+    }
+
+    where.projectId = request.query.projectId;
+  } else {
+    // If no projectId, get all projects in org and filter references
+    const projects = await db.project.findMany({
+      where: {
+        organizationId: request.client!.organizationId,
+      },
+      select: { id: true },
+    });
+
+    where.projectId = {
+      in: projects.map((p) => p.id),
+    };
+  }
+
+  const references = await db.reference.findMany({
+    where,
+    orderBy: {
+      createdAt: 'desc',
+    },
+  });
+
+  reply.send({ data: references });
+}
+
+export async function getReference(
+  request: FastifyRequest<{ Params: { id: string } }>,
+  reply: FastifyReply,
+) {
+  const reference = await db.reference.findUnique({
+    where: {
+      id: request.params.id,
+    },
+    include: {
+      project: {
+        select: {
+          organizationId: true,
+        },
+      },
+    },
+  });
+
+  if (!reference) {
+    throw new HttpError('Reference not found', { status: 404 });
+  }
+
+  if (reference.project.organizationId !== request.client!.organizationId) {
+    throw new HttpError('Reference not found', { status: 404 });
+  }
+
+  reply.send({ data: reference });
+}
+
+export async function createReference(
+  request: FastifyRequest<{ Body: z.infer<typeof zCreateReference> }>,
+  reply: FastifyReply,
+) {
+  const parsed = zCreateReference.safeParse(request.body);
+
+  if (parsed.success === false) {
+    return reply.status(400).send({
+      error: 'Bad Request',
+      message: 'Invalid request body',
+      details: parsed.error.errors,
+    });
+  }
+
+  const { projectId, title, description, datetime } = parsed.data;
+
+  // Verify project belongs to organization
+  const project = await db.project.findFirst({
+    where: {
+      id: projectId,
+      organizationId: request.client!.organizationId,
+    },
+  });
+
+  if (!project) {
+    throw new HttpError('Project not found', { status: 404 });
+  }
+
+  const reference = await db.reference.create({
+    data: {
+      projectId,
+      title,
+      description: description || null,
+      date: new Date(datetime),
+    },
+  });
+
+  reply.send({ data: reference });
+}
+
+export async function updateReference(
+  request: FastifyRequest<{
+    Params: { id: string };
+    Body: z.infer<typeof zUpdateReference>;
+  }>,
+  reply: FastifyReply,
+) {
+  const parsed = zUpdateReference.safeParse(request.body);
+
+  if (parsed.success === false) {
+    return reply.status(400).send({
+      error: 'Bad Request',
+      message: 'Invalid request body',
+      details: parsed.error.errors,
+    });
+  }
+
+  // Verify reference exists and belongs to organization
+  const existing = await db.reference.findUnique({
+    where: {
+      id: request.params.id,
+    },
+    include: {
+      project: {
+        select: {
+          organizationId: true,
+        },
+      },
+    },
+  });
+
+  if (!existing) {
+    throw new HttpError('Reference not found', { status: 404 });
+  }
+
+  if (existing.project.organizationId !== request.client!.organizationId) {
+    throw new HttpError('Reference not found', { status: 404 });
+  }
+
+  const updateData: any = {};
+  if (parsed.data.title !== undefined) {
+    updateData.title = parsed.data.title;
+  }
+  if (parsed.data.description !== undefined) {
+    updateData.description = parsed.data.description ?? null;
+  }
+  if (parsed.data.datetime !== undefined) {
+    updateData.date = new Date(parsed.data.datetime);
+  }
+
+  const reference = await db.reference.update({
+    where: {
+      id: request.params.id,
+    },
+    data: updateData,
+  });
+
+  reply.send({ data: reference });
+}
+
+export async function deleteReference(
+  request: FastifyRequest<{ Params: { id: string } }>,
+  reply: FastifyReply,
+) {
+  const reference = await db.reference.findUnique({
+    where: {
+      id: request.params.id,
+    },
+    include: {
+      project: {
+        select: {
+          organizationId: true,
+        },
+      },
+    },
+  });
+
+  if (!reference) {
+    throw new HttpError('Reference not found', { status: 404 });
+  }
+
+  if (reference.project.organizationId !== request.client!.organizationId) {
+    throw new HttpError('Reference not found', { status: 404 });
+  }
+
+  await db.reference.delete({
+    where: {
+      id: request.params.id,
+    },
+  });
+
+  reply.send({ success: true });
+}

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

@@ -71,7 +71,7 @@ async function fetchImage(
   url: URL,
 ): Promise<{ buffer: Buffer; contentType: string; status: number }> {
   const controller = new AbortController();
-  const timeout = setTimeout(() => controller.abort(), 10000); // 10s timeout
+  const timeout = setTimeout(() => controller.abort(), 1000); // 10s timeout
 
   try {
     const response = await fetch(url.toString(), {
@@ -175,20 +175,10 @@ async function processImage(
       bufferSize: buffer.length,
     });
 
-    // If Sharp fails, try to create a simple fallback image
+    throw error;
-    return createFallbackImage();
   }
 }
 
-// Create a simple transparent fallback image when Sharp can't process the original
-function createFallbackImage(): Buffer {
-  // 1x1 transparent PNG
-  return Buffer.from(
-    'iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mNk+A8AAQUBAScY42YAAAAASUVORK5CYII=',
-    'base64',
-  );
-}
-
 // Process OG image with Sharp (resize to 300px width)
 async function processOgImage(
   buffer: Buffer,
@@ -220,8 +210,7 @@ async function processOgImage(
       bufferSize: buffer.length,
     });
 
-    // If Sharp fails, try to create a simple fallback image
+    throw error;
-    return createFallbackImage();
   }
 }
 
@@ -241,11 +230,15 @@ export async function getFavicon(
   reply: FastifyReply,
 ) {
   try {
+    logger.info('getFavicon', {
+      url: request.query.url,
+    });
     const url = validateUrl(request.query.url);
     if (!url) {
-      reply.header('Content-Type', 'image/png');
+      return reply
-      reply.header('Cache-Control', 'public, max-age=3600');
+        .status(404)
-      return reply.send(createFallbackImage());
+        .header('Content-Type', 'text/plain')
+        .send('Not found');
     }
 
     const cacheKey = createCacheKey(url.toString());
@@ -259,11 +252,13 @@ export async function getFavicon(
     }
 
     let imageUrl: URL;
-
     // If it's a direct image URL, use it directly
     if (isDirectImage(url)) {
       imageUrl = url;
     } else {
+      logger.info('before parseUrlMeta', {
+        url: url.toString(),
+      });
       // For website URLs, extract favicon from HTML
       const meta = await parseUrlMeta(url.toString());
       logger.info('parseUrlMeta result', {
@@ -323,9 +318,10 @@ export async function getFavicon(
 
     // Accept any response as long as we have valid image data
     if (buffer.length === 0) {
-      reply.header('Content-Type', 'image/png');
+      return reply
-      reply.header('Cache-Control', 'public, max-age=3600');
+        .status(404)
-      return reply.send(createFallbackImage());
+        .header('Content-Type', 'text/plain')
+        .send('Not found');
     }
 
     // Process the image (resize to 30x30 PNG, or serve ICO as-is)

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

@@ -1,22 +1,27 @@
-import type { FastifyReply, FastifyRequest } from 'fastify';
-import { assocPath, pathOr, pick } from 'ramda';
-
-import { HttpError } from '@/utils/errors';
 import { generateId, slug } from '@openpanel/common';
 import { generateDeviceId, parseUserAgent } from '@openpanel/common/server';
-import { getProfileById, getSalts, upsertProfile } from '@openpanel/db';
+import {
+  getProfileById,
+  getSalts,
+  replayBuffer,
+  upsertProfile,
+} from '@openpanel/db';
 import { type GeoLocation, getGeoLocation } from '@openpanel/geo';
 import { getEventsGroupQueueShard } from '@openpanel/queue';
 import { getRedisCache } from '@openpanel/redis';
-
 import {
   type IDecrementPayload,
   type IIdentifyPayload,
   type IIncrementPayload,
+  type IReplayPayload,
   type ITrackHandlerPayload,
   type ITrackPayload,
   zTrackHandlerPayload,
 } from '@openpanel/validation';
+import type { FastifyReply, FastifyRequest } from 'fastify';
+import { assocPath, pathOr, pick } from 'ramda';
+import { HttpError } from '@/utils/errors';
+import { getDeviceId } from '@/utils/ids';
 
 export function getStringHeaders(headers: FastifyRequest['headers']) {
   return Object.entries(
@@ -28,14 +33,14 @@ export function getStringHeaders(headers: FastifyRequest['headers']) {
         'openpanel-client-id',
         'request-id',
       ],
-      headers,
+      headers
-    ),
+    )
   ).reduce(
     (acc, [key, value]) => ({
       ...acc,
       [key]: value ? String(value) : undefined,
     }),
-    {},
+    {}
   );
 }
 
@@ -45,14 +50,15 @@ function getIdentity(body: ITrackHandlerPayload): IIdentifyPayload | undefined {
       | IIdentifyPayload
       | undefined;
 
-    return (
+    if (identity) {
-      identity ||
+      return identity;
-      (body.payload.profileId
+    }
-        ? {
+
-            profileId: body.payload.profileId,
+    return body.payload.profileId
-          }
+      ? {
-        : undefined)
+          profileId: String(body.payload.profileId),
-    );
+        }
+      : undefined;
   }
 
   return undefined;
@@ -60,7 +66,7 @@ function getIdentity(body: ITrackHandlerPayload): IIdentifyPayload | undefined {
 
 export function getTimestamp(
   timestamp: FastifyRequest['timestamp'],
-  payload: ITrackHandlerPayload['payload'],
+  payload: ITrackHandlerPayload['payload']
 ) {
   const safeTimestamp = timestamp || Date.now();
   const userDefinedTimestamp =
@@ -104,8 +110,8 @@ interface TrackContext {
   headers: Record<string, string | undefined>;
   timestamp: { value: number; isFromPast: boolean };
   identity?: IIdentifyPayload;
-  currentDeviceId?: string;
+  deviceId: string;
-  previousDeviceId?: string;
+  sessionId: string;
   geo: GeoLocation;
 }
 
@@ -113,7 +119,7 @@ async function buildContext(
   request: FastifyRequest<{
     Body: ITrackHandlerPayload;
   }>,
-  validatedBody: ITrackHandlerPayload,
+  validatedBody: ITrackHandlerPayload
 ): Promise<TrackContext> {
   const projectId = request.client?.projectId;
   if (!projectId) {
@@ -125,51 +131,30 @@ async function buildContext(
     validatedBody.type === 'track' && validatedBody.payload.properties?.__ip
       ? (validatedBody.payload.properties.__ip as string)
       : request.clientIp;
-  const ua = request.headers['user-agent'];
+  const ua = request.headers['user-agent'] ?? 'unknown/1.0';
-  const headers = getStringHeaders(request.headers);
 
+  const headers = getStringHeaders(request.headers);
   const identity = getIdentity(validatedBody);
   const profileId = identity?.profileId;
 
-  // We might get a profileId from the alias table
-  // If we do, we should use that instead of the one from the payload
   if (profileId && validatedBody.type === 'track') {
     validatedBody.payload.profileId = profileId;
   }
 
   // Get geo location (needed for track and identify)
-  const geo = await getGeoLocation(ip);
+  const [geo, salts] = await Promise.all([getGeoLocation(ip), getSalts()]);
 
-  // Generate device IDs if needed (for track)
+  const { deviceId, sessionId } = await getDeviceId({
-  let currentDeviceId: string | undefined;
+    projectId,
-  let previousDeviceId: string | undefined;
+    ip,
-
+    ua,
-  if (validatedBody.type === 'track') {
+    salts,
-    const overrideDeviceId =
+    overrideDeviceId:
-      typeof validatedBody.payload.properties?.__deviceId === 'string'
+      validatedBody.type === 'track' &&
-        ? validatedBody.payload.properties.__deviceId
+      typeof validatedBody.payload?.properties?.__deviceId === 'string'
-        : undefined;
+        ? validatedBody.payload?.properties.__deviceId
-
+        : undefined,
-    const [salts] = await Promise.all([getSalts()]);
+  });
-    currentDeviceId =
-      overrideDeviceId ||
-      (ua
-        ? generateDeviceId({
-            salt: salts.current,
-            origin: projectId,
-            ip,
-            ua,
-          })
-        : '');
-    previousDeviceId = ua
-      ? generateDeviceId({
-          salt: salts.previous,
-          origin: projectId,
-          ip,
-          ua,
-        })
-      : '';
-  }
 
   return {
     projectId,
@@ -181,46 +166,35 @@ async function buildContext(
       isFromPast: timestamp.isTimestampFromThePast,
     },
     identity,
-    currentDeviceId,
+    deviceId,
-    previousDeviceId,
+    sessionId,
     geo,
   };
 }
 
 async function handleTrack(
   payload: ITrackPayload,
-  context: TrackContext,
+  context: TrackContext
 ): Promise<void> {
-  const {
+  const { projectId, deviceId, geo, headers, timestamp, sessionId } = context;
-    projectId,
-    currentDeviceId,
-    previousDeviceId,
-    geo,
-    headers,
-    timestamp,
-  } = context;
-
-  if (!currentDeviceId || !previousDeviceId) {
-    throw new HttpError('Device ID generation failed', { status: 500 });
-  }
 
   const uaInfo = parseUserAgent(headers['user-agent'], payload.properties);
   const groupId = uaInfo.isServer
     ? payload.profileId
       ? `${projectId}:${payload.profileId}`
       : `${projectId}:${generateId()}`
-    : currentDeviceId;
+    : deviceId;
   const jobId = [
     slug(payload.name),
     timestamp.value,
     projectId,
-    currentDeviceId,
+    deviceId,
     groupId,
   ]
     .filter(Boolean)
     .join('-');
 
-  const promises = [];
+  const promises: Promise<unknown>[] = [];
 
   // 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
@@ -241,12 +215,14 @@ async function handleTrack(
         },
         uaInfo,
         geo,
-        currentDeviceId,
+        deviceId,
-        previousDeviceId,
+        sessionId,
+        currentDeviceId: '', // TODO: Remove
+        previousDeviceId: '', // TODO: Remove
       },
       groupId,
       jobId,
-    }),
+    })
   );
 
   await Promise.all(promises);
@@ -254,7 +230,7 @@ async function handleTrack(
 
 async function handleIdentify(
   payload: IIdentifyPayload,
-  context: TrackContext,
+  context: TrackContext
 ): Promise<void> {
   const { projectId, geo, ua } = context;
   const uaInfo = parseUserAgent(ua, payload.properties);
@@ -284,7 +260,7 @@ async function handleIdentify(
 async function adjustProfileProperty(
   payload: IIncrementPayload | IDecrementPayload,
   projectId: string,
-  direction: 1 | -1,
+  direction: 1 | -1
 ): Promise<void> {
   const { profileId, property, value } = payload;
   const profile = await getProfileById(profileId, projectId);
@@ -294,7 +270,7 @@ async function adjustProfileProperty(
 
   const parsed = Number.parseInt(
     pathOr<string>('0', property.split('.'), profile.properties),
-    10,
+    10
   );
 
   if (Number.isNaN(parsed)) {
@@ -304,7 +280,7 @@ async function adjustProfileProperty(
   profile.properties = assocPath(
     property.split('.'),
     parsed + direction * (value || 1),
-    profile.properties,
+    profile.properties
   );
 
   await upsertProfile({
@@ -317,23 +293,44 @@ async function adjustProfileProperty(
 
 async function handleIncrement(
   payload: IIncrementPayload,
-  context: TrackContext,
+  context: TrackContext
 ): Promise<void> {
   await adjustProfileProperty(payload, context.projectId, 1);
 }
 
 async function handleDecrement(
   payload: IDecrementPayload,
-  context: TrackContext,
+  context: TrackContext
 ): Promise<void> {
   await adjustProfileProperty(payload, context.projectId, -1);
 }
 
+async function handleReplay(
+  payload: IReplayPayload,
+  context: TrackContext
+): Promise<void> {
+  if (!context.sessionId) {
+    throw new HttpError('Session ID is required for replay', { status: 400 });
+  }
+
+  const row = {
+    project_id: context.projectId,
+    session_id: context.sessionId,
+    chunk_index: payload.chunk_index,
+    started_at: payload.started_at,
+    ended_at: payload.ended_at,
+    events_count: payload.events_count,
+    is_full_snapshot: payload.is_full_snapshot,
+    payload: payload.payload,
+  };
+  await replayBuffer.add(row);
+}
+
 export async function handler(
   request: FastifyRequest<{
     Body: ITrackHandlerPayload;
   }>,
-  reply: FastifyReply,
+  reply: FastifyReply
 ) {
   // Validate request body with Zod
   const validationResult = zTrackHandlerPayload.safeParse(request.body);
@@ -374,6 +371,9 @@ export async function handler(
     case 'decrement':
       await handleDecrement(validatedBody.payload, context);
       break;
+    case 'replay':
+      await handleReplay(validatedBody.payload, context);
+      break;
     default:
       return reply.status(400).send({
         status: 400,
@@ -382,12 +382,15 @@ export async function handler(
       });
   }
 
-  reply.status(200).send();
+  reply.status(200).send({
+    deviceId: context.deviceId,
+    sessionId: context.sessionId,
+  });
 }
 
 export async function fetchDeviceId(
   request: FastifyRequest,
-  reply: FastifyReply,
+  reply: FastifyReply
 ) {
   const salts = await getSalts();
   const projectId = request.client?.projectId;
@@ -420,20 +423,31 @@ export async function fetchDeviceId(
 
   try {
     const multi = getRedisCache().multi();
-    multi.exists(`bull:sessions:sessionEnd:${projectId}:${currentDeviceId}`);
+    multi.hget(
-    multi.exists(`bull:sessions:sessionEnd:${projectId}:${previousDeviceId}`);
+      `bull:sessions:sessionEnd:${projectId}:${currentDeviceId}`,
+      'data'
+    );
+    multi.hget(
+      `bull:sessions:sessionEnd:${projectId}:${previousDeviceId}`,
+      'data'
+    );
     const res = await multi.exec();
-
     if (res?.[0]?.[1]) {
+      const data = JSON.parse(res?.[0]?.[1] as string);
+      const sessionId = data.payload.sessionId;
       return reply.status(200).send({
         deviceId: currentDeviceId,
+        sessionId,
         message: 'current session exists for this device id',
       });
     }
 
     if (res?.[1]?.[1]) {
+      const data = JSON.parse(res?.[1]?.[1] as string);
+      const sessionId = data.payload.sessionId;
       return reply.status(200).send({
         deviceId: previousDeviceId,
+        sessionId,
         message: 'previous session exists for this device id',
       });
     }
@@ -443,6 +457,7 @@ export async function fetchDeviceId(
 
   return reply.status(200).send({
     deviceId: currentDeviceId,
+    sessionId: '',
     message: 'No session exists for this device id',
   });
 }

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

@@ -191,7 +191,9 @@ export async function polarWebhook(
             where: {
               subscriptionCustomerId: event.data.customer.id,
               subscriptionId: event.data.id,
-              subscriptionStatus: 'active',
+              subscriptionStatus: {
+                in: ['active', 'past_due', 'unpaid'],
+              },
             },
           });
 

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

@@ -1,20 +1,21 @@
-import { isDuplicatedEvent } from '@/utils/deduplicate';
 import type {
   DeprecatedPostEventPayload,
   ITrackHandlerPayload,
 } from '@openpanel/validation';
 import type { FastifyReply, FastifyRequest } from 'fastify';
+import { isDuplicatedEvent } from '@/utils/deduplicate';
 
 export async function duplicateHook(
   req: FastifyRequest<{
     Body: ITrackHandlerPayload | DeprecatedPostEventPayload;
   }>,
-  reply: FastifyReply,
+  reply: FastifyReply
 ) {
   const ip = req.clientIp;
   const origin = req.headers.origin;
   const clientId = req.headers['openpanel-client-id'];
-  const shouldCheck = ip && origin && clientId;
+  const isReplay = 'type' in req.body && req.body.type === 'replay';
+  const shouldCheck = ip && origin && clientId && !isReplay;
 
   const isDuplicate = shouldCheck
     ? await isDuplicatedEvent({

apps/api/src/hooks/is-bot.hook.ts

@@ -44,6 +44,6 @@ export async function isBotHook(
       }
     }
 
-    return reply.status(202).send('OK');
+    return reply.status(202).send();
   }
 }

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

@@ -1,4 +1,3 @@
-import { DEFAULT_IP_HEADER_ORDER } from '@openpanel/common';
 import type { FastifyReply, FastifyRequest } from 'fastify';
 import { path, pick } from 'ramda';
 
@@ -6,7 +5,7 @@ const ignoreLog = ['/healthcheck', '/healthz', '/metrics', '/misc'];
 const ignoreMethods = ['OPTIONS'];
 
 const getTrpcInput = (
-  request: FastifyRequest,
+  request: FastifyRequest
 ): Record<string, unknown> | undefined => {
   const input = path<any>(['query', 'input'], request);
   try {
@@ -18,7 +17,7 @@ const getTrpcInput = (
 
 export async function requestLoggingHook(
   request: FastifyRequest,
-  reply: FastifyReply,
+  reply: FastifyReply
 ) {
   if (ignoreMethods.includes(request.method)) {
     return;
@@ -40,9 +39,8 @@ export async function requestLoggingHook(
       elapsed: reply.elapsedTime,
       headers: pick(
         ['openpanel-client-id', 'openpanel-sdk-name', 'openpanel-sdk-version'],
-        request.headers,
+        request.headers
       ),
-      body: request.body,
     });
   }
 }

apps/api/src/index.ts

@@ -1,27 +1,27 @@
+process.env.TZ = 'UTC';
+
 import compress from '@fastify/compress';
 import cookie from '@fastify/cookie';
 import cors, { type FastifyCorsOptions } from '@fastify/cors';
-import type { FastifyTRPCPluginOptions } from '@trpc/server/adapters/fastify';
+import {
-import { fastifyTRPCPlugin } from '@trpc/server/adapters/fastify';
+  decodeSessionToken,
-import type { FastifyBaseLogger, FastifyRequest } from 'fastify';
+  EMPTY_SESSION,
-import Fastify from 'fastify';
+  type SessionValidationResult,
-import metricsPlugin from 'fastify-metrics';
+  validateSessionToken,
-
+} from '@openpanel/auth';
 import { generateId } from '@openpanel/common';
 import {
   type IServiceClientWithProject,
   runWithAlsSession,
 } from '@openpanel/db';
-import { getCache, getRedisPub } from '@openpanel/redis';
+import { getRedisPub } from '@openpanel/redis';
 import type { AppRouter } from '@openpanel/trpc';
 import { appRouter, createContext } from '@openpanel/trpc';
-
+import type { FastifyTRPCPluginOptions } from '@trpc/server/adapters/fastify';
-import {
+import { fastifyTRPCPlugin } from '@trpc/server/adapters/fastify';
-  EMPTY_SESSION,
+import type { FastifyBaseLogger, FastifyRequest } from 'fastify';
-  type SessionValidationResult,
+import Fastify from 'fastify';
-  decodeSessionToken,
+import metricsPlugin from 'fastify-metrics';
-  validateSessionToken,
-} from '@openpanel/auth';
 import sourceMapSupport from 'source-map-support';
 import {
   healthcheck,
@@ -38,6 +38,7 @@ import exportRouter from './routes/export.router';
 import importRouter from './routes/import.router';
 import insightsRouter from './routes/insights.router';
 import liveRouter from './routes/live.router';
+import manageRouter from './routes/manage.router';
 import miscRouter from './routes/misc.router';
 import oauthRouter from './routes/oauth-callback.router';
 import profileRouter from './routes/profile.router';
@@ -49,8 +50,6 @@ import { logger } from './utils/logger';
 
 sourceMapSupport.install();
 
-process.env.TZ = 'UTC';
-
 declare module 'fastify' {
   interface FastifyRequest {
     client: IServiceClientWithProject | null;
@@ -62,13 +61,16 @@ declare module 'fastify' {
 }
 
 const port = Number.parseInt(process.env.API_PORT || '3000', 10);
+const host =
+  process.env.API_HOST ||
+  (process.env.NODE_ENV === 'production' ? '0.0.0.0' : 'localhost');
 
 const startServer = async () => {
   logger.info('Starting server');
   try {
     const fastify = Fastify({
       maxParamLength: 15_000,
-      bodyLimit: 1048576 * 500, // 500MB
+      bodyLimit: 1_048_576 * 500, // 500MB
       loggerInstance: logger as unknown as FastifyBaseLogger,
       disableRequestLogging: true,
       genReqId: (req) =>
@@ -80,7 +82,7 @@ const startServer = async () => {
     fastify.register(cors, () => {
       return (
         req: FastifyRequest,
-        callback: (error: Error | null, options: FastifyCorsOptions) => void,
+        callback: (error: Error | null, options: FastifyCorsOptions) => void
       ) => {
         // TODO: set prefix on dashboard routes
         const corsPaths = [
@@ -93,7 +95,7 @@ const startServer = async () => {
         ];
 
         const isPrivatePath = corsPaths.some((path) =>
-          req.url.startsWith(path),
+          req.url.startsWith(path)
         );
 
         if (isPrivatePath) {
@@ -114,6 +116,7 @@ const startServer = async () => {
 
         return callback(null, {
           origin: '*',
+          maxAge: 86_400 * 7, // cache preflight for 7 days
         });
       };
     });
@@ -143,9 +146,18 @@ const startServer = async () => {
       instance.addHook('onRequest', async (req) => {
         if (req.cookies?.session) {
           try {
-            const sessionId = decodeSessionToken(req.cookies.session);
+            const sessionId = decodeSessionToken(req.cookies?.session);
             const session = await runWithAlsSession(sessionId, () =>
-              validateSessionToken(req.cookies.session),
+              validateSessionToken(req.cookies.session)
+            );
+            req.session = session;
+          } catch (e) {
+            req.session = EMPTY_SESSION;
+          }
+        } else if (process.env.DEMO_USER_ID) {
+          try {
+            const session = await runWithAlsSession('1', () =>
+              validateSessionToken(null)
             );
             req.session = session;
           } catch (e) {
@@ -160,7 +172,7 @@ const startServer = async () => {
         prefix: '/trpc',
         trpcOptions: {
           router: appRouter,
-          createContext: createContext,
+          createContext,
           onError(ctx) {
             if (
               ctx.error.code === 'UNAUTHORIZED' &&
@@ -194,6 +206,7 @@ const startServer = async () => {
       instance.register(importRouter, { prefix: '/import' });
       instance.register(insightsRouter, { prefix: '/insights' });
       instance.register(trackRouter, { prefix: '/track' });
+      instance.register(manageRouter, { prefix: '/manage' });
       // Keep existing endpoints for backward compatibility
       instance.get('/healthcheck', healthcheck);
       // New Kubernetes-style health endpoints
@@ -203,7 +216,7 @@ const startServer = async () => {
         reply.send({
           status: 'ok',
           message: 'Successfully running OpenPanel.dev API',
-        }),
+        })
       );
     });
 
@@ -252,10 +265,7 @@ const startServer = async () => {
       });
     }
 
-    await fastify.listen({
+    await fastify.listen({ host, port });
-      host: process.env.NODE_ENV === 'production' ? '0.0.0.0' : 'localhost',
-      port,
-    });
 
     try {
       // Notify when keys expires
@@ -263,7 +273,7 @@ const startServer = async () => {
     } catch (error) {
       logger.warn('Failed to set redis notify-keyspace-events', error);
       logger.warn(
-        'If you use a managed Redis service, you may need to set this manually.',
+        'If you use a managed Redis service, you may need to set this manually.'
       );
       logger.warn('Otherwise some functions may not work as expected.');
     }

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

@@ -0,0 +1,132 @@
+import * as controller from '@/controllers/manage.controller';
+import { validateManageRequest } from '@/utils/auth';
+import { activateRateLimiter } from '@/utils/rate-limiter';
+import { Prisma } from '@openpanel/db';
+import type { FastifyPluginCallback, FastifyRequest } from 'fastify';
+
+const manageRouter: FastifyPluginCallback = async (fastify) => {
+  await activateRateLimiter({
+    fastify,
+    max: 20,
+    timeWindow: '10 seconds',
+  });
+
+  fastify.addHook('preHandler', async (req: FastifyRequest, reply) => {
+    try {
+      const client = await validateManageRequest(req.headers);
+      req.client = client;
+    } catch (e) {
+      if (e instanceof Prisma.PrismaClientKnownRequestError) {
+        return reply.status(401).send({
+          error: 'Unauthorized',
+          message: 'Client ID seems to be malformed',
+        });
+      }
+
+      if (e instanceof Error) {
+        return reply
+          .status(401)
+          .send({ error: 'Unauthorized', message: e.message });
+      }
+
+      return reply
+        .status(401)
+        .send({ error: 'Unauthorized', message: 'Unexpected error' });
+    }
+  });
+
+  // Projects routes
+  fastify.route({
+    method: 'GET',
+    url: '/projects',
+    handler: controller.listProjects,
+  });
+
+  fastify.route({
+    method: 'GET',
+    url: '/projects/:id',
+    handler: controller.getProject,
+  });
+
+  fastify.route({
+    method: 'POST',
+    url: '/projects',
+    handler: controller.createProject,
+  });
+
+  fastify.route({
+    method: 'PATCH',
+    url: '/projects/:id',
+    handler: controller.updateProject,
+  });
+
+  fastify.route({
+    method: 'DELETE',
+    url: '/projects/:id',
+    handler: controller.deleteProject,
+  });
+
+  // Clients routes
+  fastify.route({
+    method: 'GET',
+    url: '/clients',
+    handler: controller.listClients,
+  });
+
+  fastify.route({
+    method: 'GET',
+    url: '/clients/:id',
+    handler: controller.getClient,
+  });
+
+  fastify.route({
+    method: 'POST',
+    url: '/clients',
+    handler: controller.createClient,
+  });
+
+  fastify.route({
+    method: 'PATCH',
+    url: '/clients/:id',
+    handler: controller.updateClient,
+  });
+
+  fastify.route({
+    method: 'DELETE',
+    url: '/clients/:id',
+    handler: controller.deleteClient,
+  });
+
+  // References routes
+  fastify.route({
+    method: 'GET',
+    url: '/references',
+    handler: controller.listReferences,
+  });
+
+  fastify.route({
+    method: 'GET',
+    url: '/references/:id',
+    handler: controller.getReference,
+  });
+
+  fastify.route({
+    method: 'POST',
+    url: '/references',
+    handler: controller.createReference,
+  });
+
+  fastify.route({
+    method: 'PATCH',
+    url: '/references/:id',
+    handler: controller.updateReference,
+  });
+
+  fastify.route({
+    method: 'DELETE',
+    url: '/references/:id',
+    handler: controller.deleteReference,
+  });
+};
+
+export default manageRouter;

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

@@ -26,6 +26,7 @@ const trackRouter: FastifyPluginCallback = async (fastify) => {
           type: 'object',
           properties: {
             deviceId: { type: 'string' },
+            sessionId: { type: 'string' },
             message: { type: 'string', optional: true },
           },
         },

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

@@ -9,7 +9,7 @@ import {
 } from '@openpanel/db';
 import { ChartEngine } from '@openpanel/db';
 import { getCache } from '@openpanel/redis';
-import { zChartInputAI } from '@openpanel/validation';
+import { zReportInput } from '@openpanel/validation';
 import { tool } from 'ai';
 import { z } from 'zod';
 
@@ -27,7 +27,10 @@ export function getReport({
     - ${chartTypes.metric}
     - ${chartTypes.bar}
 `,
-    parameters: zChartInputAI,
+    parameters: zReportInput.extend({
+      startDate: z.string().describe('The start date for the report'),
+      endDate: z.string().describe('The end date for the report'),
+    }),
     execute: async (report) => {
       return {
         type: 'report',
@@ -72,7 +75,10 @@ export function getConversionReport({
   return tool({
     description:
       'Generate a report (a chart) for conversions between two actions a unique user took.',
-    parameters: zChartInputAI,
+    parameters: zReportInput.extend({
+      startDate: z.string().describe('The start date for the report'),
+      endDate: z.string().describe('The end date for the report'),
+    }),
     execute: async (report) => {
       return {
         type: 'report',
@@ -94,7 +100,10 @@ export function getFunnelReport({
   return tool({
     description:
       'Generate a report (a chart) for funnel between two or more actions a unique user (session_id or profile_id) took.',
-    parameters: zChartInputAI,
+    parameters: zReportInput.extend({
+      startDate: z.string().describe('The start date for the report'),
+      endDate: z.string().describe('The end date for the report'),
+    }),
     execute: async (report) => {
       return {
         type: 'report',

apps/api/src/utils/auth.ts

@@ -73,7 +73,7 @@ export async function validateSdkRequest(
       clientId,
     )
   ) {
-    throw createError('Ingestion: Clean ID must be a valid UUIDv4');
+    throw createError('Ingestion: Client ID must be a valid UUIDv4');
   }
 
   const client = await getClientByIdCached(clientId);
@@ -236,3 +236,40 @@ export async function validateImportRequest(
 
   return client;
 }
+
+export async function validateManageRequest(
+  headers: RawRequestDefaultExpression['headers'],
+): Promise<IServiceClientWithProject> {
+  const clientId = headers['openpanel-client-id'] as string;
+  const clientSecret = (headers['openpanel-client-secret'] as string) || '';
+
+  if (
+    !/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/.test(
+      clientId,
+    )
+  ) {
+    throw new Error('Manage: Client ID must be a valid UUIDv4');
+  }
+
+  const client = await getClientByIdCached(clientId);
+
+  if (!client) {
+    throw new Error('Manage: Invalid client id');
+  }
+
+  if (!client.secret) {
+    throw new Error('Manage: Client has no secret');
+  }
+
+  if (client.type !== ClientType.root) {
+    throw new Error(
+      'Manage: Only root clients are allowed to manage resources',
+    );
+  }
+
+  if (!(await verifyPassword(clientSecret, client.secret))) {
+    throw new Error('Manage: Invalid client secret');
+  }
+
+  return client;
+}

apps/api/src/utils/ids.ts

@@ -0,0 +1,158 @@
+import crypto from 'node:crypto';
+import { generateDeviceId } from '@openpanel/common/server';
+import { getSafeJson } from '@openpanel/json';
+import { getRedisCache } from '@openpanel/redis';
+
+export async function getDeviceId({
+  projectId,
+  ip,
+  ua,
+  salts,
+  overrideDeviceId,
+}: {
+  projectId: string;
+  ip: string;
+  ua: string | undefined;
+  salts: { current: string; previous: string };
+  overrideDeviceId?: string;
+}) {
+  if (overrideDeviceId) {
+    return { deviceId: overrideDeviceId, sessionId: '' };
+  }
+
+  if (!ua) {
+    return { deviceId: '', sessionId: '' };
+  }
+
+  const currentDeviceId = generateDeviceId({
+    salt: salts.current,
+    origin: projectId,
+    ip,
+    ua,
+  });
+  const previousDeviceId = generateDeviceId({
+    salt: salts.previous,
+    origin: projectId,
+    ip,
+    ua,
+  });
+
+  return await getDeviceIdFromSession({
+    projectId,
+    currentDeviceId,
+    previousDeviceId,
+  });
+}
+
+async function getDeviceIdFromSession({
+  projectId,
+  currentDeviceId,
+  previousDeviceId,
+}: {
+  projectId: string;
+  currentDeviceId: string;
+  previousDeviceId: string;
+}) {
+  try {
+    const multi = getRedisCache().multi();
+    multi.hget(
+      `bull:sessions:sessionEnd:${projectId}:${currentDeviceId}`,
+      'data'
+    );
+    multi.hget(
+      `bull:sessions:sessionEnd:${projectId}:${previousDeviceId}`,
+      'data'
+    );
+    const res = await multi.exec();
+    if (res?.[0]?.[1]) {
+      const data = getSafeJson<{ payload: { sessionId: string } }>(
+        (res?.[0]?.[1] as string) ?? ''
+      );
+      if (data) {
+        const sessionId = data.payload.sessionId;
+        return { deviceId: currentDeviceId, sessionId };
+      }
+    }
+    if (res?.[1]?.[1]) {
+      const data = getSafeJson<{ payload: { sessionId: string } }>(
+        (res?.[1]?.[1] as string) ?? ''
+      );
+      if (data) {
+        const sessionId = data.payload.sessionId;
+        return { deviceId: previousDeviceId, sessionId };
+      }
+    }
+  } catch (error) {
+    console.error('Error getting session end GET /track/device-id', error);
+  }
+
+  return {
+    deviceId: currentDeviceId,
+    sessionId: getSessionId({
+      projectId,
+      deviceId: currentDeviceId,
+      graceMs: 5 * 1000,
+      windowMs: 1000 * 60 * 30,
+    }),
+  };
+}
+
+/**
+ * Deterministic session id for (projectId, deviceId) within a time window,
+ * with a grace period at the *start* of each window to avoid boundary splits.
+ *
+ * - windowMs: 30 minutes by default
+ * - graceMs: 1 minute by default (events in first minute of a bucket map to previous bucket)
+ * - Output: base64url, 128-bit (16 bytes) truncated from SHA-256
+ */
+function getSessionId(params: {
+  projectId: string;
+  deviceId: string;
+  eventMs?: number; // use event timestamp; defaults to Date.now()
+  windowMs?: number; // default 5 min
+  graceMs?: number; // default 1 min
+  bytes?: number; // default 16 (128-bit). You can set 24 or 32 for longer ids.
+}): string {
+  const {
+    projectId,
+    deviceId,
+    eventMs = Date.now(),
+    windowMs = 5 * 60 * 1000,
+    graceMs = 60 * 1000,
+    bytes = 16,
+  } = params;
+
+  if (!projectId) {
+    throw new Error('projectId is required');
+  }
+  if (!deviceId) {
+    throw new Error('deviceId is required');
+  }
+  if (windowMs <= 0) {
+    throw new Error('windowMs must be > 0');
+  }
+  if (graceMs < 0 || graceMs >= windowMs) {
+    throw new Error('graceMs must be >= 0 and < windowMs');
+  }
+  if (bytes < 8 || bytes > 32) {
+    throw new Error('bytes must be between 8 and 32');
+  }
+
+  const bucket = Math.floor(eventMs / windowMs);
+  const offset = eventMs - bucket * windowMs;
+
+  // Grace at the start of the bucket: stick to the previous bucket.
+  const chosenBucket = offset < graceMs ? bucket - 1 : bucket;
+
+  const input = `sess:v1:${projectId}:${deviceId}:${chosenBucket}`;
+
+  const digest = crypto.createHash('sha256').update(input).digest();
+  const truncated = digest.subarray(0, bytes);
+
+  // base64url
+  return truncated
+    .toString('base64')
+    .replace(/\+/g, '-')
+    .replace(/\//g, '_')
+    .replace(/=+$/g, '');
+}

apps/api/src/utils/parseUrlMeta.ts

@@ -72,7 +72,9 @@ interface UrlMetaData {
 
 export async function parseUrlMeta(url: string) {
   try {
-    const metadata = (await urlMetadata(url)) as UrlMetaData;
+    const metadata = (await urlMetadata(url, {
+      timeout: 500,
+    })) as UrlMetaData;
     const data = transform(metadata, url);
     return data;
   } catch (err) {

apps/api/tsconfig.json

@@ -5,7 +5,8 @@
     "paths": {
       "@/*": ["./src/*"]
     },
-    "tsBuildInfoFile": "node_modules/.cache/tsbuildinfo.json"
+    "tsBuildInfoFile": "node_modules/.cache/tsbuildinfo.json",
+    "strictNullChecks": true
   },
   "include": ["."],
   "exclude": ["node_modules", "dist"]

apps/justfuckinguseopenpanel/index.html

@@ -0,0 +1,505 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  
+  <!-- Primary Meta Tags -->
+  <title>Just Fucking Use OpenPanel - Stop Overpaying for Analytics</title>
+  <meta name="title" content="Just Fucking Use OpenPanel - Stop Overpaying for Analytics">
+  <meta name="description" content="Mixpanel costs $2,300/month at scale. PostHog costs $1,982/month. Web-only tools tell you nothing about user behavior. OpenPanel gives you full product analytics for a fraction of the cost, or FREE self-hosted.">
+  <meta name="keywords" content="openpanel, analytics, mixpanel alternative, posthog alternative, product analytics, web analytics, open source analytics, self-hosted analytics">
+  <meta name="author" content="OpenPanel">
+  <meta name="robots" content="index, follow">
+  <link rel="canonical" href="https://justfuckinguseopenpanel.dev/">
+  <link rel="icon" type="image/x-icon" href="/favicon.ico">
+  
+  <!-- Open Graph / Facebook -->
+  <meta property="og:type" content="website">
+  <meta property="og:url" content="https://justfuckinguseopenpanel.dev/">
+  <meta property="og:title" content="Just Fucking Use OpenPanel - Stop Overpaying for Analytics">
+  <meta property="og:description" content="Mixpanel costs $2,300/month at scale. PostHog costs $1,982/month. Web-only tools tell you nothing about user behavior. OpenPanel gives you full product analytics for a fraction of the cost, or FREE self-hosted.">
+  <meta property="og:image" content="/ogimage.png">
+  <meta property="og:image:width" content="1200">
+  <meta property="og:image:height" content="630">
+  <meta property="og:site_name" content="Just Fucking Use OpenPanel">
+  
+  <!-- Twitter -->
+  <meta name="twitter:card" content="summary_large_image">
+  <meta name="twitter:url" content="https://justfuckinguseopenpanel.dev/">
+  <meta name="twitter:title" content="Just Fucking Use OpenPanel - Stop Overpaying for Analytics">
+  <meta name="twitter:description" content="Mixpanel costs $2,300/month at scale. PostHog costs $1,982/month. Web-only tools tell you nothing about user behavior. OpenPanel gives you full product analytics for a fraction of the cost, or FREE self-hosted.">
+  <meta name="twitter:image" content="/ogimage.png">
+  
+  <!-- Additional Meta Tags -->
+  <meta name="theme-color" content="#0a0a0a">
+  <meta name="color-scheme" content="dark">
+  <style>
+    * {
+      margin: 0;
+      padding: 0;
+      box-sizing: border-box;
+    }
+
+    body {
+      background: #0a0a0a;
+      color: #e5e5e5;
+      font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, "Helvetica Neue", Arial, sans-serif;
+      font-size: 18px;
+      line-height: 1.75;
+      padding: 2rem 1.5rem;
+    }
+
+    .container {
+      max-width: 700px;
+      margin: 0 auto;
+    }
+
+    h1 {
+      font-size: 2rem;
+      font-weight: 700;
+      line-height: 1;
+      margin-bottom: 0.5rem;
+      color: #ffffff;
+    }
+
+    h2 {
+      font-size: 1.875rem;
+      font-weight: 800;
+      line-height: 1.3;
+      margin-top: 3rem;
+      margin-bottom: 1.5rem;
+      color: #ffffff;
+    }
+
+    h3 {
+      font-size: 1.5rem;
+      font-weight: 700;
+      line-height: 1.4;
+      margin-top: 2rem;
+      margin-bottom: 1rem;
+      color: #ffffff;
+    }
+
+    p {
+      margin-bottom: 1.25em;
+    }
+
+    strong {
+      font-weight: 700;
+      color: #ffffff;
+    }
+
+    a {
+      color: #3b82f6;
+      text-decoration: underline;
+      text-underline-offset: 2px;
+    }
+
+    a:hover {
+      color: #60a5fa;
+    }
+
+    ul, ol {
+      margin-left: 1.5rem;
+      margin-bottom: 1.25em;
+    }
+
+    li {
+      margin-bottom: 0.5em;
+    }
+
+    blockquote {
+      border-left: 4px solid #3b82f6;
+      padding-left: 1.5rem;
+      margin: 1.5rem 0;
+      font-style: italic;
+      color: #d1d5db;
+    }
+
+    table {
+      width: 100%;
+      border-collapse: collapse;
+      margin: 2rem 0;
+    }
+
+    th, td {
+      padding: 0.75rem;
+      text-align: left;
+      border-bottom: 1px solid #374151;
+    }
+
+    th {
+      font-weight: 700;
+      color: #ffffff;
+      background: #131313;
+    }
+
+    tr:hover {
+      background: #131313;
+    }
+
+    .screenshot {
+      margin: 0 -4rem 4rem;
+      position: relative;
+      z-index: 10;
+    }
+
+    @media (max-width: 840px) {
+      .screenshot {
+        margin: 0;
+      }
+    }
+
+    .screenshot-inner {
+      border-radius: 8px;
+      overflow: hidden;
+      padding: 0.5rem;
+      background: #1a1a1a;
+      border: 1px solid #2a2a2a;
+    }
+
+    .window-controls {
+      display: flex;
+      align-items: center;
+      gap: 0.5rem;
+      margin-bottom: 0.5rem;
+      padding: 0 0.25rem;
+    }
+
+    .window-dot {
+      width: 8px;
+      height: 8px;
+      border-radius: 50%;
+    }
+
+    .window-dot.red {
+      background: #ef4444;
+    }
+
+    .window-dot.yellow {
+      background: #eab308;
+    }
+
+    .window-dot.green {
+      background: #22c55e;
+    }
+
+    .screenshot-image-wrapper {
+      width: 100%;
+      border: 1px solid #2a2a2a;
+      border-radius: 6px;
+      overflow: hidden;
+      background: #0a0a0a;
+    }
+
+    .screenshot img {
+      width: 100%;
+      height: auto;
+      display: block;
+    }
+
+    .cta {
+      background: #131313;
+      border: 1px solid rgba(255, 255, 255, 0.1);
+      border-radius: 8px;
+      padding: 2rem;
+      margin: 3rem 0;
+      text-align: center;
+      margin: 0 -4rem 4rem;
+    }
+
+    @media (max-width: 840px) {
+      .cta {
+        margin: 0;
+      }
+    }
+
+    .cta h2 {
+      margin-top: 0;
+    }
+
+    .cta a {
+      display: inline-block;
+      background: #fff;
+      color: #000;
+      padding: 0.75rem 1.5rem;
+      border-radius: 6px;
+      text-decoration: none;
+      font-weight: 600;
+      margin: 0.5rem;
+      transition: background 0.2s;
+    }
+
+    .cta a:hover {
+      background: #fff;
+      color: #000;
+    }
+
+    footer {
+      margin-top: 4rem;
+      padding-top: 2rem;
+      border-top: 1px solid #374151;
+      text-align: center;
+      color: #9ca3af;
+      font-size: 0.875rem;
+    }
+
+    .hero {
+      text-align: left;
+      margin-top: 4rem;
+      line-height: 1.5;
+    }
+
+    .hero p {
+      font-size: 1.25rem;
+      color: #8f8f8f;
+      margin-top: 1rem;
+    }
+
+    figcaption {
+      margin-top: 1rem;
+      font-size: 0.875rem;
+      text-align: center;
+      color: #9ca3af;
+      max-width: 100%;
+    }
+  </style>
+</head>
+<body>
+  <div class="container">
+    <div class="hero">
+      <h1>Just Fucking Use OpenPanel</h1>
+      <p>Stop settling for basic metrics. Get real insights that actually help you build a better product.</p>
+    </div>
+
+    <figure class="screenshot">
+      <div class="screenshot-inner">
+        <div class="window-controls">
+          <div class="window-dot red"></div>
+          <div class="window-dot yellow"></div>
+          <div class="window-dot green"></div>
+        </div>
+        <div class="screenshot-image-wrapper">
+          <img src="screenshots/realtime-dark.webp" alt="OpenPanel Real-time Analytics" width="1400" height="800">
+        </div>
+      </div>
+      <figcaption>Real-time analytics - see events as they happen. No waiting, no delays.</figcaption>
+    </figure>
+
+    <h2>The PostHog/Mixpanel Problem (Volume Pricing Hell)</h2>
+
+    <p>Let's talk about what happens when you have a <strong>real product</strong> with <strong>real users</strong>.</p>
+
+    <p><strong>Real pricing at scale (20M+ events/month):</strong></p>
+    <ul>
+      <li><strong>Mixpanel</strong>: $2,300/month (and more with add-ons)</li>
+      <li><strong>PostHog</strong>: $1,982/month (and more with add-ons)</li>
+    </ul>
+
+    <p>"1 million free events!" they scream. Cute. Until you have an actual product with actual users doing actual things. Then suddenly you need to "talk to sales" and your wallet starts bleeding.</p>
+
+    <p>Add-ons, add-ons everywhere. Session replay? +$X. Feature flags? +$X. HIPAA compliance? +$250/month. A/B testing? That'll be extra. You're hemorrhaging money just to understand what your users are doing, you magnificent fool.</p>
+
+    <h2>The Web-Only Analytics Trap</h2>
+
+    <p>You built a great fucking product. You have real traffic. Thousands, tens of thousands of visitors. But you're flying blind.</p>
+
+    <blockquote>
+      "Congrats, 50,000 visitors from France this month. Why didn't a single one buy your baguette?"
+    </blockquote>
+
+    <p>You see the traffic. You see the bounce rate. You see the referrers. You see where they're from. You have <strong>NO FUCKING IDEA</strong> what users actually do.</p>
+
+    <p>Where do they drop off? Do they come back? What features do they use? Why didn't they convert? Who the fuck knows! You're using a glorified hit counter with a pretty dashboard that tells you everything about geography and nothing about behavior.</p>
+
+    <p>Plausible. Umami. Fathom. Simple Analytics. GoatCounter. Cabin. Pirsch. They're all the same story: simple analytics with some goals you can define. Page views, visitors, countries, basic funnels. That's it. No retention analysis. No user profiles. No event tracking. No cohorts. No revenue tracking. Just... basic web analytics.</p>
+
+    <p>And when you finally need to understand your users—when you need to see where they drop off in your signup flow, or which features drive retention, or why your conversion rate is shit—you end up paying for a <strong>SECOND tool</strong> on top. Now you're paying for two subscriptions, managing two dashboards, and your users' data is split across two platforms like a bad divorce.</p>
+
+    <h2>Counter One Dollar Stats</h2>
+
+    <p>"$1/month for page views. Adorable."</p>
+
+    <p>Look, I get it. A dollar is cheap. But you're getting exactly what you pay for: page views. That's it. No funnels. No retention. No user profiles. No event tracking. Just... page views.</p>
+
+    <p>Here's the thing: if you want to make <strong>good decisions</strong> about your product, you need to understand <strong>what your users are actually doing</strong>, not just where the fuck they're from.</p>
+
+    <p>OpenPanel gives you the full product analytics suite. Or self-host for <strong>FREE</strong> with <strong>UNLIMITED events</strong>.</p>
+
+    <p>You get:</p>
+    <ul>
+      <li>Funnels to see where users drop off</li>
+      <li>Retention analysis to see who comes back</li>
+      <li>Cohorts to segment your users</li>
+      <li>User profiles to understand individual behavior</li>
+      <li>Custom dashboards to see what matters to YOU</li>
+      <li>Revenue tracking to see what actually makes money</li>
+      <li>All the web analytics (page views, visitors, referrers) that the other tools give you</li>
+    </ul>
+
+    <p>One Dollar Stats tells you 50,000 people visited from France. OpenPanel tells you why they didn't buy your baguette. That's the difference between vanity metrics and actual insights.</p>
+
+    <h2>Why OpenPanel is the Answer</h2>
+
+    <p>You want analytics that actually help you build a better product. Not vanity metrics. Not enterprise pricing. Not two separate tools.</p>
+
+    <p>To make good decisions, you need to understand <strong>what your users are doing</strong>, not just where they're from. You need to see where they drop off. You need to know which features they use. You need to understand why they convert or why they don't.</p>
+
+    <ul>
+      <li><strong>Open Source & Self-Hostable</strong>: AGPL-3.0 - fork it, audit it, own it. Self-host for FREE with unlimited events, or use our cloud</li>
+      <li><strong>Price</strong>: Affordable pricing that scales, or FREE self-hosted (unlimited events, forever)</li>
+      <li><strong>SDK Size</strong>: 2.3KB (PostHog is 52KB+ - that's 22x bigger, you performance-obsessed maniac)</li>
+      <li><strong>Privacy</strong>: Cookie-free by default, EU-only hosting (or your own servers if you self-host)</li>
+      <li><strong>Full Suite</strong>: Web analytics + product analytics in one tool. No need for two subscriptions.</li>
+    </ul>
+
+    <figure class="screenshot">
+      <div class="screenshot-inner">
+        <div class="window-controls">
+          <div class="window-dot red"></div>
+          <div class="window-dot yellow"></div>
+          <div class="window-dot green"></div>
+        </div>
+        <div class="screenshot-image-wrapper">
+          <img src="screenshots/overview-dark.webp" alt="OpenPanel Overview Dashboard" width="1400" height="800">
+        </div>
+      </div>
+      <figcaption>OpenPanel overview showing web analytics and product analytics in one clean interface</figcaption>
+    </figure>
+
+    <h2>Open Source & Self-Hosting: The Ultimate Fuck You to Pricing Hell</h2>
+
+    <p>Tired of watching your analytics bill grow every month? Tired of "talk to sales" when you hit their arbitrary limits? Tired of paying $2,000+/month just to understand your users?</p>
+
+    <p><strong>OpenPanel is open source.</strong> AGPL-3.0 licensed. You can fork it. You can audit it. You can own it. And you can <strong>self-host it for FREE with UNLIMITED events</strong>.</p>
+
+    <p>That's right. Zero dollars. Unlimited events. All the features. Your data on your servers. No vendor lock-in. No surprise bills. No "enterprise sales" calls.</p>
+
+    <p>Mixpanel at 20M events? $2,300/month. PostHog? $1,982/month. OpenPanel self-hosted? <strong>$0/month</strong>. Forever.</p>
+
+    <p>Don't want to manage infrastructure? That's fine. Use our cloud. But if you want to escape the pricing hell entirely, self-hosting is a Docker command away. Your data, your rules, your wallet.</p>
+
+    <h2>The Comparison Table (The Brutal Truth)</h2>
+
+    <table>
+      <thead>
+        <tr>
+          <th>Tool</th>
+          <th>Price at 20M events</th>
+          <th>What You Get</th>
+        </tr>
+      </thead>
+      <tbody>
+        <tr>
+          <td><strong>Mixpanel</strong></td>
+          <td>$2,300+/month</td>
+          <td>Not all feautres... since addons are extra</td>
+        </tr>
+        <tr>
+          <td><strong>PostHog</strong></td>
+          <td>$1,982+/month</td>
+          <td>Not all feautres... since addons are extra</td>
+        </tr>
+        <tr>
+          <td><strong>Plausible</strong></td>
+          <td>Various pricing</td>
+          <td>Simple analytics with basic goals. Page views and visitors. That's it.</td>
+        </tr>
+        <tr>
+          <td><strong>One Dollar Stats</strong></td>
+          <td>$1/month</td>
+          <td>Page views (but cheaper!)</td>
+        </tr>
+        <tr style="background: #131313; border: 2px solid #3b82f6;">
+          <td><strong>OpenPanel</strong></td>
+          <td><strong>~$530/mo or FREE (self-hosted)</strong></td>
+          <td><strong>Web + Product analytics. The full package. Open source. Your data.</strong></td>
+        </tr>
+      </tbody>
+    </table>
+
+    <figure class="screenshot">
+      <div class="screenshot-inner">
+        <div class="window-controls">
+          <div class="window-dot red"></div>
+          <div class="window-dot yellow"></div>
+          <div class="window-dot green"></div>
+        </div>
+        <div class="screenshot-image-wrapper">
+          <img src="screenshots/profile-dark.webp" alt="OpenPanel User Profiles" width="1400" height="800">
+        </div>
+      </div>
+      <figcaption>User profiles - see individual user journeys and behavior. Something web-only tools can't give you.</figcaption>
+    </figure>
+
+    <figure class="screenshot">
+      <div class="screenshot-inner">
+        <div class="window-controls">
+          <div class="window-dot red"></div>
+          <div class="window-dot yellow"></div>
+          <div class="window-dot green"></div>
+        </div>
+        <div class="screenshot-image-wrapper">
+          <img src="screenshots/report-dark.webp" alt="OpenPanel Reports and Funnels" width="1400" height="800">
+        </div>
+      </div>
+      <figcaption>Funnels, retention, and custom reports - the features you CAN'T get with web-only tools</figcaption>
+    </figure>
+
+    <h2>The Bottom Fucking Line</h2>
+
+    <p>If you want to make good decisions about your product, you need to understand what your users are actually doing. Not just where they're from. Not just how many page views you got. You need to see the full picture: funnels, retention, user behavior, conversion paths.</p>
+
+    <p>You have three choices:</p>
+
+    <ol>
+      <li>Keep using Google Analytics like a data-harvesting accomplice, adding cookie banners, annoying your users, and contributing to the dystopian surveillance economy</li>
+      <li>Pay $2,000+/month for Mixpanel or PostHog when you scale, or use simple web-only analytics that tell you nothing about user behavior—just where they're from</li>
+      <li>Use OpenPanel (affordable pricing or FREE self-hosted) and get the full analytics suite: web analytics AND product analytics in one tool, so you can actually understand what your users do</li>
+    </ol>
+
+    <p>If you picked option 1 or 2, I can't help you. You're beyond saving. Go enjoy your complicated, privacy-violating, overpriced analytics life where you know everything about where your users are from but nothing about what they actually do.</p>
+
+    <p>But if you have even one functioning brain cell, you'll realize that OpenPanel gives you everything you need—web analytics AND product analytics—for a fraction of what the enterprise tools cost. You'll finally understand what your users are doing, not just where the fuck they're from.</p>
+
+    <div class="cta">
+      <h2>Ready to understand what your users actually do?</h2>
+      <p>Stop settling for vanity metrics. Get the full analytics suite—web analytics AND product analytics—so you can make better decisions. Or self-host for free.</p>
+      <a href="https://openpanel.dev" target="_blank">Get Started with OpenPanel</a>
+      <a href="https://openpanel.dev/docs/self-hosting/self-hosting" target="_blank">Self-Host Guide</a>
+    </div>
+
+    <figure class="screenshot">
+      <div class="screenshot-inner">
+        <div class="window-controls">
+          <div class="window-dot red"></div>
+          <div class="window-dot yellow"></div>
+          <div class="window-dot green"></div>
+        </div>
+        <div class="screenshot-image-wrapper">
+          <img src="screenshots/dashboard-dark.webp" alt="OpenPanel Custom Dashboards" width="1400" height="800">
+        </div>
+      </div>
+      <figcaption>Custom dashboards - build exactly what you need to understand your product</figcaption>
+    </figure>
+
+    <footer>
+      <p><strong>Just Fucking Use OpenPanel</strong></p>
+      <p>Inspired by <a href="https://justfuckingusereact.com" target="_blank" rel="nofollow">justfuckingusereact.com</a>, <a href="https://justfuckingusehtml.com" target="_blank" rel="nofollow">justfuckingusehtml.com</a>, and <a href="https://justfuckinguseonedollarstats.com" target="_blank" rel="nofollow">justfuckinguseonedollarstats.com</a> and all other just fucking use sites.</p>
+      <p style="margin-top: 1rem;">This is affiliated with <a href="https://openpanel.dev" target="_blank" rel="nofollow">OpenPanel</a>. We still love all products mentioned in this website, and we're grateful for them and what they do 🫶</p>
+    </footer>
+  </div>
+
+  <script>
+    window.op=window.op||function(){var n=[];return new Proxy(function(){arguments.length&&n.push([].slice.call(arguments))},{get:function(t,r){return"q"===r?n:function(){n.push([r].concat([].slice.call(arguments)))}} ,has:function(t,r){return"q"===r}}) }();
+    window.op('init', {
+      clientId: '59d97757-9449-44cf-a8c1-8f213843b4f0',
+      trackScreenViews: true,
+      trackOutgoingLinks: true,
+      trackAttributes: true,
+    });
+  </script>
+  <script src="https://openpanel.dev/op1.js" defer async></script>
+</body>
+</html>

apps/justfuckinguseopenpanel/wrangler.jsonc

@@ -0,0 +1,7 @@
+{
+  "name": "justfuckinguseopenpanel",
+  "compatibility_date": "2025-12-19",
+  "assets": {
+    "directory": "."
+  }
+}

apps/public/content/articles/alternatives-to-mixpanel.mdx

@@ -1,187 +0,0 @@
----
-title: Find an alternative to Mixpanel
-description: A list of alternatives to Mixpanel, including open source and paid options.
-date: 2024-11-12
-updated: 2025-12-02
-team: OpenPanel Team
-tag: Comparison
-cover: /content/cover-alternatives.jpg
----
-
-> Want to understand how people use your website? You might think of using Mixpanel first. But it can be complex and hard to learn.
-
-Think about using something else that's just as good but simpler to use. A tool that makes collecting data easy without the struggle of learning complex features.
-
-Here's what a better website analytics tool can give you:
-- **Confidence**: Make choices based on data
-- **Efficiency**: Work faster with your analytics
-- **Ease**: Less complex, easier to learn
-
-## Understanding Website Analytics
-
-Website analytics helps you collect and understand website data. It shows you how people use your website.
-
-Since 2016, more companies have started using digital analytics. Companies now want to know how users behave, spot patterns, and make better choices using data.
-
-Just counting website visits isn't enough anymore. Understanding how users interact with your website can show you important insights and opportunities.
-
-Good website analytics helps you set goals, track progress, and make your website better. You need tools that are both powerful and easy to use.
-
-These tools turn raw numbers into useful insights, helping you stay ahead of others.
-
-## Introduction to Mixpanel
-
-Mixpanel is a powerful analytics tool that helps marketers, developers, and product managers understand how users behave on their websites and apps.
-
-Started in 2009, this platform changed how we look at data in real-time.
-
-Mixpanel helps teams track user engagement and keep users coming back.
-
-It tracks specific user actions instead of just page views, giving you better insights into what users do.
-
-Its dashboard shows real-time data clearly, helping teams make better decisions.
-
-Mixpanel remains a strong player in analytics, helping businesses improve their online presence.
-
-> See our detailed comparison: [OpenPanel vs Mixpanel](/compare/mixpanel-alternative)
-
-## Limitations of Mixpanel
-
-Despite its strengths, Mixpanel has several problems users need to deal with.
-
-First, [Mixpanel's pricing](/articles/mixpanel-pricing) is often too high. The cost of all its features may not make sense for smaller companies or startups, making it hard for growing businesses to use. Simply put, you might not get enough value for what you pay.
-
-Second, Mixpanel is hard to learn. New users often struggle with its complex interface.
-
-Third, Mixpanel doesn't work well with some important business tools. This makes it hard to connect all your data in one place.
-
-Lastly, setting up event tracking is difficult. Users need to carefully set up tracking for each action they want to monitor, which takes time and can lead to mistakes. This means teams often spend too much time setting things up instead of using the data right away.
-
-## The Need for Simpler Solutions
-
-In today's busy market, having easy-to-use analytics is key for business success.
-
-Simple tools help companies collect and understand data without confusion.
-
-These tools are easy to use and quick to set up, saving time and money. By making data collection and analysis simpler, businesses of any size can use analytics without needing technical experts or long training.
-
-More importantly, simple solutions help small and medium-sized businesses compete better. Good data insights can change how well a business does. With easy-to-use alternatives to Mixpanel, even businesses with small budgets can grow and make smart choices. Using these simple tools lets businesses focus on what matters—growing and succeeding.
-
-## Key Features to Look For
-
-When choosing a Mixpanel alternative, look for these important features:
-- Easy to set up
-- Real-time data
-- Simple to use
-- Good data charts and graphs
-
-First, it should be easy to connect with your website.
-
-The tool should show you data as it happens, helping you make quick decisions.
-
-It should be easy to use. A tool that's simple to understand saves time and is easier to learn.
-
-Good data charts are important. Look for tools that show data in ways that make sense to you.
-
-You should be able to change the tool to fit your needs.
-
-Lastly, it should be worth the money. The best tool gives you good features at a fair price.
-
-## Benefits of a Mixpanel Alternative
-
-Using a simpler alternative to Mixpanel can make your work easier and better.
-
-First, it's more efficient. Simpler tools are faster to learn and use, helping your team work better. When tools are easier to use, people enjoy using them more.
-
-Also, you can save money. Many alternatives do similar things as Mixpanel but cost less, letting you spend money on other important things while still getting good analytics.
-
-Finally, alternatives often let you customize more things to fit your needs. This helps you get better insights and make better plans.
-
-## Cost-Effectiveness
-
-> Choosing a simpler Mixpanel alternative can save you money and help you grow.
-
-The lower prices of many alternatives help you save money. You can use this saved money for other important things while still getting good analytics. These savings add up over time.
-
-**Key Benefits:**
-- Lower prices
-- Fewer extra features you don't need
-- Less training needed
-- Faster to start using
-
-In the end, saving money with alternatives isn't just about the price. By using simpler tools, businesses can balance cost and features better.
-
-## User-Friendly Interface
-
-> A simple, easy-to-use design means you can start using the data quickly, without lots of training.
-
-A big benefit of Mixpanel alternatives is how easy they are to use. This helps everyone use the tool well, no matter their tech skills.
-
-Simple navigation helps you work faster. Users can find what they need quickly and easily. By focusing on the main features, users don't get confused by too many options.
-
-**Impact:** When tools are easy to use, teams can do better work without getting frustrated. Clear dashboards show important information simply.
-
-## Customizable Reports
-
-> Your data, your way. Turn numbers into insights that help you take action.
-
-Custom reports let you see data how you want to. This saves time and helps you understand complex data better.
-
-A good Mixpanel alternative should have:
-- Easy drag-and-drop tools
-- Live data updates
-- Different ways to show charts
-
-## Data Accuracy
-
-> Accurate data helps you trust your analytics.
-
-In website analytics, good data is very important. It affects your decisions and results. With a Mixpanel alternative, getting accurate data is key.
-
-**Important Points:**
-- Data you can trust
-- Regular accuracy checks
-- Ongoing data testing
-- Building trust with your team
-
-## Real-Time Analytics
-
-> In today's fast-moving online world, seeing data right away helps you make better decisions.
-
-These tools let you watch how people use your website as it happens. You don't have to wait for reports; you see everything right away.
-
-**Impact:** Whether you're tracking clicks, page views, or sales, seeing data right away helps you fix problems quickly and find new opportunities.
-
-## Tips for Transitioning
-
-> A good switch starts with a clear plan and ends with confident users.
-
-Start by making a clear plan with goals and timelines. This helps everyone understand what's happening.
-
-**Best Steps:**
-1. Get your team involved early
-2. Train everyone well
-3. Test with a small project first
-4. Keep talking with your team
-5. Find team members who can help others
-
-## Future Trends in Website Analytics
-
-> As websites change, analytics tools are changing too, bringing new ways to understand data.
-
-**Important New Trends:**
-
-**AI tools**
-AI helps businesses not just understand what users did before, but guess what they might do next.
-
-**Privacy first analytics**
-With new privacy laws like GDPR and CCPA, companies are finding new ways to get insights while protecting user privacy.
-
-**Quick data updates**
-Getting data quickly helps businesses make faster, better decisions.
-
-By using these new tools, businesses can better understand their users and do better online.
-
-## Related Articles
-
-Looking for more options? Read our comprehensive guide on [9 best open source web analytics tools](/articles/open-source-web-analytics).

apps/public/content/articles/better-compliance-self-hosted-analytics.mdx

@@ -4,6 +4,7 @@ description: A practical guide to GDPR, CCPA, HIPAA, and other privacy regulatio
 tag: Guide
 team: OpenPanel Team
 date: 2025-12-08
+updated: 2026-02-07
 cover: /content/compliance.jpg
 ---
 
@@ -267,7 +268,7 @@ Self-hosting eliminates third-party data sharing, which simplifies compliance wi
 </FaqItem>
 
 <FaqItem question="Can I migrate from Google Analytics to OpenPanel?">
-Yes. OpenPanel can replace Google Analytics for most use cases. We offer both web analytics and product analytics features. Check our comparison with other platforms like the [Google Analytics alternative](/compare/google-analytics-alternative) page.
+Yes. OpenPanel can replace Google Analytics for most use cases. We offer both [web analytics](/features/web-analytics) and product analytics features. Check our comparison with other platforms like the [Google Analytics alternative](/compare/google-analytics-alternative) page.
 </FaqItem>
 
 <FaqItem question="Is OpenPanel open source?">

apps/public/content/articles/bullmq-alternative.mdx

@@ -1,7 +1,8 @@
 ---
-title: A BullMQ Alternative for Grouped Job Processing
+title: "BullMQ Alternative: GroupMQ for Sequential Job Processing Without Race Conditions"
-description: An open-source queue system that eliminates race conditions through intelligent job grouping, perfect for high-throughput event processing pipelines
+description: "Tired of race conditions with BullMQ? GroupMQ is a free, open-source alternative that processes grouped jobs sequentially — no locks, no Pro license needed."
 date: 2025-10-31
+updated: 2026-02-12
 team: OpenPanel Team
 tag: Article
 cover: /content/bullmq-alternative.jpg
@@ -53,7 +54,7 @@ Here's what makes GroupMQ special:
 
 GroupMQ shines in scenarios where you need to maintain order within related operations:
 
-**Analytics Processing**: Process events from the same user sequentially to maintain accurate session tracking and prevent duplicate counting.
+**Analytics Processing**: Process events from the same user sequentially to maintain accurate [session tracking](/features/session-tracking) and prevent duplicate counting.
 
 **E-commerce Orders**: Handle order updates, payment processing, and inventory changes for the same order ID without race conditions.
 

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

@@ -1,93 +1,195 @@
 ---
-title: Cookieless Analytics
+title: "Cookieless Analytics: Best Tools & How They Work in 2026"
-description: Discover how to gather meaningful insights without cookies and why OpenPanel makes it effortless.
+description: "The complete guide to cookieless analytics platforms. Compare the best cookie-free analytics tools, learn how tracking without cookies works, and find the right solution for your site."
 tag: Guide
 team: OpenPanel Team
 date: 2025-06-17
-updated: 2025-12-02
+updated: 2026-02-16
 cover: /content/cookieless-analytics.jpg
 ---
+import { Faqs, FaqItem } from '@/components/faq';
+import { Figure } from '@/components/figure';
 
-The age of tracking everyone, everywhere, with endless cookies is fading fast. Today’s users expect both useful experiences and respect for their privacy. Enter **cookieless analytics**—a smarter way to understand your audience without leaving a trail of crumbs behind. In this guide, we’ll unpack why this approach matters, and how you can get up and running in minutes with OpenPanel.
+Third-party cookies are dying. Safari and Firefox blocked them years ago. Chrome is finally following through. And privacy regulations keep getting stricter.
 
-## What Is Cookieless Analytics, Really?
+If your analytics still depends on cookies, you're working with incomplete data — and possibly breaking the law. **Cookieless analytics** gives you accurate visitor insights without cookies, consent banners, or compliance headaches.
 
-Put simply, it’s tracking without relying on third-party cookies. Instead of stuffing bits of data into a user’s browser, you pivot to methods like:
+This guide covers how cookieless tracking works, why it matters, and which tools do it best.
 
-* **Server-side events.** Capture interactions directly on your backend.
+## Why Cookies Are Going Away
-* **Session-based identifiers.** Tie actions together during a visit—then discard the identifier when they leave.
-* **First-party data.** Use your own signup forms, preferences, and logs.
-* **Device fingerprints** (used sparingly). Hash together non-identifying signals like screen size and language.
 
-Each of these respects privacy laws and keeps you off users’ “block” lists—without sacrificing insights.
+The shift away from cookies didn't happen overnight. It's been building for years.
 
-## Why Ditch Cookies? Four Big Wins
+### Browser restrictions
 
-### 1. Stay Ahead of Privacy Laws
+Safari's Intelligent Tracking Prevention (ITP) started blocking third-party cookies in 2017. Firefox followed with Enhanced Tracking Protection in 2019. Both browsers now block third-party cookies by default and limit first-party cookie lifetimes.
 
-Regulations like GDPR and CCPA aren’t going away. By design, cookieless systems:
+Chrome — which holds roughly 65% of browser market share — announced its cookie deprecation plans in 2020. After multiple delays, Google is now phasing out third-party cookies through its Privacy Sandbox initiative. The timeline has shifted, but the direction is clear: third-party cookies are on borrowed time.
 
-* Avoid endless consent banners
+### Privacy regulations
-* Keep you clear of hefty fines
-* Show customers you take privacy seriously
 
-### 2. Delight Your Visitors
+GDPR requires explicit consent before setting non-essential cookies. That means cookie banners, consent management platforms, and the constant risk of getting it wrong. Fines can reach €20 million or 4% of global revenue.
 
-Nothing disrupts a first impression like a pop-up you can’t close. With cookieless analytics:
+CCPA, Brazil's LGPD, and similar laws in other regions add their own requirements. The regulatory trend is unmistakable: more restrictions, not fewer.
 
-* Pages load faster
+### Ad blockers and privacy tools
-* There are no nagging “Accept cookies?” prompts
-* Your site works even when someone’s browser is locked down
 
-### 3. Future-Proof Your Data
+Over 40% of internet users run ad blockers or privacy tools. Most of these block analytics cookies too. That means cookie-based analytics is already missing a large chunk of your traffic.
 
-Browsers are phasing out third-party cookies (Safari, Firefox already have). A cookieless stack means:
+### The result
 
-* No last-minute scrambling when Chrome follows suit
+If you're still relying on cookies for analytics, you're getting incomplete data from a shrinking pool of users — and jumping through legal hoops to do it. Cookieless analytics solves all three problems at once.
-* Compatibility with privacy-focused browsers
-* A sustainable analytics foundation
 
-### 4. Cleaner, More Trustworthy Insights
+## How Cookieless Tracking Works
 
-When you rely on your own data sources:
+Cookieless analytics doesn't mean you stop collecting data. It means you collect it differently. Here are the main approaches:
 
-* You reduce duplicate or incomplete sessions
+### Server-side tracking
-* You focus on active, consenting users
-* Your reports match your real user base
 
-## Why OpenPanel Shines for Cookieless Tracking
+Instead of running JavaScript that sets cookies in the browser, server-side tracking captures events on your backend. The user's browser never receives a tracking cookie because the data collection happens on your server.
 
-We built OpenPanel from the ground up with privacy at its heart—and with features you actually need:
+This approach is immune to ad blockers, doesn't require consent banners for basic analytics, and gives you more control over what data you collect.
 
-> See how OpenPanel compares to other cookieless analytics tools: [OpenPanel vs Plausible](/compare/plausible-alternative) | [OpenPanel vs Fathom](/compare/fathom-alternative)
+### Session-based identifiers
 
-### Privacy by Default
+Some tools create a temporary, non-persistent identifier for each visit. This ties actions together during a single session — page views, clicks, form submissions — without storing anything in the browser. When the session ends, the identifier is discarded.
 
-* **Zero cookies.** Ever.
+This gives you meaningful session-level data (bounce rate, pages per visit, conversion paths) without the privacy implications of persistent tracking.
-* **GDPR & CCPA compliant.** Out of the box.
-* **Transparent data policies.** Your users know what’s collected and why.
 
-### Powerful, Yet Simple Analytics
+### First-party data
 
-* **Real-time dashboards.** Watch events as they happen.
+Your own signup forms, user accounts, and preference settings are first-party data. You collected it directly from the user with their knowledge. Cookieless analytics tools can combine anonymous session data with authenticated user data when someone logs in — no cookies needed.
-* **Custom events & properties.** Track anything from “add to wishlist” to “video watched.”
-* **Rich reports.** Dive deep on funnels, retention, and user journeys.
 
-### Plug-and-Play Setup
+### Hashed identifiers
 
-1. **Drop in our script:** Copy–paste, and you’re live.
+Some tools generate a daily hash from non-identifying signals like the visitor's IP address, user agent, and screen size. This lets you count unique visitors without storing personal data or setting cookies. The hash changes daily, so there's no long-term tracking.
-2. **Pick your SDK:** JavaScript, Python, Go… whatever fits.
-3. **Start tracking in minutes.** No extra configuration.
 
-### Open Source & Self-Hosted Option
+OpenPanel uses this approach: a daily rotating hash that counts unique visitors accurately without storing any personal information.
 
-* **Inspect the code.** Full transparency.
+## Best Cookieless Analytics Tools Compared
-* **Self-host if you choose.** Keep data on your servers.
-* **No vendor lock-in.** Export anytime.
 
-## Quick Start: Two Steps to Cookieless Insights
+Not all cookieless analytics tools are the same. Some focus on simple pageview tracking. Others offer full product analytics with funnels, retention, and user journeys. Here's how the main options compare:
 
-1. **Add the tracking snippet**
+| Tool | Type | Cookieless | Open Source | Self-Host | Cloud Pricing (from) | Best For |
+|------|------|-----------|-------------|-----------|---------------------|----------|
+| **OpenPanel** | Web + Product | Yes | Yes (AGPL-3.0) | Free | $2.50/mo | Teams wanting product analytics without cookies |
+| **Plausible** | Web | Yes | Yes (AGPL-3.0) | Free | $9/mo | Simple, lightweight pageview analytics |
+| **Fathom** | Web | Yes | No | No | $15/mo | Privacy-focused teams wanting managed hosting |
+| **Simple Analytics** | Web | Yes | No | No | $9/mo | Simplest possible analytics setup |
+| **Pirsch** | Web | Yes | Yes (AGPL-3.0) | License | $6/mo | Server-side analytics without JavaScript |
+
+### OpenPanel
+
+<Figure
+  src="/content/tools/openpanel.png"
+  caption="OpenPanel's web analytics dashboard — cookieless by default"
+/>
+
+[OpenPanel](/) is an open source analytics platform that combines web analytics and product analytics — all without cookies. You get pageviews and traffic sources alongside funnels, retention, custom events, and user journeys.
+
+**What sets it apart:** Most cookieless tools only track pageviews. OpenPanel gives you Mixpanel-level product analytics (event tracking, [funnels](/features/funnels), [retention](/features/retention), user properties) without setting a single cookie. And you can [self-host it for free](/articles/how-to-self-host-openpanel).
+
+- Zero cookies, ever
+- GDPR and CCPA compliant out of the box
+- Real-time dashboards
+- Custom events and properties
+- Open source with full self-hosting support
+- Starts at $2.50/month on cloud
+
+### Plausible
+
+<Figure
+  src="/content/tools/plausible.png"
+  caption="Plausible's minimal analytics dashboard"
+/>
+
+[Plausible](/compare/plausible-alternative) is a lightweight, privacy-first web analytics tool. It tracks pageviews, referral sources, and basic engagement metrics without cookies.
+
+**Best for:** Sites that need simple traffic stats and nothing more. If you don't need event tracking, funnels, or user-level analytics, Plausible keeps things minimal.
+
+- Under 1 KB script size
+- No cookies, no consent banner needed
+- Self-hostable (community edition)
+- Starts at $9/month on cloud
+
+### Fathom
+
+<Figure
+  src="/content/tools/fathom.png"
+  caption="Fathom's privacy-focused analytics dashboard"
+/>
+
+[Fathom](/compare/fathom-alternative) is a privacy-focused, managed analytics tool. It handles cookieless tracking, EU isolation, and compliance so you don't have to think about it.
+
+**Best for:** Teams that want a fully managed solution with zero maintenance. Fathom handles all the infrastructure and compliance details.
+
+- Cookieless by default
+- EU data isolation available
+- Managed hosting only (no self-host)
+- Starts at $15/month
+
+### Simple Analytics
+
+[Simple Analytics](/compare/simple-analytics-alternative) does exactly what its name suggests: simple, privacy-friendly analytics with no cookies, no tracking scripts on the user's device, and a clean dashboard.
+
+**Best for:** Teams that want the absolute simplest analytics setup. No configuration, no complex features — just traffic data.
+
+- No cookies, no fingerprinting
+- Lightweight script
+- AI-powered insights
+- Starts at $9/month
+
+### Pirsch
+
+<Figure
+  src="/content/tools/pirsch.png"
+  caption="Pirsch's server-side analytics dashboard"
+/>
+
+Pirsch takes a different approach entirely: server-side only analytics. There's no JavaScript snippet to load. Instead, you send events from your backend, which means ad blockers can't interfere.
+
+**Best for:** Developers who want 100% accurate tracking that can't be blocked by browser extensions.
+
+- Server-side only, no JavaScript needed
+- Cookie-free by design
+- Open source core
+- Starts at $6/month
+
+## Cookieless Analytics vs Traditional Analytics
+
+Switching from cookie-based analytics (like Google Analytics) to a cookieless platform isn't just a privacy upgrade. It changes what data you get and how you use it.
+
+### What you gain
+
+**Accurate visitor counts.** Cookie-based analytics misses users who block cookies, use private browsing, or decline consent banners. Cookieless tools track everyone because there's nothing to block or decline.
+
+**No consent banners.** If your analytics tool doesn't set cookies, most privacy laws don't require a consent banner for basic analytics. That means no pop-ups, faster page loads, and better user experience.
+
+**Simpler compliance.** No cookies means no cookie audits, no consent management platforms, no records of consent, and no worrying about which cookies are "strictly necessary." Your legal team will thank you.
+
+**Faster pages.** Cookie-based analytics scripts are typically larger and heavier. Most cookieless tools use lightweight scripts under 5 KB. Some, like Pirsch, use no client-side script at all.
+
+**Future-proof data.** Your analytics won't break when Chrome finishes deprecating third-party cookies. You're already ahead.
+
+### What you lose
+
+**Cross-session user tracking (mostly).** Without persistent cookies, you can't easily track the same anonymous visitor across multiple sessions over weeks or months. If a user visits Monday and returns Thursday, most cookieless tools count that as two separate visitors.
+
+However, this matters less than you think. Once a user logs in or signs up, you can track them across sessions using your own first-party data. Tools like OpenPanel support this with authenticated user identification.
+
+**Some Google Analytics features.** GA's remarketing audiences, cross-domain tracking, and integration with Google Ads all rely on cookies. If you depend on these, you'll need alternative approaches.
+
+**Attribution modeling.** Multi-touch attribution across long time windows gets harder without persistent identifiers. But honestly, cookie-based attribution was never as accurate as people assumed — it was already broken by ad blockers and browser restrictions.
+
+### The bottom line
+
+For most sites, cookieless analytics gives you *more* accurate data (because nothing is blocked) while removing the legal and UX overhead of cookie consent. The tradeoff — less cross-session anonymous tracking — is increasingly irrelevant as cookies disappear anyway.
+
+## Getting Started with Cookieless Analytics
+
+Setting up OpenPanel takes about two minutes. No cookies, no consent banners, no complex configuration.
+
+### 1. Add the tracking snippet
 
 ```html
 <script>
@@ -102,18 +204,54 @@ We built OpenPanel from the ground up with privacy at its heart—and with featu
 <script src="https://openpanel.dev/op1.js" defer async></script>
 ```
 
-2. **Fire off your first event**
+### 2. Track custom events
 
 ```javascript
-// Simple click
 window.op('track', 'signup_button_clicked');
 
-// Purchase with details
 window.op('track', 'order_placed', {
-  orderId: 'ORD-20250617-001',
+  orderId: 'ORD-20260216-001',
   revenue: 49.95,
   currency: 'EUR',
 });
 ```
 
-That’s it—you’re capturing all the user interactions you need, cookie-free.
+That's it. You're collecting analytics data without cookies, without consent banners, and without compromising on the insights you need.
+
+Want full control over your data? You can also [self-host OpenPanel](/articles/how-to-self-host-openpanel) on your own infrastructure for free.
+
+## FAQ
+
+<Faqs>
+<FaqItem question="What is cookieless analytics?">
+Cookieless analytics is a way to track website and app usage without storing cookies in the visitor's browser. Instead, it uses techniques like server-side tracking, session-based identifiers, and hashed signals to collect data. This avoids the need for cookie consent banners and improves compliance with privacy regulations like GDPR and CCPA.
+</FaqItem>
+
+<FaqItem question="Is cookieless analytics GDPR compliant?">
+Cookieless analytics makes GDPR compliance significantly easier. Since no cookies are set, you typically don't need a cookie consent banner for basic analytics. However, GDPR applies to all personal data processing, not just cookies. Choose a tool that minimizes data collection and offers EU data hosting or self-hosting. OpenPanel is GDPR compliant by design — it collects no personal data and can be [self-hosted](/articles/how-to-self-host-openpanel) on your own EU servers.
+</FaqItem>
+
+<FaqItem question="Do I still need a cookie banner with cookieless analytics?">
+For basic analytics, no. Cookie consent banners are required when your site sets non-essential cookies. If your analytics tool doesn't use cookies at all — like OpenPanel, Plausible, or Fathom — you don't need a cookie banner specifically for analytics. You may still need one if other parts of your site use cookies (marketing tools, chat widgets, etc.).
+</FaqItem>
+
+<FaqItem question="How accurate is cookieless analytics compared to Google Analytics?">
+Cookieless analytics is often *more* accurate than Google Analytics for basic metrics like pageviews and unique visitors. That's because cookie-based analytics misses users who block cookies, use ad blockers, or decline consent banners — which can be 30-40% of traffic. Cookieless tools capture these visitors because there's nothing to block or decline.
+</FaqItem>
+
+<FaqItem question="Can cookieless analytics track individual users?">
+Cookieless analytics tracks anonymous sessions by default. However, once a user logs in or identifies themselves, tools like OpenPanel can associate their activity with a user profile using first-party data. This gives you user-level analytics (funnels, retention, journeys) for authenticated users without ever needing a cookie.
+</FaqItem>
+
+<FaqItem question="What is the best cookieless analytics platform?">
+It depends on your needs. For teams that want both web analytics and product analytics (funnels, retention, events) without cookies, [OpenPanel](/) is the best option — it's open source, self-hostable, and starts at $2.50/month. For simple pageview tracking, [Plausible](/compare/plausible-alternative) is the most popular choice. For fully managed, zero-maintenance analytics, [Fathom](/compare/fathom-alternative) is worth considering.
+</FaqItem>
+
+<FaqItem question="Is Google Analytics cookieless?">
+No. Google Analytics (GA4) still uses first-party cookies by default. Google has introduced a "cookieless measurement" mode, but it relies on Google's modeling and machine learning to estimate data — it doesn't actually track without cookies in the same way purpose-built cookieless tools do. For genuine cookieless analytics, you need a tool designed for it from the ground up.
+</FaqItem>
+
+<FaqItem question="Can I use cookieless analytics with a self-hosted setup?">
+Yes. Several cookieless analytics tools support self-hosting, which gives you full data ownership and the strongest possible privacy posture. OpenPanel, Plausible, and Pirsch all offer self-hosted options. With self-hosting, your analytics data never leaves your own servers. See our guide on [self-hosted analytics and compliance](/articles/better-compliance-self-hosted-analytics) for more details.
+</FaqItem>
+</Faqs>

apps/public/content/articles/how-to-create-a-funnel.mdx

@@ -4,11 +4,12 @@ description: Funnels are powerful tools that help you understand how users move
 tag: Guide
 team: OpenPanel Team
 date: 2025-03-31
+updated: 2026-02-07
 cover: /content/funnels.jpg
 ---
 import { Figure } from "@/components/figure";
 
-Funnels are powerful tools that help you understand how users move through your website or app. In this guide, we'll walk you through everything you need to know about creating and using funnels effectively.
+[Funnels](/features/funnels) are powerful tools that help you understand how users move through your website or app. In this guide, we'll walk you through everything you need to know about creating and using funnels effectively.
 
 ## What is a Funnel?
 
@@ -66,7 +67,7 @@ Before you change report type you'll see a linear chart with a line for each eve
 
 ### 4. Understanding Your Funnel Results
 
-When your funnel is ready, you'll see a visualization that tells an important story. Let's say 1,000 people view a recipe - that's the top of your funnel. If 175 of those people save the recipe, your conversion rate is 17.5%. This number tells you how well this part of your process is working.
+When your funnel is ready, you'll see a visualization that tells an important story. Let's say 1,000 people view a recipe - that's the top of your funnel. If 175 of those people save the recipe, your [conversion rate](/features/conversion) is 17.5%. This number tells you how well this part of your process is working.
 
 > In this example we just did a 2-step-funnel, you can have as many steps as you want, but we recommend around 3-5.
 

apps/public/content/articles/how-to-export-data-from-umami.mdx

@@ -2,6 +2,7 @@
 title: How to Export Data from Umami Analytics
 description: Learn how to export your analytics data from Umami for migration or backup
 date: 2025-10-30
+updated: 2026-02-07
 cover: /content/export-data-from-umami.jpg
 tag: Guide
 team: OpenPanel Team
@@ -16,7 +17,7 @@ import { Figure } from '@/components/figure'
   caption="Running the OpenPanel Umami exporter to export analytics data from Umami"
 />
 
-When it comes to web analytics, having control over your data is crucial. Whether you're planning to switch analytics platforms, need to create backups, or want to analyze your data in specialized tools, being able to export your Umami Analytics data is essential.
+When it comes to [web analytics](/features/web-analytics), having control over your data is crucial. Whether you're planning to switch analytics platforms, need to create backups, or want to analyze your data in specialized tools, being able to export your Umami Analytics data is essential.
 
 The challenge is that Umami handles data export differently depending on whether you're using their cloud service or self-hosting. This guide will walk you through both scenarios and help you understand why you might want to consider alternatives like OpenPanel for your analytics needs.
 
@@ -83,7 +84,7 @@ We built OpenPanel with the understanding that modern websites need more than ju
 
 One key difference is real-time data processing. With our platform, you see visitor activity as it happens, not with the delays common in batch-processing systems. This immediacy helps you respond quickly to traffic spikes, marketing campaigns, or technical issues.
 
-Our event tracking goes beyond simple pageviews. You can track custom events, user interactions, and conversion funnels without writing complex code. Our platform automatically captures many interactions that would require manual setup in Umami.
+Our [event tracking](/features/event-tracking) goes beyond simple pageviews. You can track custom events, user interactions, and [conversion funnels](/features/funnels) without writing complex code. Our platform automatically captures many interactions that would require manual setup in Umami.
 
 Our filtering and segmentation capabilities are also more advanced. You can create complex queries to understand specific user segments, compare time periods with more flexibility, and build custom dashboards that focus on your key metrics.
 

apps/public/content/articles/how-to-secure-ubuntu-server.mdx

@@ -4,6 +4,7 @@ description: Learn essential steps to secure your Ubuntu server, including user
 tag: Hosting
 team: OpenPanel Team
 date: 2024-11-14
+updated: 2026-02-12
 cover: /content/secure-server.jpg
 ---
 

apps/public/content/articles/how-to-self-host-openpanel.mdx

@@ -2,7 +2,7 @@
 title: How to Self-Host OpenPanel Analytics Platform
 description: Learn how to self-host OpenPanel web analytics platform. Step-by-step guide to install and configure your own analytics server for better privacy and cost savings.
 date: 2025-02-28
-updated: 2025-12-02
+updated: 2026-02-07
 cover: /content/how-to-self-host-openpanel.jpg
 tag: Guide
 team: OpenPanel Team
@@ -22,7 +22,7 @@ cd openpanel/self-hosting
 
 ## Why Self-Host Your Own Analytics Platform?
 
-Looking for a [Mixpanel alternative](/articles/alternatives-to-mixpanel)? Self-hosting your own web analytics and product analytics platform comes with several benefits. Let's break down the pros and cons of running your own analytics server.
+Looking for a [Mixpanel alternative](/articles/alternatives-to-mixpanel)? Self-hosting your own [web analytics](/features/web-analytics) and product analytics platform comes with several benefits. Let's break down the pros and cons of running your own analytics server.
 
 For a comparison of all open source analytics platforms, see our [comprehensive guide to open source web analytics tools](/articles/open-source-web-analytics).
 

apps/public/content/articles/introduction-to-openpanel.mdx

@@ -4,7 +4,7 @@ description: OpenPanel is a versatile analytics platform that offers a wide arra
 tag: Introduction
 team: OpenPanel Team
 date: 2024-11-09
-updated: 2025-12-02
+updated: 2026-02-07
 ---
 
 Welcome to OpenPanel, the open-source analytics platform designed to be a robust alternative to Mixpanel and a great substitute for Google Analytics. In this article, we'll explore why OpenPanel is the ideal choice for businesses looking to leverage powerful analytics while maintaining control over their data.
@@ -15,7 +15,7 @@ At OpenPanel, we are committed to the principles of open-source software. By mak
 
 ## Why Choose OpenPanel?
 
-Our journey began with a vision to create an open-source alternative to Mixpanel, a tool we admired for its product analytics capabilities. However, as we developed OpenPanel, we realized the potential to offer more comprehensive features that Mixpanel lacked, particularly in the realm of web analytics. While Mixpanel excels in product analytics, it doesn't fully address web analytics needs. OpenPanel bridges this gap by integrating both web and product analytics, providing a holistic view of user behavior.
+Our journey began with a vision to create an open-source alternative to Mixpanel, a tool we admired for its product analytics capabilities. However, as we developed OpenPanel, we realized the potential to offer more comprehensive features that Mixpanel lacked, particularly in the realm of [web analytics](/features/web-analytics). While Mixpanel excels in product analytics, it doesn't fully address web analytics needs. OpenPanel bridges this gap by integrating both web and product analytics, providing a holistic view of user behavior.
 
 For a detailed comparison with other tools, see our guide on [open source web analytics](/articles/open-source-web-analytics).
 
@@ -25,8 +25,8 @@ OpenPanel is a versatile analytics platform that offers a wide array of features
 
 -   **Web Analytics**: Gain insights similar to tools like Plausible, Fathom, and Simple Analytics.
 -   **Product Analytics**: Analyze product usage and user interactions, akin to Mixpanel.
--   **User Retention**: Track and enhance user retention rates.
+-   **[User Retention](/features/retention)**: Track and enhance user retention rates.
--   **Funnels**: Visualize user journeys and conversion paths.
+-   **[Funnels](/features/funnels)**: Visualize user journeys and [conversion paths](/features/conversion).
 -   **Events**: Monitor specific user actions and interactions.
 -   **Profiles**: Create detailed user profiles to better understand your audience.
 -   **Real-Time View**: Display real-time data on a big monitor in your office for dynamic insights.

apps/public/content/articles/mixpanel-alternatives.mdx

@@ -1,7 +1,8 @@
 ---
-title: Mixpanel Alternatives - 4 Best Options for Product Analytics
-description: Looking for Mixpanel alternatives? Compare pricing, features, and privacy options among the best product analytics tools including open-source solutions.
 date: 2025-07-18
+title: "13 Best Mixpanel Alternatives & Competitors in 2026"
+description: "Compare the best Mixpanel alternatives for product analytics in 2026. Side-by-side pricing, features, and privacy comparison of 7 top tools plus 6 honorable mentions — including open source and free options."
+updated: 2026-02-16
 tag: Comparison
 team: OpenPanel Team
 cover: /content/cover-alternatives.jpg
@@ -9,7 +10,7 @@ cover: /content/cover-alternatives.jpg
 import { Faqs, FaqItem } from '@/components/faq';
 import { Figure } from '@/components/figure'
 
-Mixpanel revolutionized product analytics by making it easy to track user behavior beyond simple pageviews. But as powerful as it is, many teams are searching for Mixpanel alternatives that better fit their needs, budget, or privacy requirements.
+Mixpanel revolutionized product analytics by making it easy to track user behavior beyond simple pageviews. But as powerful as it is, many teams are searching for Mixpanel alternatives and competitors that better fit their needs, budget, or privacy requirements. Whether you need a free open source option you can self-host or an affordable cloud tool, there are strong alternatives worth considering in 2026.
 
 The surge in demand for Mixpanel alternatives stems from several pain points that teams frequently encounter:
 
@@ -23,7 +24,21 @@ The surge in demand for Mixpanel alternatives stems from several pain points tha
 
 **Self-hosting Requirements**: Some organizations, particularly in regulated industries, need to keep analytics data within their own infrastructure. Mixpanel's cloud-only approach doesn't accommodate these security and compliance requirements.
 
-In this guide, we'll explore the top 5 Mixpanel alternatives specifically designed for product analytics. Whether you're looking to reduce costs, improve privacy, or gain more flexibility, there's an alternative that fits your needs. If you're also interested in web analytics tools, check out our guide to [open-source web analytics](/articles/open-source-web-analytics).
+In this guide, we'll explore 13 Mixpanel alternatives — 7 in-depth reviews of the strongest competitors plus 6 honorable mentions worth knowing about. Whether you're looking to reduce costs, improve privacy, or gain more flexibility, there's an alternative that fits your needs. If you're also interested in [web analytics](/features/web-analytics) tools, check out our guide to [open-source web analytics](/articles/open-source-web-analytics).
+
+Here's a quick comparison of all 7 top alternatives:
+
+| Tool | Type | Open Source | Self-Host | Free Tier | Paid From | Best For |
+|------|------|-------------|-----------|-----------|-----------|----------|
+| [**OpenPanel**](#1-openpanel---the-privacy-first-alternative) | Web + Product | Yes (AGPL-3.0) | Free | 30-day trial | $2.50/mo | Affordable, privacy-first product analytics |
+| [**PostHog**](#2-posthog---the-all-in-one-platform) | Product + More | Yes (MIT) | Free | 1M events/mo | Usage-based | All-in-one: analytics + replay + flags |
+| [**Heap**](#3-heap---the-autocapture-alternative) | Product | No | No | 10K sessions/mo | ~$3,600/yr | Autocapture and retroactive analysis |
+| [**Amplitude**](#4-amplitude---the-enterprise-alternative) | Product | No | No | 10M events/mo | Contact sales | Enterprise ML-powered analytics |
+| [**Pendo**](#5-pendo---the-product-experience-alternative) | Product + UX | No | No | 500 users | Contact sales | Analytics + in-app guides + feedback |
+| [**Matomo**](#6-matomo---the-privacy-focused-on-premise-alternative) | Web + Product | Yes (GPL-3.0) | Free | Self-hosted free | €23/mo (cloud) | Privacy-first, GDPR-compliant analytics |
+| [**GA4**](#7-google-analytics-4---the-free-enterprise-alternative) | Web + Product | No | No | 25M events/mo | ~$50K/yr (360) | Free analytics at scale, Google ecosystem |
+
+Now let's look at what matters when choosing a Mixpanel alternative, then dive deep into each tool.
 
 <Figure
   src="/content/mixpanel.png"
@@ -37,9 +52,9 @@ Before diving into specific tools, let's establish what features are essential f
 
 ### Core Product Analytics Features
 
-**Event Tracking**: The foundation of product analytics. You need to track custom events like signups, purchases, feature usage, and any user action that matters to your business. The tool should support [event properties and user properties](/docs/api/track#tracking-events) for rich data collection.
+**[Event Tracking](/features/event-tracking)**: The foundation of product analytics. You need to track custom events like signups, purchases, feature usage, and any user action that matters to your business. The tool should support [event properties and user properties](/docs/api/track#tracking-events) for rich data collection.
 
-**Funnel Analysis**: Understanding conversion rates through multi-step processes is crucial. Whether it's onboarding, checkout, or feature adoption, you need to visualize where users drop off and optimize accordingly.
+**[Funnel Analysis](/features/funnels)**: Understanding [conversion rates](/features/conversion) through multi-step processes is crucial. Whether it's onboarding, checkout, or feature adoption, you need to visualize where users drop off and optimize accordingly.
 
 **Retention Analytics**: Track how often users return and engage with your product over time. Look for cohort analysis, retention curves, and the ability to segment users by behavior patterns.
 
@@ -98,7 +113,7 @@ All plans include unlimited websites, team members, and 5 years of data retentio
 
 **Funnel Builder**: Create multi-step funnels to analyze conversion rates. Visualize drop-off points and optimize user flows.
 
-**Retention Analysis**: Understand user stickiness with cohort retention charts. Track daily, weekly, or monthly retention patterns.
+**[Retention Analysis](/features/retention)**: Understand user stickiness with cohort retention charts. Track daily, weekly, or monthly retention patterns.
 
 **Individual User Profiles**: Drill down into specific user journeys. See complete event timelines for debugging or customer support.
 
@@ -338,6 +353,181 @@ Amplitude's pricing isn't publicly available for paid tiers, but their free tier
 - Teams needing advanced data governance
 - Organizations with large free tier requirements
 
+## 5. Pendo - The Product Experience Alternative
+
+### Overview
+
+Pendo goes beyond traditional product analytics by combining behavioral tracking with in-app guidance, user feedback, and product planning tools. It's designed for product managers who want to understand how users interact with their product and then act on those insights directly within the application.
+
+Where Mixpanel focuses purely on analytics, Pendo helps you close the loop: analyze behavior, then deploy targeted in-app guides, tooltips, and announcements to improve adoption and onboarding without writing code.
+
+- **Homepage**: [pendo.io](https://pendo.io)
+- **Free Tier**: Up to 500 monthly active users
+- **License**: Proprietary
+
+### Pricing
+
+Pendo's pricing is based on monthly active users (MAUs) rather than events:
+
+| Plan | MAUs | Price | Features |
+|------|------|-------|----------|
+| Free | Up to 500 | $0 | Core analytics, 1 guide |
+| Base | Custom | Contact sales | Analytics, guides, NPS |
+| Core | Custom | Contact sales | Full platform, roadmapping |
+| Pulse | Custom | Contact sales | Enterprise features, SLAs |
+
+*Note: Pendo's paid plans typically start at $7,000-12,000/year depending on MAU count and features.*
+
+### Key Features
+
+**Product Analytics**: Event tracking, funnels, paths, and retention analysis similar to Mixpanel's core offering.
+
+**In-App Guides**: Create tooltips, walkthroughs, and onboarding flows without code. Target users based on behavior segments.
+
+**NPS & Surveys**: Collect user feedback directly within your product with built-in NPS, polls, and surveys.
+
+**Product Planning**: Roadmapping tools that connect user feedback and analytics data to product decisions.
+
+**Session Replay**: Watch user sessions to understand behavior in context (add-on feature).
+
+### Pros
+- Combines analytics with actionable in-app guidance
+- No-code guide builder for product managers
+- Built-in NPS and user feedback collection
+- Strong onboarding optimization capabilities
+- Good mobile analytics support
+
+### Cons
+- Expensive — paid plans start at $7,000+/year
+- Not open source — full vendor lock-in
+- Analytics are less deep than dedicated tools like Mixpanel
+- Heavier SDK can impact page performance
+- Free tier limited to 500 MAUs
+
+<Faqs>
+<FaqItem question="How does Pendo compare to Mixpanel for analytics?">
+Mixpanel is stronger for pure analytics — deeper funnels, more flexible queries, and better data exploration. Pendo's analytics are competent but simpler. The real value of Pendo is combining analytics with in-app guides and feedback, which Mixpanel doesn't offer at all.
+</FaqItem>
+<FaqItem question="Can Pendo replace Mixpanel entirely?">
+For teams that primarily need basic product analytics plus in-app guidance, yes. But if you rely heavily on advanced event analysis, custom queries, or detailed funnel breakdowns, you may find Pendo's analytics too limited and still need a dedicated tool alongside it.
+</FaqItem>
+<FaqItem question="Is Pendo worth the price?">
+Pendo is one of the most expensive options in this list. It's worth it if you actively use the in-app guide and feedback features — that's where the unique value lies. If you only need analytics, there are much more affordable alternatives like OpenPanel or PostHog.
+</FaqItem>
+</Faqs>
+
+### Best For
+- Product managers who need analytics plus in-app guidance
+- Teams optimizing user onboarding without engineering resources
+- Companies that want to collect user feedback alongside behavioral data
+- Organizations willing to pay premium prices for an integrated product experience platform
+
+## 6. Matomo - The Privacy-Focused On-Premise Alternative
+
+### Overview
+
+Matomo (formerly Piwik) is one of the longest-standing open-source analytics platforms, used by over 1 million websites worldwide. Unlike Mixpanel, Matomo was built with privacy at its core — it's the go-to choice for government agencies, universities, and organizations in regulated industries that need full GDPR compliance without legal uncertainty.
+
+While Matomo started as a web analytics tool (and still excels there), it has expanded into product analytics territory with features like custom events, funnels, and cohort analysis. It's not as deep as Mixpanel for product analytics, but for teams that need both web and product analytics with complete data ownership, Matomo is a proven choice. See our detailed [OpenPanel vs Matomo comparison](/compare/matomo-alternative) for a feature-by-feature breakdown.
+
+- **Homepage**: [matomo.org](https://matomo.org)
+- **GitHub**: [github.com/matomo-org/matomo](https://github.com/matomo-org/matomo)
+- **License**: GPL-3.0 (fully open source)
+- **Free Tier**: Self-hosted is free forever
+
+### Pricing
+
+| Plan | Price | Features |
+|------|-------|----------|
+| Self-hosted (On-Premise) | Free | Full platform, unlimited sites, community support |
+| Cloud - Essential | From €23/month | 50k hits, managed hosting, email support |
+| Cloud - Business | From €45/month | 50k hits, advanced features, phone support |
+| Cloud - Enterprise | Contact sales | Custom limits, SLAs, dedicated support |
+
+### Key Features
+
+**Web Analytics**: Comprehensive pageview tracking, referrers, campaigns, and real-time visitors — comparable to Google Analytics.
+
+**Custom Events & Goals**: Track custom events and define conversion goals with multi-step funnels.
+
+**Heatmaps & Session Recording**: Built-in heatmaps, scroll depth, and session replays (premium features on cloud, available as plugins on self-hosted).
+
+**Tag Manager**: Server-side tag manager included, reducing reliance on third-party scripts.
+
+**GDPR Manager**: Built-in tools for data subject access requests, consent management, and data anonymization.
+
+### Pros
+- Battle-tested open-source platform with 15+ years of development
+- 100% data ownership when self-hosted — no data sent to third parties
+- GDPR compliance built in, trusted by EU government agencies
+- Large plugin ecosystem for extending functionality
+- Can import Google Analytics data for easier migration
+
+### Cons
+- Product analytics features are less mature than Mixpanel
+- Self-hosted version requires PHP/MySQL stack and ongoing maintenance
+- Cloud pricing can get expensive at scale (charged per hit)
+- Interface feels dated compared to modern analytics tools
+- Some advanced features (heatmaps, A/B testing) require paid plugins
+
+### Best For
+- Organizations in regulated industries (healthcare, government, finance)
+- Teams migrating from Google Analytics who want data ownership
+- Companies in the EU that need bulletproof GDPR compliance
+- Self-hosting teams already running PHP/MySQL infrastructure
+
+## 7. Google Analytics 4 - The Free Enterprise Alternative
+
+### Overview
+
+Google Analytics 4 (GA4) is the default analytics platform for millions of websites and the most common tool teams already have in place before considering Mixpanel. While GA4 has evolved significantly from Universal Analytics, adding event-based tracking and product analytics features, it still lags behind Mixpanel in areas like user-level analysis, custom funnels, and real-time event debugging.
+
+That said, GA4 is hard to ignore as a Mixpanel alternative purely because of its price tag: free for up to 25 million events per month. For teams on a tight budget that need basic product analytics alongside comprehensive web analytics, GA4 can cover a lot of ground before you need a dedicated tool. For a detailed look at how OpenPanel compares, see our [Google Analytics alternative](/compare/google-analytics-alternative) page.
+
+- **Homepage**: [analytics.google.com](https://analytics.google.com)
+- **Free Tier**: 25 million events per month
+- **License**: Proprietary (Google)
+
+### Pricing
+
+| Plan | Price | Features |
+|------|-------|----------|
+| GA4 (Standard) | Free | 25M events/month, 14 months retention, standard reports |
+| GA4 360 (Enterprise) | From ~$50,000/year | Unlimited events, 50 months retention, SLAs, BigQuery streaming |
+
+### Key Features
+
+**Event-Based Tracking**: GA4 uses an event-driven model similar to Mixpanel — every interaction is an event with parameters.
+
+**Exploration Reports**: Freeform analysis, funnel exploration, path exploration, and cohort analysis — closer to Mixpanel-style ad hoc querying.
+
+**BigQuery Integration**: Export raw event data to BigQuery for custom SQL analysis at no additional cost.
+
+**Predictive Metrics**: ML-powered predictions for purchase probability, churn probability, and revenue forecasts.
+
+**Cross-Platform Tracking**: Unified web and app analytics with Google's identity resolution.
+
+### Pros
+- Free for most businesses (25M events/month is generous)
+- Seamless integration with Google Ads, Search Console, and the Google ecosystem
+- Event-based model is a major improvement over Universal Analytics
+- BigQuery export enables advanced custom analysis
+- Largest community and resource base of any analytics tool
+
+### Cons
+- Not open source — your data lives on Google's servers
+- Privacy concerns: data is used for Google's advertising products
+- Not GDPR-compliant by default (requires careful configuration)
+- Limited to 14 months of data retention on the free tier
+- User-level analysis is restricted compared to Mixpanel
+- Complex setup for accurate event tracking
+
+### Best For
+- Teams that need free analytics at scale
+- Companies already deep in the Google ecosystem (Ads, Search Console)
+- Organizations that need basic product analytics alongside web analytics
+- Businesses where privacy and data ownership are not primary concerns
+
 ## Making the Right Choice
 
 Choosing the right Mixpanel alternative depends on your specific needs:
@@ -373,33 +563,100 @@ Choosing the right Mixpanel alternative depends on your specific needs:
 - You need to collect user feedback and manage feature requests
 - You have the budget for a premium product experience platform
 
+### Choose Matomo if:
+- You need bulletproof GDPR compliance for regulated industries
+- You're migrating from Google Analytics and want data ownership
+- You need a battle-tested open-source platform with a large plugin ecosystem
+- Your team is comfortable with PHP/MySQL self-hosting
+
+### Choose GA4 if:
+- You need free analytics at massive scale (25M events/month)
+- You're already invested in the Google ecosystem (Ads, Search Console, BigQuery)
+- You need basic product analytics alongside comprehensive web analytics
+- Privacy and data ownership are not your primary concerns
+
+## Honorable Mentions
+
+Beyond the seven alternatives above, several other tools are worth considering depending on your specific use case:
+
+### [Countly](https://count.ly/)
+
+An open-source mobile and web analytics platform with a focus on mobile apps. Offers self-hosting, push notifications, crash analytics, and user profiles. Good for mobile-first teams that want a Mixpanel alternative with built-in engagement tools. Community edition is free and open source (AGPL-3.0).
+
+### [Kissmetrics](https://www.kissmetrics.io/)
+
+One of the original Mixpanel competitors, Kissmetrics focuses on revenue-driven analytics for SaaS and ecommerce. It connects user behavior directly to revenue metrics, making it valuable for teams that think in terms of customer lifetime value rather than raw event counts. Pricing starts around $299/month.
+
+### [FullStory](https://www.fullstory.com/)
+
+Combines product analytics with session replay and heatmaps. FullStory's auto-capture approach is similar to Heap's, but with a stronger focus on digital experience intelligence. Best for UX teams and enterprises with budget for premium tooling. No free tier for analytics.
+
+### [Statsig](https://www.statsig.com/)
+
+Built by ex-Facebook engineers, Statsig combines product analytics with feature flags, A/B testing, and experimentation. The analytics layer is newer but the experimentation platform is mature. Generous free tier with 1 million events/month. A strong choice if experimentation is as important to you as analytics.
+
+### [Plausible Analytics](https://plausible.io/)
+
+A lightweight, privacy-first [web analytics tool](/compare/plausible-alternative) that's the opposite of Mixpanel: simple, no cookies, GDPR-compliant by default. It won't replace Mixpanel's product analytics, but if you've realized you only need web analytics (not custom events and funnels), Plausible is a clean, affordable option at $9/month. Also available as open source for self-hosting.
+
+### [Umami](https://umami.is/)
+
+Another lightweight open-source [web analytics alternative](/compare/umami-alternative) focused on simplicity and privacy. Similar to Plausible but fully free and self-hostable. Great for developers who want basic analytics without the complexity. Like Plausible, it's a web analytics tool — not a product analytics replacement for Mixpanel.
+
 ## Migration Considerations
 
 When switching from Mixpanel to any alternative, consider:
 
-**Data Migration**: Most tools allow you to export Mixpanel data and import historical events. Check for migration guides and tools.
+**Data Migration**: Most tools allow you to export Mixpanel data and import historical events. Check for migration guides — we have a dedicated [migrate from Mixpanel](/guides/migrate-from-mixpanel) guide for OpenPanel.
 
-**SDK Compatibility**: Review your current Mixpanel implementation and plan for code changes. Many alternatives offer similar APIs to ease transition.
+**SDK Compatibility**: Review your current Mixpanel implementation and plan for code changes. OpenPanel supports [Next.js](/docs/sdks/nextjs), [React](/docs/sdks/react), [Vue](/docs/sdks/vue), [Python](/docs/sdks/python), and [many more frameworks](/docs/sdks).
 
-**Feature Parity**: List your must-have Mixpanel features and ensure your chosen alternative supports them.
+**Feature Parity**: List your must-have Mixpanel features and ensure your chosen alternative supports them. For a detailed feature-by-feature comparison, see our [OpenPanel vs Mixpanel](/compare/mixpanel-alternative) page.
 
 **Team Training**: Budget time for your team to learn the new tool. Simpler alternatives like OpenPanel require less training than complex platforms like PostHog.
 
-**Cost Analysis**: Calculate total cost including hosting, maintenance, and potential feature add-ons. Don't forget to factor in engineering time for self-hosted solutions.
+**Cost Analysis**: Calculate total cost including hosting, maintenance, and potential feature add-ons. Don't forget to factor in engineering time for [self-hosted solutions](/articles/self-hosted-web-analytics).
 
 ## Conclusion
 
 The best Mixpanel alternative varies based on your priorities and product type:
 
-- **[OpenPanel](https://openpanel.dev)** offers the best balance of features, affordability, and privacy for most teams
+- **[OpenPanel](/compare/mixpanel-alternative)** offers the best balance of features, affordability, and privacy for most teams
-- **PostHog** is ideal if you need an all-in-one platform with session replay and feature flags
+- **[PostHog](/compare/posthog-alternative)** is ideal if you need an all-in-one platform with session replay and feature flags
-- **Heap** suits enterprises that value retroactive analysis and can afford premium pricing
+- **[Heap](/compare/heap-alternative)** suits enterprises that value retroactive analysis and can afford premium pricing
-- **Amplitude** works for high-volume products that fit within the generous free tier
+- **[Amplitude](/compare/amplitude-alternative)** works for high-volume products that fit within the generous free tier
 - **Pendo** is perfect for teams that need analytics plus in-app guidance and user onboarding
+- **[Matomo](/compare/matomo-alternative)** is the go-to choice for GDPR compliance and regulated industries
+- **GA4** is unbeatable on price if you're already in the Google ecosystem
 
 The key is understanding what you actually need versus what sounds impressive. Many teams pay for complex analytics platforms but only use basic features. Start with your real requirements, not aspirational ones, and you'll find the right Mixpanel alternative for your needs.
 
-**Also consider:** If you're primarily tracking website traffic rather than product events, check out our guide to [open-source web analytics tools](/articles/open-source-web-analytics) for simpler alternatives like Plausible, Umami, and Matomo.
+**Also consider:** If you're primarily tracking website traffic rather than product events, check out our guide to [open-source web analytics tools](/articles/open-source-web-analytics) for simpler alternatives like [Plausible](/compare/plausible-alternative), [Umami](/compare/umami-alternative), and [Matomo](/compare/matomo-alternative).
 
 Ready to try a simpler, more affordable approach to product analytics? [Start your free trial of OpenPanel](https://dashboard.openpanel.dev/onboarding) and see how easy analytics can be.
 
+## Frequently Asked Questions
+
+<Faqs>
+<FaqItem question="What is the best free Mixpanel alternative?">
+For most teams, **OpenPanel** is the best free Mixpanel alternative because you can [self-host it](/articles/how-to-self-host-openpanel) with no feature limitations. PostHog also offers a generous free tier of 1 million events per month on their cloud, and Amplitude gives you 10 million events free (though paid plans are opaque). If you just need web analytics without product analytics features, [Plausible](/compare/plausible-alternative) and Umami are excellent free open-source options.
+</FaqItem>
+<FaqItem question="What is the best open source Mixpanel alternative?">
+**OpenPanel** (AGPL-3.0) and **PostHog** (MIT) are the two leading [open source analytics](/articles/open-source-web-analytics) alternatives to Mixpanel. OpenPanel is lighter-weight and more affordable, while PostHog offers more features (session replay, feature flags) at the cost of complexity and higher resource requirements.
+</FaqItem>
+<FaqItem question="How much does Mixpanel cost in 2026?">
+Mixpanel offers a free plan with 20 million events per month (increased from 100k). Paid Growth plans start at $28/month for additional features like unlimited saved reports and advanced analytics. At scale, costs grow quickly — tracking 1 million events on the Growth plan costs approximately $779/month. See our full [Mixpanel pricing breakdown](/articles/mixpanel-pricing) for details.
+</FaqItem>
+<FaqItem question="Can I self-host a Mixpanel alternative?">
+Yes. OpenPanel and PostHog both offer full [self-hosted deployments](/docs/self-hosting/self-hosting). OpenPanel can run on a single VPS with minimal resources, while PostHog requires more infrastructure (16GB+ RAM). Self-hosting gives you complete data ownership, GDPR compliance by design, and eliminates recurring SaaS costs.
+</FaqItem>
+<FaqItem question="Which Mixpanel alternative is best for startups?">
+**OpenPanel** is the best choice for most startups because of its low pricing ($2.50/mo starting) and the option to self-host for free. PostHog's free tier (1M events) is also attractive for early-stage startups. Amplitude's 10M event free tier works well if you don't need self-hosting. Avoid Heap and Pendo for startups — their pricing starts in the thousands per year.
+</FaqItem>
+<FaqItem question="What's the easiest Mixpanel alternative to set up?">
+OpenPanel is the easiest to get started with — cloud setup takes under 5 minutes, and the SDK is lightweight. PostHog cloud is also quick to set up. Self-hosting adds complexity for both tools, but OpenPanel's single Docker Compose deployment is simpler than PostHog's multi-service architecture.
+</FaqItem>
+<FaqItem question="Do Mixpanel alternatives support mobile analytics?">
+Yes. OpenPanel has SDKs for [React Native](/docs/sdks/react-native), [Swift](/docs/sdks/swift) (iOS), and [Kotlin](/docs/sdks/kotlin) (Android). PostHog supports iOS, Android, React Native, and Flutter. Amplitude and Pendo also have strong mobile SDKs. Heap supports mobile via their autocapture SDK.
+</FaqItem>
+</Faqs>

apps/public/content/articles/mixpanel-pricing.mdx

@@ -1,54 +1,90 @@
 ---
-title: Mixpanel Pricing
+title: "Mixpanel Pricing 2026: Free Plan, Growth Costs & Full Breakdown"
-description: A complete breakdown of Mixpanel's pricing plans, what's included, hidden costs to watch for, and how it compares to alternatives like OpenPanel.
+description: "Complete guide to Mixpanel pricing in 2026. Free plan (1M events), Growth plan ($0.00028/event), Enterprise, hidden add-on costs, and how it compares to OpenPanel."
 tag: Guide
 team: OpenPanel Team
 date: 2025-12-08
+updated: 2026-02-13
 cover: /content/mixpanel-pricing-cover.jpg
 ---
 
-Mixpanel is one of the most popular product analytics tools out there. It's powerful, well-designed, and used by thousands of companies. But before you commit, you probably want to understand exactly what you'll be paying.
+Mixpanel pricing starts with a free plan capped at **1 million monthly events**. The Growth plan charges **$0.00028 per event** ($0.28 per 1,000 events) after 1M free events, with costs reaching ~$2,520/month at 10 million events. Enterprise pricing requires contacting sales and typically starts around $25,000/year.
 
-Mixpanel's pricing has gone through several changes over the years. They've made it more transparent recently, which is great. But there are still some things that aren't immediately obvious when you're looking at their pricing page.
+Here's the quick overview:
 
-In this guide, we'll break down exactly how Mixpanel pricing works, what you get at each tier, and some things to watch out for as your usage grows.
+| Plan | Monthly Events | Price | Best For |
+|------|---------------|-------|----------|
+| **Free** | Up to 1M | $0 | Small projects, MVPs |
+| **Growth** | 1M free, up to 20M | From $0 (scales with usage) | Growing companies |
+| **Enterprise** | Unlimited | Custom (from ~$25K/year) | Large organizations |
+
+Now let's break down exactly what you get at each tier, what the hidden costs are, and whether Mixpanel is worth the price for your use case.
 
 ## How Mixpanel Pricing Works
 
-Mixpanel uses event-based pricing. This means you pay based on the number of events you track, not the number of users on your team or the number of projects you have.
+Mixpanel uses **event-based pricing**. You pay based on the number of events you track, not the number of users on your team or the number of projects you have.
 
-An "event" is any user action you decide to track. A button click, a page view, a purchase, a sign-up. Each one counts as an event. If you track 10 different actions and have 10,000 monthly active users, you could easily be looking at millions of events per month.
+An "event" is any user action you decide to track: a button click, a page view, a purchase, a sign-up. Each one counts as one event. If you track 10 different actions and have 10,000 monthly active users, you could easily be looking at millions of events per month.
 
-Mixpanel offers three main plans: Free, Growth, and Enterprise.
+This model means your costs scale directly with your product's usage. The more successful your product becomes, the more you pay.
 
 ## Mixpanel Free Plan
 
-The free plan is genuinely generous for getting started. You get up to 20 million events per month, which sounds like a lot. For many small projects and early-stage startups, this is plenty.
+Does Mixpanel have a free tier? **Yes.** The Mixpanel free plan includes up to **1 million monthly events** with core analytics features. It's a decent starting point for small projects and early-stage startups.
 
 Here's what's included in the free plan:
 
-The core analytics features work well. You get access to Insights, Funnels, Flows, and Retention reports. You can create unlimited reports and dashboards. The data is real-time, and you can segment by any property you're tracking.
+- **1M monthly events** — once you hit the cap, you'll need to upgrade
+- **Core analytics** — Insights, [Funnels](/features/funnels), Flows, and [Retention](/features/retention) reports
+- **5 saved reports per seat** — enough to start, but teams feel this limit quickly
+- **10K monthly session replays** — see exactly how users interact with your product
+- **30 Spark AI queries per month** — Mixpanel's AI-powered query builder
+- **Unlimited seats** — no per-user charges
 
-However, there are limitations. You don't get access to some of the more advanced features like behavioral cohorts, saved metrics, or custom properties beyond the basics. The free plan also doesn't include Group Analytics, which is pretty much essential if you're building a B2B product and want to analyze data at the company level rather than just individual users.
+However, the free plan has significant limitations:
 
-There's also no data export on the free plan. If you want to pull your data into a warehouse or analyze it elsewhere, you'll need to upgrade.
+- **No Group Analytics** — essential for B2B products that need account-level analysis
+- **No data export** — you can't pull data into a warehouse
+- **Limited behavioral cohorts** — advanced segmentation requires Growth
+- **No formulas or saved metrics** — basic reporting only
+- **No anomaly detection or root cause analysis**
+- **No multi-touch attribution**
+- **Limited custom properties and borrowed properties**
+- **5 monitoring alerts per project** (Growth gets unlimited)
+
+The free plan works well for validating a product idea or running basic analytics on a small project. But once you need collaboration features, advanced analysis, or your events exceed 1 million per month, you'll need to upgrade.
 
 ## Mixpanel Growth Plan
 
-The Growth plan is where most paying customers land. As of early 2025, Mixpanel made the Growth plan more accessible by including the first 1 million events free each month when you add a credit card.
+The Growth plan is where most paying customers land. It includes the first **1 million events free** each month. After that, you pay approximately **$0.00028 per event** ($0.28 per 1,000 events), with volume discounts available at higher tiers.
 
-After that first million, you pay based on your event volume. The pricing scales something like this:
+Here's how Mixpanel Growth plan pricing scales with event volume:
 
-- 1.5 million events: around $140/month
+| Monthly Events | Estimated Monthly Cost | Cost per 1K Events |
-- 5 million events: around $612.5/month  
+|---------------|----------------------|-------------------|
-- 10 million events: around $1,176/month
+| 1M | $0 (free) | $0.00 |
-- 20 million events: around $2,289/month
+| 2M | ~$280 | ~$0.28 |
+| 5M | ~$1,120 | ~$0.28 |
+| 10M | ~$2,520 | ~$0.28 |
+| 20M | ~$5,320 | ~$0.28 |
+| 20M+ | Contact sales | Volume discounts |
 
-These are approximate figures since Mixpanel's pricing page uses a slider and the exact numbers depend on your specific configuration.
+*Prices are approximate based on Mixpanel's pricing calculator. Annual billing typically offers 10-15% discounts.*
 
-The Growth plan adds several important features over Free. You get full access to advanced analysis tools including multi-touch attribution, formulas, saved metrics, and behavioral cohorts. Custom properties become more flexible. You also get access to experiment analysis and more detailed reporting.
+The Growth plan adds several important features over Free:
 
-One thing to note: these prices are for the core analytics. Add-ons cost extra.
+- **Unlimited saved reports** — no more caps on collaborative analytics
+- **Full behavioral cohorts** — segment users based on actions
+- **20K monthly session replays** (customizable up to 500K)
+- **60 Spark AI queries per month** (double the free plan)
+- **Formulas & saved metrics** — build advanced calculations
+- **Multi-touch attribution** — understand which channels drive conversions
+- **Impact & statistical significance** — measure feature impact
+- **Anomaly detection & root cause analysis** — catch issues early
+- **Unlimited monitoring alerts**
+- **Custom properties and borrowed properties** — full flexibility
+
+One thing to note: these prices are for core analytics only. Several features that many teams consider essential are **paid add-ons** on top of the Growth plan.
 
 <Figure
   src="/content/mixpanel-pricing.png"
@@ -57,7 +93,7 @@ One thing to note: these prices are for the core analytics. Add-ons cost extra.
 
 ## Free vs Growth Plan: What's the Difference?
 
-If you're trying to decide whether to stay on Free or upgrade to Growth, here's a detailed breakdown of what you get with each plan:
+If you're trying to decide whether to stay on Free or upgrade to Growth, here's a detailed breakdown:
 
 | Feature | Free Plan | Growth Plan |
 |---------|-----------|-------------|
@@ -67,72 +103,105 @@ If you're trying to decide whether to stay on Free or upgrade to Growth, here's
 | **Spark AI queries** | 30/month | 60/month |
 | **Behavioral cohorts** | Limited | Full access |
 | **Custom properties** | Limited | Full access |
-| **Formulas & saved metrics** | ❌ | ✅ |
+| **Formulas & saved metrics** | Limited | Full access |
-| **Impact & statistical significance** | ❌ | ✅ |
+| **Impact & statistical significance** | No | Yes |
-| **Multi-touch attribution** | ❌ | ✅ |
+| **Multi-touch attribution** | No | Yes |
 | **Monitoring alerts** | 5 per project | Unlimited |
-| **Anomaly detection** | ❌ | ✅ |
+| **Anomaly detection** | No | Yes |
-| **Root cause analysis** | ❌ | ✅ |
+| **Root cause analysis** | No | Yes |
-| **Experiment reporting** | ❌ | Add-on |
+| **Cart analysis** | No | Yes |
-| **Feature flags** | ❌ | Add-on |
+| **Campaign reporting** | No | Yes |
-| **Account-level analytics** | ❌ | Add-on |
+| **Experiment reporting** | No | Add-on |
-| **Data pipelines** | ❌ | Add-on |
+| **Feature flags** | No | Add-on |
+| **Account-level analytics** | No | Add-on |
+| **Data pipelines** | No | Add-on |
+| **Metric Trees** | No | Add-on |
 | **Lookup tables** | Limited | Full access |
 | **Support** | Email (standard) | Email (24/5) |
 
-The key takeaway: Free is genuinely useful for basic analytics, but once you need advanced features like formulas, cohort analysis, or more than 5 saved reports per person, you'll need to upgrade. And even on Growth, several important features like account-level analytics and data pipelines are still add-ons.
+The bottom line: Free works for basic analytics and small projects. Once you need advanced features like formulas, cohort analysis, unlimited saved reports, or more than 1M monthly events, you'll need Growth. And even on Growth, several important features are still add-ons that cost extra.
 
 ## Mixpanel Enterprise Plan
 
-Enterprise pricing isn't published. You need to contact sales, and pricing depends on your specific needs, event volume, and how good you are at negotiating.
+Enterprise pricing isn't published. You need to contact sales, and the final price depends on your event volume, feature requirements, and negotiation.
 
-Based on publicly available information from sites that track B2B pricing, Enterprise plans typically start around $20,000 per year for MTU-based pricing (monthly tracked users) or around $27,000 per year for 300 million events on event-based pricing.
+Based on publicly available data, **Mixpanel Enterprise plans typically start around $25,000-$30,000 per year** and can go well over $100,000/year for large-scale deployments.
 
-Enterprise adds features like SSO, advanced permissions and data governance, dedicated support, custom contracts, and access to some exclusive reports like Signal and Impact.
+Enterprise adds features that larger organizations need:
 
-If you're a larger organization with compliance requirements or need specific security features, Enterprise is likely where you'll end up.
+- **Unlimited monthly events** — custom volume with no caps
+- **Up to 1 trillion events** capacity
+- **SAML-based SSO & SCIM provisioning** — critical for security-conscious orgs
+- **Advanced data governance** — sensitive data classification & protection
+- **Compartmentalized data access** — granular permissions at the report level
+- **HIPAA compliance tools** — for healthcare companies
+- **Customizable data retention policy** — keep data longer than standard limits
+- **300 Spark AI queries per month**
+- **24/7 support** with faster response SLAs
+- **Slack shared channel support** (add-on)
+- **Dedicated account manager**
+- **Professional services** available
+- **Signal correlation analysis** — advanced analytics
+- **Cross-product analytics** — analyze across multiple products
+- **Data quality monitoring** and verified data
+- **Custom pricing & terms**
+
+If you're a larger organization with compliance requirements, need SSO, or require specific security features, Enterprise is where you'll end up.
 
 ## The Add-Ons That Add Up
 
-Here's where Mixpanel pricing gets a bit tricky. Several features that you might consider core functionality are actually paid add-ons, even on Growth plans.
+Here's where Mixpanel pricing gets tricky. Several features that you might consider core functionality are **paid add-ons**, even on Growth plans:
 
-**Group Analytics** is the big one. If you're building a B2B product, you almost certainly need this. It lets you analyze data at the account or company level, not just individual users. Without it, you can't answer basic questions like "which companies are most engaged?" or "what's our retention by account?" Group Analytics is a separate line item on your bill.
+**Account-Level Behavioral Analytics (Group Analytics)** is the big one. If you're building a B2B product, you almost certainly need this. It lets you analyze data at the account or company level, not just individual users. Without it, you can't answer basic questions like "which companies are most engaged?" or "what's our retention by account?" This is a separate line item on your bill, even on Growth and Enterprise.
 
-**Data Pipelines** is another common add-on. This lets you export your Mixpanel data to a data warehouse like BigQuery, Snowflake, or Redshift. Based on publicly available pricing data, this can add around $19,000+ annually for larger implementations. If you need your analytics data in your warehouse for broader analysis or reporting, this cost adds up.
+**Data Pipelines** is another common add-on. This lets you export your Mixpanel data to a data warehouse like BigQuery, Snowflake, or Redshift. If you need your analytics data in your warehouse for broader analysis, this cost adds up — estimates suggest $19,000+ annually for larger implementations.
 
-**Session Replay** lets you watch recordings of user sessions. It's useful for understanding the context behind your quantitative data, but it's another add-on with its own pricing.
+**Session Replay** beyond the included free tier. Growth includes 20K monthly replays, but if you need more (up to 500K), that's extra.
 
-**Warehouse Connectors** allow you to import data from your warehouse into Mixpanel. Again, separate pricing.
+**Warehouse Connectors** allow you to import data from your warehouse into Mixpanel. Separate pricing.
+
+**Feature Flags** for controlling feature rollouts. Add-on on Growth.
+
+**Experiment Reporting** for A/B testing analysis. Add-on on Growth.
+
+**Metric Trees** for visualizing metric dependencies. Add-on on Growth.
 
 When budgeting for Mixpanel, make sure you factor in which add-ons you'll actually need. The base plan price can be misleading if you end up needing two or three add-ons to do what you want.
 
 ## Mixpanel Startup Program
 
-If you're an early-stage startup, Mixpanel offers a pretty solid deal. Their startup program gives you access to a "Startup Plan" free for one year.
+If you're an early-stage startup, Mixpanel offers a solid deal. Their startup program gives you access to a "Startup Plan" **free for one year**.
 
-To qualify, your company needs to be founded less than 5 years ago, have less than $8 million in total funding, and not have previously redeemed similar offers.
+To qualify:
+- Founded less than **5 years ago**
+- Less than **$8 million** in total funding
+- Haven't redeemed similar offers before
 
 The Startup Plan includes advanced features, Group Analytics, Data Pipelines, Warehouse Connectors, and Session Replay. You get up to 1 billion events over the year and 500,000 session replay recordings.
 
-There's a catch though: you need to start sending data within 90 days of acceptance, or you get removed from the program. And after the year is up, you'll need to move to a paid plan or downgrade to Free.
+There's a catch: you need to start sending data within **90 days** of acceptance, or you get removed. And after the year is up, you'll need to move to a paid plan or downgrade to Free.
 
-It's a good deal if you qualify, but plan ahead for what happens when that first year ends.
+It's a good deal if you qualify, but plan ahead for what happens when that first year ends. Many startups get locked into Mixpanel during this free year and face a significant bill when it expires.
 
 ## When Mixpanel Gets Expensive
 
-Mixpanel's event-based pricing means your costs are directly tied to your growth. The more successful your product becomes, the more you pay. This makes sense from Mixpanel's perspective, but it can create some challenges for growing companies.
+Mixpanel's event-based pricing means your costs are directly tied to your product's growth. Here's a realistic scenario:
 
-Here's a scenario. Let's say you're tracking 15 different events per user. Your product has 50,000 monthly active users, each doing an average of 20 tracked actions per session, with 3 sessions per month. That's 15 × 50,000 × 20 × 3 = 45 million events per month. You've already blown past the free tier and are looking at significant monthly costs.
+Let's say you're tracking 15 different events per user. Your product has 50,000 monthly active users, each doing an average of 20 tracked actions per session, with 3 sessions per month. That's:
+
+**15 × 50,000 × 20 × 3 = 45 million events per month**
+
+At that volume, you're well past the Growth plan's 20M cap and into Enterprise territory — likely looking at $40,000+ per year minimum.
 
 Now imagine you launch a marketing campaign that doubles your user base. Your analytics bill just doubled too.
 
-Some teams respond to this by tracking fewer events or being very selective about what they measure. That's not ideal. You want your analytics to grow with your product, not become a constraint on what you can learn about your users.
+Some teams respond by tracking fewer events or being selective about what they measure. That's not ideal. You want your analytics to grow with your product, not become a constraint on what you can learn about your users.
 
-The other thing that catches people off guard is the gap between the free tier and paid pricing. 20 million events is free. But once you hit 20,000,001 events, you're on a paid plan. The jump can feel steep if you weren't expecting it.
+The other thing that catches people off guard is the cost of add-ons stacking up. Base plan + Group Analytics + Data Pipelines + extra Session Replays can easily 2-3x your expected bill.
 
 ## What Users Say About Mixpanel Pricing
 
-Looking at reviews on G2, Capterra, and similar sites, pricing is one of the most common complaints about Mixpanel. Here are some themes that come up repeatedly:
+Looking at reviews on G2, Capterra, and similar sites, pricing is one of the most common complaints about Mixpanel:
 
 > "The jump from free to paid can be steep." Many users start on the generous free tier, get comfortable with the tool, and then face a significant cost when they outgrow it.
 
@@ -142,100 +211,122 @@ Looking at reviews on G2, Capterra, and similar sites, pricing is one of the mos
 
 > "Pricing forced us to track less." Some users report deliberately limiting their tracking to stay within budget, which defeats the purpose of having comprehensive analytics.
 
-To be fair, there are also plenty of users who think Mixpanel provides good value, especially compared to building custom analytics infrastructure. The complaints tend to come from teams that have scaled beyond the free tier and are comparing costs to alternatives.
+To be fair, many users think Mixpanel provides good value, especially compared to building custom analytics infrastructure. The complaints tend to come from teams that have scaled beyond the free tier and are comparing costs to alternatives.
 
-## Mixpanel vs OpenPanel: A Direct Comparison
+## Mixpanel vs OpenPanel: Pricing Comparison
 
-Since you're reading this on the OpenPanel blog, let's be upfront about how we compare. We built [OpenPanel](/articles/introduction-to-openpanel) specifically as a more affordable alternative to Mixpanel, so we think the comparison is worth making.
+Since you're reading this on the OpenPanel blog, let's be upfront about how we compare. We built [OpenPanel](/articles/introduction-to-openpanel) specifically as a more affordable alternative to Mixpanel.
 
-Here's how the pricing stacks up at different event volumes:
+Here's how pricing stacks up at different event volumes:
 
-| Monthly Events | Mixpanel Growth | OpenPanel Cloud |
+| Monthly Events | Mixpanel Growth | OpenPanel Cloud | Savings |
-|---------------|-----------------|-----------------|
+|---------------|-----------------|-----------------|---------|
-| 100K | ~$28* | $20 |
+| 100K | ~$0 (free tier)* | $20 | — |
-| 500K | ~$70* | $50 |
+| 500K | ~$0 (free tier)* | $50 | — |
-| 1M | Free (with card) | $90 |
+| 1M | $0 (free tier) | $90 | — |
-| 1.5M | ~$140 | $180 |
+| 2.5M | ~$420 | $180 | 57% cheaper |
-| 5M | ~$612 | $250 |
+| 5M | ~$1,120 | $250 | 78% cheaper |
-| 10M | ~$1,176 | $350 |
+| 10M | ~$2,520 | $350 | 86% cheaper |
-| 20M | ~$2,289 | $530 |
+| 20M | ~$5,320 | $530 | 90% cheaper |
-| 50M | Contact sales | $900 |
+| 30M | Contact sales | $680 | — |
+| 50M | Contact sales | $900 | — |
 
-*Mixpanel's free tier covers up to 20M events, but with limited features
+*Mixpanel's free tier covers up to 1M events but with limited features (5 saved reports per seat, no Group Analytics, no data export, limited cohorts).
 
-At 20 million events, OpenPanel is about 77% cheaper than Mixpanel's Growth plan. But the pricing difference is only part of the story.
+At 10 million events, **OpenPanel is ~86% cheaper** than Mixpanel's Growth plan. But the pricing difference is only part of the story.
 
-**What's included matters.** With [OpenPanel pricing](/pricing), everything is included. Unlimited websites, unlimited users, unlimited dashboards. There are no tiers within tiers, no add-ons, no "contact sales for this feature." You pick your event volume and that's your price.
+**Everything is included.** With [OpenPanel pricing](/pricing), all features are included at every tier. Unlimited websites, unlimited users, unlimited dashboards. No tiers within tiers, no add-ons, no "contact sales for this feature." Pick your event volume and that's your price.
 
-**Self-hosting is an option.** If you want to go even further on cost savings, you can [self-host OpenPanel](/articles/how-to-self-host-openpanel) for free. Your only cost is the infrastructure itself, which can be surprisingly affordable. A decent VPS can handle millions of events and costs maybe $20-50/month.
+**Self-hosting is free.** If you want maximum cost control, you can [self-host OpenPanel](/articles/how-to-self-host-openpanel) for free. Your only cost is infrastructure — a decent VPS can handle millions of events for $20-50/month.
 
-**Privacy by default.** OpenPanel uses [cookieless tracking](/articles/cookieless-analytics) out of the box. No cookie consent banners needed. This isn't just about compliance, it means you get more accurate data because you're not losing users who decline cookies.
+**Privacy by default.** OpenPanel uses [cookieless tracking](/articles/cookieless-analytics) out of the box. No cookie consent banners needed. This means more accurate data because you're not losing users who decline cookies.
 
-Obviously, we're biased here. Mixpanel has been around longer, has more integrations, and has a larger team building features. If you need very specific capabilities that only Mixpanel offers, it might be worth the premium. But for most teams doing product analytics, OpenPanel covers the core use cases at a fraction of the cost.
+**No hidden costs.** Mixpanel's Growth plan price is just the starting point once you factor in Group Analytics, Data Pipelines, extra Session Replays, and other add-ons. OpenPanel's price is the full price.
 
-You can see a more detailed comparison on our [Mixpanel alternative](/compare/mixpanel-alternative) page.
+Obviously, we're biased here. Mixpanel has been around longer, has more integrations, and has a larger team. If you need very specific capabilities that only Mixpanel offers, it might be worth the premium. But for most teams doing product analytics, OpenPanel covers the core use cases at a fraction of the cost.
+
+See our full [Mixpanel vs OpenPanel comparison](/compare/mixpanel-alternative) for a feature-by-feature breakdown.
 
 ## Tips for Managing Mixpanel Costs
 
-If you decide Mixpanel is the right tool for you, here are some ways to keep costs under control:
+If you decide Mixpanel is the right tool for you, here are ways to keep costs under control:
 
-**Be intentional about what you track.** Don't track everything just because you can. Define your key metrics and the events that feed into them. You can always add more tracking later if you need it.
+**Be intentional about what you track.** Don't track everything just because you can. Define your key metrics and the events that feed into them. You can always add more tracking later.
 
-**Use the startup program if you qualify.** That free year gives you runway to grow before you need to worry about analytics costs.
+**Use the startup program if you qualify.** That free year gives you runway to grow before analytics costs hit.
 
 **Consider annual billing.** Mixpanel typically offers 10-15% discounts for annual commitments. If you're confident you'll stick with the tool, this is easy savings.
 
-**Audit your tracking regularly.** Over time, teams tend to accumulate tracking that's no longer used. Old features get deprecated, experiments end, but the events keep flowing. A quarterly audit can help you trim unnecessary events.
+**Audit your tracking regularly.** Over time, teams accumulate tracking that's no longer used. Old features get deprecated, experiments end, but the events keep flowing. A quarterly audit can trim unnecessary events.
 
-**Negotiate at renewal.** B2B SaaS pricing is often negotiable, especially at higher volumes. Don't just accept the renewal quote, ask what flexibility exists.
+**Negotiate at renewal.** B2B SaaS pricing is often negotiable, especially at higher volumes. Don't just accept the renewal quote — ask what flexibility exists.
+
+**Evaluate add-on necessity.** Before committing to Group Analytics or Data Pipelines, assess whether you truly need them or if there are workarounds.
 
 ## Making the Decision
 
-Mixpanel is a good product. The analytics are powerful, the UI is well-designed, and there's a reason it's one of the most popular tools in the category.
+Mixpanel is a solid product. The analytics are powerful, the UI is well-designed, and there's a reason it's one of the most popular tools in the category.
 
-But pricing matters. If you're a growing startup watching your runway, or a bootstrapped company keeping costs lean, or an enterprise trying to justify spend to finance, you need to factor in the true cost of your analytics stack.
+But pricing matters. If you're a growing startup watching your runway, a bootstrapped company keeping costs lean, or an enterprise trying to justify spend to finance — you need to understand the true cost of your analytics stack.
 
 The questions to ask yourself:
 
 1. How many events will you realistically track as you grow?
 2. Do you need Group Analytics for B2B analysis?
 3. Do you need data export to a warehouse?
-4. What happens to your budget when your user base doubles?
+4. What's your total cost including add-ons, not just the base plan?
+5. What happens to your budget when your user base doubles?
 
-If the answers to those questions make you nervous about Mixpanel's pricing trajectory, it might be worth looking at alternatives before you're locked in.
+If the answers make you nervous about Mixpanel's pricing trajectory, it's worth looking at alternatives before you're locked in.
 
-[OpenPanel](/) offers a 30-day free trial with no credit card required. You can try it alongside Mixpanel and see which fits better for your needs and budget. And if you want maximum control over costs and data, [self-hosting](/docs/self-hosting/self-hosting) is always an option.
+[OpenPanel](/) offers a 30-day free trial with no credit card required. You can try it alongside Mixpanel and see which fits your needs and budget. And if you want maximum control over costs and data, [self-hosting](/docs/self-hosting/self-hosting) is always an option.
 
 <Faqs>
-<FaqItem question="How much does Mixpanel cost per month?">
+<FaqItem question="How much does Mixpanel cost in 2026?">
-Mixpanel's cost depends on your event volume. The free plan covers up to 20 million events with limited features. The Growth plan starts with 1 million free events (with credit card), then scales from around $28/month for additional events up to $2,289/month for 20 million events. Enterprise pricing requires contacting sales but typically starts around $20,000/year.
+Mixpanel offers three plans in 2026: a Free plan with up to 1M monthly events and limited features, a Growth plan starting at $0 with 1M free events then $0.00028 per event ($0.28 per 1,000 events) scaling up to ~$5,320/month for 20M events, and an Enterprise plan with custom pricing typically starting around $25,000/year. Add-ons like Group Analytics, Data Pipelines, and extra Session Replays cost extra on top of the base plan.
 </FaqItem>
 
-<FaqItem question="Is Mixpanel free to use?">
+<FaqItem question="Does Mixpanel have a free tier?">
-Yes, Mixpanel has a free tier that includes up to 20 million events per month. However, it comes with feature limitations. You don't get Group Analytics, data export, advanced cohorts, or some other features. For basic product analytics on smaller projects, the free tier can work well.
+Yes. Mixpanel's free tier includes up to 1 million monthly events, 5 saved reports per seat, 10,000 monthly session replays, and 30 Spark AI queries per month. Core analytics features like Insights, Funnels, Flows, and Retention reports are included. However, you don't get Group Analytics, data export, advanced cohorts, formulas, multi-touch attribution, or anomaly detection on the free plan.
+</FaqItem>
+
+<FaqItem question="What are the Mixpanel free plan limits?">
+The Mixpanel free plan is limited to 1M monthly events, 5 saved reports per seat, 10K session replays per month, 30 Spark AI queries per month, and 5 monitoring alerts per project. Advanced features like behavioral cohorts, custom properties, formulas, and saved metrics are limited or unavailable. Group Analytics, Data Pipelines, and data export are not included.
+</FaqItem>
+
+<FaqItem question="How much does Mixpanel cost per event?">
+On the Mixpanel Growth plan, you pay approximately $0.00028 per event ($0.28 per 1,000 events) after the first 1 million free monthly events. Volume discounts may be available at higher tiers. Enterprise plans have custom per-event pricing negotiated directly with Mixpanel's sales team.
 </FaqItem>
 
 <FaqItem question="What counts as an event in Mixpanel?">
-An event is any user action you choose to track. This includes button clicks, page views, sign-ups, purchases, form submissions, feature usage, or any custom action you define. Each occurrence counts as one event toward your monthly total.
+An event is any user action you choose to track. This includes button clicks, page views, sign-ups, purchases, form submissions, feature usage, or any custom action you define. Each occurrence counts as one event toward your monthly total. Mixpanel also supports autocapture which automatically tracks events without manual instrumentation.
 </FaqItem>
 
 <FaqItem question="Is Mixpanel worth the price?">
-It depends on your needs and budget. Mixpanel is a powerful tool with excellent analytics capabilities. For well-funded companies that need its specific features, it can be worth it. For cost-conscious teams, the pricing can escalate quickly as you grow. Alternatives like OpenPanel offer similar core functionality at significantly lower prices.
+It depends on your needs and budget. Mixpanel excels at deep product analytics — funnels, retention, cohort analysis, and experimentation. For well-funded companies that need its specific features and can afford the add-ons, it delivers value. For cost-conscious teams or those who need simpler analytics, the pricing can escalate quickly as you grow. Alternatives like OpenPanel offer similar core functionality at significantly lower prices with all features included.
 </FaqItem>
 
 <FaqItem question="Does Mixpanel charge for Group Analytics?">
-Yes. Group Analytics is a paid add-on, even on Growth plans. This feature is essential for B2B products that need to analyze data at the company or account level rather than just individual users. The additional cost isn't prominently displayed on the main pricing page.
+Yes. Group Analytics (account-level behavioral analytics) is a paid add-on on both Growth and Enterprise plans. This feature is essential for B2B products that need to analyze data at the company or account level rather than just individual users. The extra cost is not included in the base plan price shown on Mixpanel's pricing page.
 </FaqItem>
 
 <FaqItem question="How does Mixpanel pricing compare to OpenPanel?">
-OpenPanel is significantly cheaper at most event volumes. At 20 million events, OpenPanel costs $530/month compared to Mixpanel's approximately $2,289/month. OpenPanel also includes all features in every plan with no add-ons, and offers a free self-hosting option.
+OpenPanel is significantly cheaper at most event volumes and includes all features at every tier. At 10 million events, OpenPanel costs $350/month compared to Mixpanel's approximately $2,520/month — about 86% cheaper. OpenPanel also has no add-ons or hidden costs, and offers a free self-hosting option for maximum cost control.
 </FaqItem>
 
 <FaqItem question="Can startups get Mixpanel for free?">
-Yes. Mixpanel's Startup Program offers eligible startups their first year free on the Startup Plan. To qualify, your company must be founded less than 5 years ago and have less than $8 million in total funding. The plan includes advanced features and up to 1 billion events over the year.
+Yes. Mixpanel's Startup Program offers eligible startups their first year free on the Startup Plan. To qualify, your company must be founded less than 5 years ago, have less than $8 million in total funding, and not have redeemed similar offers. The plan includes advanced features and up to 1 billion events over the year. You must start sending data within 90 days of acceptance.
 </FaqItem>
 
 <FaqItem question="What happens if I go over my Mixpanel event limit?">
-On the Growth plan, you'll be charged for additional events at your plan's overage rate. Mixpanel states they don't apply punitive overcharges, you just pay the regular per-event rate. They also have a "forgiveness policy" for events tracked by mistake. On the free plan, exceeding limits may require upgrading to a paid plan.
+On the Growth plan, you'll be charged for additional events at your plan's overage rate. Mixpanel states they don't apply punitive overcharges — you pay the regular per-event rate. They also have a "forgiveness policy" for events tracked by mistake. On the free plan, exceeding the 1M event limit requires upgrading to a paid plan.
 </FaqItem>
-</Faqs>
+
+<FaqItem question="How many Spark AI queries does Mixpanel include?">
+The Free plan includes 30 Spark AI queries per month. The Growth plan doubles this to 60 queries per month. Enterprise plans include 300 Spark AI queries per month. Spark is Mixpanel's AI-powered query builder that lets you ask questions about your data in natural language.
+</FaqItem>
+
+<FaqItem question="What are Mixpanel's pricing alternatives for startups on a budget?">
+For startups looking for affordable product analytics, OpenPanel is a strong alternative starting at $2.50/month for 5,000 events and $90/month for 1M events with all features included. OpenPanel also offers free self-hosting. Other alternatives include PostHog (open source with a free tier) and Amplitude (limited free plan). Unlike Mixpanel, OpenPanel has no add-on costs for features like group analytics or data export.
+</FaqItem>
+</Faqs>

apps/public/content/articles/open-source-web-analytics.mdx

@@ -1,8 +1,8 @@
 ---
-title: 9 best open source web analytics tools
+title: "9 Best Open Source Analytics Tools in 2026 (Compared)"
-description: In an era where data drives decisions, what are your best options for web analytics?
+description: "Comprehensive comparison of the best open source web analytics and product analytics tools in 2026. Self-hosted and cloud options with pricing, features, and honest reviews."
 date: 2024-11-10
-updated: 2025-12-02
+updated: 2026-02-13
 cover: /content/cover-best-web-analytics.jpg
 tag: Comparison
 team: OpenPanel Team
@@ -10,16 +10,36 @@ team: OpenPanel Team
 import { Faqs, FaqItem } from '@/components/faq';
 import { Figure } from '@/components/figure'
 
-In today's data-driven world, understanding your website's performance is crucial for making informed decisions. While Google Analytics dominates the market, many developers and businesses are turning to open source web analytics tools for better privacy, data ownership, and customization.
+The best open source web analytics tools in 2026 are **OpenPanel** (best overall for web + product analytics), **PostHog** (best all-in-one platform), **Plausible** (best for simplicity), and **Matomo** (best Google Analytics replacement). All offer self-hosting, privacy-first tracking, and GDPR compliance.
 
-Open source web analytics solutions offer several advantages over proprietary alternatives:
+Open source analytics tools give you what proprietary platforms like Google Analytics can't: **complete data ownership**, **no vendor lock-in**, **privacy compliance by design**, and **the ability to self-host for free**. Whether you need simple pageview tracking or advanced product analytics with funnels, retention, and session replay — there's an open source solution that fits. If you're specifically looking to replace GA4, see our [Google Analytics alternative comparison](/compare/google-analytics-alternative) and [migration guide](/guides/migrate-from-google-analytics).
-- **Complete data ownership** - Your analytics data stays on your servers
-- **Privacy compliance** - Many are GDPR/CCPA compliant by design
-- **No vendor lock-in** - You can modify and extend the code as needed
-- **Cost control** - Self-host for free or choose affordable hosted options
-- **Transparency** - Open source code means you know exactly what's being tracked
 
-In this comprehensive guide, we've evaluated 9 of the best open source web analytics tools available today. Each tool has been assessed based on features, pricing, ease of use, and community support. Whether you need simple pageview tracking or advanced product analytics, there's an open source solution that fits your needs.
+Here's a quick comparison of all 9 tools:
+
+| Tool | Type | License | Self-Host | Cloud Pricing (from) | Best For |
+|------|------|---------|-----------|---------------------|----------|
+| [**OpenPanel**](#openpanel) | Web + Product | AGPL-3.0 | Free | $2.50/mo | Teams wanting Mixpanel-like analytics, open source |
+| [**PostHog**](#posthog) | Product + Web | MIT | Free | $0 + usage | Developers needing analytics + flags + experiments |
+| [**Plausible**](#plausible) | Web | AGPL-3.0 | Free | $9/mo | Simple, privacy-first pageview analytics |
+| [**Matomo**](#matomo) | Web | GPL-3.0 | Free | €29/mo | Google Analytics replacement with full feature set |
+| [**Fathom**](#fathom) | Web | Proprietary | License | $15/mo | Privacy-focused teams wanting zero maintenance |
+| [**Umami**](#umami) | Web | MIT | Free | $0 + usage | Developers wanting lightweight, self-hosted analytics |
+| [**Ackee**](#ackee) | Web | MIT | Free | None | Minimalist self-hosted tracking |
+| [**Pirsch**](#pirsch) | Web | AGPL-3.0 | License | $6/mo | Server-side analytics without JavaScript |
+| [**Swetrix**](#swetrix) | Web | AGPL-3.0 | Free | $5/mo | Cookieless analytics with performance monitoring |
+
+Now let's dive deep into each tool.
+
+## What to Look for in Open Source Analytics
+
+Before picking a tool, consider these key factors:
+
+- **Web analytics vs product analytics** — Do you just need pageviews and traffic sources, or do you need event tracking, funnels, retention, and user journeys?
+- **Self-hosted vs cloud** — Self-hosting gives you full data control and is often free, but requires server maintenance. Cloud hosting is easier but costs money.
+- **Privacy and compliance** — Does the tool track without cookies? Is it GDPR/CCPA compliant by design?
+- **Ease of setup** — Some tools take minutes to deploy, others need significant DevOps work.
+- **Community and maintenance** — Is the project actively maintained? How large is the community?
+- **Pricing model** — Event-based, pageview-based, or flat fee? How does cost scale with growth?
 
 ## OpenPanel
 
@@ -29,7 +49,7 @@ In this comprehensive guide, we've evaluated 9 of the best open source web analy
 />
 
 ### Summary
-OpenPanel is an open-source, privacy-friendly web and product analytics platform. It combines the power of Mixpanel with the simplicity of Plausible. You get real-time event tracking, customizable charts, an overview dashboard with instant insights, individual user and session views, and plenty of SDKs. It uses cookie-free tracking and is GDPR compliant. You can self-host it for free or use the hosted Cloud service with a 30-day free trial.
+OpenPanel is an open source analytics platform that combines **web analytics and product analytics** in one tool. Think of it as Mixpanel meets Plausible — you get real-time [event tracking](/features/event-tracking), customizable charts, an overview dashboard with instant insights, individual user and session views, [funnels](/features/funnels), [retention analysis](/features/retention), and multiple SDKs. It uses cookieless tracking and is GDPR compliant by design. You can self-host for free or use the Cloud service with a 30-day free trial.
 
 - Homepage: [**https://openpanel.dev**](https://openpanel.dev)  
 - GitHub: [**https://github.com/Openpanel-dev/openpanel**](https://github.com/Openpanel-dev/openpanel)  
@@ -39,61 +59,65 @@ OpenPanel is an open-source, privacy-friendly web and product analytics platform
 
 ### Pricing
 
-OpenPanel Cloud has a 30-day free trial with no credit card required. After the trial, you choose the tier matching your monthly event volume. If you outgrow your tier you simply upgrade. Self-hosting is free (you provide your own infrastructure).
+OpenPanel Cloud has a 30-day free trial with no credit card required. After the trial, you choose the tier matching your monthly event volume. Self-hosting is completely free — you provide your own infrastructure.
 
-| Events per Month | Price (USD/month) | Annual Price (10× monthly) |
+| Events per Month | Price (USD/month) |
-| ---------------- | ----------------- | -------------------------- |
+| ---------------- | ----------------- |
-| Up to 5 000      | \$2.50            | \$25                       |
+| Up to 5,000      | $2.50             |
-| Up to 10 000     | \$5               | \$50                       |
+| Up to 10,000     | $5                |
-| Up to 100 000    | \$20              | \$200                      |
+| Up to 100,000    | $20               |
-| Up to 250 000    | \$30              | \$300                      |
+| Up to 250,000    | $30               |
-| Up to 500 000    | \$50              | \$500                      |
+| Up to 500,000    | $50               |
-| Up to 1 000 000  | \$90              | \$900                      |
+| Up to 1,000,000  | $90               |
-| Up to 2 500 000  | \$180             | \$1 800                    |
+| Up to 2,500,000  | $180              |
-| Up to 5 000 000  | \$250             | \$2 500                    |
+| Up to 5,000,000  | $250              |
-| Up to 10 000 000 | \$400             | \$4 000                    |
+| Up to 10,000,000 | $350              |
-| > 10 000 000     | Contact sales     | Contact sales              |
+| Up to 20,000,000 | $530              |
+| Up to 30,000,000 | $680              |
+| Up to 40,000,000 | $800              |
+| Up to 50,000,000 | $900              |
 
-> All Cloud plans include unlimited websites, unlimited dashboards, unlimited team members, email & Discord support, and 5 years of data retention.
+> All Cloud plans include unlimited websites, unlimited dashboards, unlimited team members, email & Discord support, and 5 years of data retention. No add-ons or hidden costs.
 
 ### Pros
-- Open-source and self-hostable so you control your data  
+- Open source and self-hostable — you control your data completely
-- Combines web and product analytics in one platform  
+- Combines web and product analytics in one platform (replaces both GA and Mixpanel)
-- Real-time tracking and instant insights, no delays  
+- Real-time tracking and instant insights, no delays
-- Cookie-free, GDPR/CCPA compliant by design  
+- Cookieless, GDPR/CCPA compliant by design — no consent banners needed
-- Generous free trial and usage-based pricing
+- Generous free trial and straightforward usage-based pricing
+- All features included at every tier, no add-ons
 
 ### Cons
-- Cloud costs grow as event volume increases  
+- Cloud costs grow as event volume increases
-- Self-hosting requires server setup and maintenance  
+- Self-hosting requires server setup and maintenance
-- Project is still early-stage with a smaller community  
+- Project is newer with a smaller community than Matomo or PostHog
-- Lacks some advanced features like session replay or heatmaps
+- No built-in session replay or heatmaps (yet)
 
 ### FAQ
 
 <Faqs>
 <FaqItem question="How does OpenPanel pricing work after the free trial?">
-After your 30-day free trial, you pick the plan that covers your monthly events. If you exceed your tier's limit, you simply move up to the next tier or contact sales for a custom enterprise plan.
+After your 30-day free trial, you pick the plan that covers your monthly events. If you exceed your tier's limit, you simply move up to the next tier or contact sales for a custom enterprise plan. All features are included at every pricing level.
 </FaqItem>
 <FaqItem question="What tools can OpenPanel replace?">
-OpenPanel can stand in for Mixpanel, Amplitude and even Google Analytics by offering both product and web analytics in a single, privacy-friendly platform.
+OpenPanel can replace Mixpanel, Amplitude, and Google Analytics by offering both product and web analytics in a single, privacy-friendly platform. It tracks events, pageviews, user journeys, funnels, and retention — all without cookies.
 </FaqItem>
-<FaqItem question="What's included in the open-source version of OpenPanel?">
+<FaqItem question="What's included in the open source version of OpenPanel?">
-Everything—custom dashboards, charts, real-time views, user/session drill-downs and all SDKs—ships under an AGPL-3.0 licence with no feature gating.
+Everything — custom dashboards, charts, real-time views, user/session drill-downs, funnels, retention, and all SDKs ship under an AGPL-3.0 license with no feature gating. The self-hosted version is identical to the cloud version.
 </FaqItem>
-<FaqItem question="What are the hosting requirements?">
+<FaqItem question="What are the hosting requirements for OpenPanel?">
-A mid-range VPS (≈ 4 vCPU / 8 GB RAM / SSD) running Docker Compose is sufficient for most projects; scale vertically as event volume grows.
+A mid-range VPS (approximately 4 vCPU, 8 GB RAM, SSD) running Docker Compose is sufficient for most projects. Scale vertically as event volume grows. A decent VPS costs $20-50/month and can handle millions of events.
 </FaqItem>
-<FaqItem question="Is there a hosted option?">
+<FaqItem question="Is there a hosted option for OpenPanel?">
-Yes. OpenPanel Cloud starts with a 30-day free trial, then switches to usage-based tiers—e.g. \$20 for 100 k events or \$90 for 1 M events per month.
+Yes. OpenPanel Cloud starts with a 30-day free trial (no credit card required), then switches to usage-based tiers — for example, $20/month for 100K events or $90/month for 1M events.
 </FaqItem>
 </Faqs>
 
 ### Alternative to OpenPanel
 **Plausible Analytics**  
-- Open-source, privacy-focused web analytics with flat pricing  
+- Open source, privacy-focused web analytics with flat pricing  
-- Lightweight, cookie-free tracking and simple dashboards  
+- Lightweight, cookieless tracking and simple dashboards  
-- Predictable monthly cost starting at \$9 for 10 000 pageviews  
+- Predictable monthly cost starting at $9 for 10,000 pageviews  
 - Ideal if you need core web metrics without product analytics  
 
 ## PostHog
@@ -106,55 +130,60 @@ Yes. OpenPanel Cloud starts with a 30-day free trial, then switches to usage-bas
 > See our detailed comparison: [OpenPanel vs PostHog](/compare/posthog-alternative)
 
 ### Summary
-PostHog is an open-source platform for product analytics. You can track events, watch session replays, roll out feature flags, run A/B tests, track errors, send surveys, and more—all in one place. You can self-host it or use their cloud service. All users get a generous free tier every month.
+PostHog is an open source platform for product analytics, session replay, feature flags, A/B testing, error tracking, and surveys — all in one place. It's developer-focused and offers both self-hosting and a generous cloud free tier. If you need a Swiss Army knife for product development, PostHog is a strong choice.
 
 - Homepage: [**https://posthog.com**](https://posthog.com)
-- Github: [**https://github.com/PostHog/posthog**](https://github.com/PostHog/posthog)
+- GitHub: [**https://github.com/PostHog/posthog**](https://github.com/PostHog/posthog)
 - License: **MIT**
 - Rating: **4/5**
 
 ### Pricing
 
-PostHog offers a generous free tier that includes 1 million events per month, along with 5,000 session recordings, 1 million feature flag requests, 100,000 error events, and 250 survey responses. This free tier covers 1 project with community support and 1 year of data retention.
+PostHog offers a generous free tier with 1 million analytics events per month, plus 5,000 session recordings, 1M feature flag requests, and more. Beyond the free limits, pricing uses volume-based step-down rates:
 
-Beyond the free limits, PostHog operates on a pay-as-you-go model. Product analytics costs $0.00005 per event, session replay is $0.005 per recording, feature flags are $0.0001 per request, error tracking is $0.00037 per event, surveys are $0.20 per response, and data pipelines cost $0.000062 per event. The pay-as-you-go plan includes 6 projects, email support, and 7 years of data retention.
+| Monthly Events | Cost per Event | Example Monthly Cost |
+|---------------|---------------|---------------------|
+| First 1M | Free | $0 |
+| 1-2M | $0.00005 | ~$50 |
+| 2-15M | $0.0000343 | ~$396 (at 12M) |
+| 15-50M | $0.0000295 | Declining rate |
+| 50-100M | $0.0000218 | Declining rate |
+| 100-250M | $0.000015 | Declining rate |
 
-| Plan           | Price            | Monthly Free Limits                       | Support        | Projects | Retention |
+Anonymous events are 55-80% cheaper than identified events, which can significantly reduce costs.
-| -------------- | ---------------- | ----------------------------------------- | -------------- | -------- | --------- |
-| Free forever   | $0               | See free tier details above               | Community forum| 1        | 1 year    |
-| Pay-as-you-go  | $0 + usage rates | First free limits then usage-based billing| Email          | 6        | 7 years   |
 
 ### Pros
-- Open-source and self-host friendly so you keep full data control  
+- Open source and self-host friendly — you keep full data control
-- All-in-one suite: analytics, replays, flags, experiments, errors, surveys  
+- All-in-one suite: analytics, replays, flags, experiments, errors, surveys
-- Generous monthly free tier for smaller sites or dev testing  
+- Generous monthly free tier for smaller projects
+- Strong developer community and active development
 
 ### Cons
-- Usage-based pricing can be hard to predict as you grow  
+- Usage-based pricing can be hard to predict as you grow
-- Managing a self-hosted instance takes extra ops work and maintenance
+- Managing a self-hosted instance takes significant ops work
-- Self-hosting vs cloud is not 1-to-1
+- Self-hosting vs cloud is not feature-equivalent
-- Enterprise support and advanced add-ons can get costly  
+- Complexity — the sheer number of features can be overwhelming
 
 ### FAQ
 
 <Faqs>
 <FaqItem question="How does PostHog pricing work after the free tier?">
-PostHog's pricing can be tricky since it's usage based. Depending on how many events you send you will pay X amount per event.
+PostHog uses volume-based step-down pricing. After the first 1M free events, you pay $0.00005 per event for the next million, then the rate drops as volume increases. A company sending 12M events monthly would pay approximately $393/month.
 </FaqItem>
 <FaqItem question="What's the difference between PostHog and OpenPanel?">
-OpenPanel is more affordable than PostHog once you exceed 1 million events, making it a cost-effective choice for growing projects. While PostHog offers a broader range of features, OpenPanel stands out for its simplicity in self-hosting and provides the same capabilities whether you use the cloud or self-hosted version. Both platforms serve as robust product and web analytics tools, but OpenPanel's pricing and deployment flexibility make it especially appealing for teams seeking value and ease of use.
+OpenPanel is more affordable than PostHog once you exceed 1 million events, making it a cost-effective choice for growing projects. While PostHog offers a broader range of features (flags, experiments, surveys, error tracking), OpenPanel focuses on web and product analytics with simpler self-hosting and identical cloud/self-hosted feature parity.
 </FaqItem>
 <FaqItem question="What tools can PostHog replace?">
-By bundling product analytics, web analytics, session replay, feature flags, experiments, error tracking and surveys, PostHog can replace Mixpanel, Amplitude, Google Analytics, Hotjar / FullStory and LaunchDarkly in one stack.
+By bundling product analytics, web analytics, session replay, feature flags, experiments, error tracking, and surveys, PostHog can replace Mixpanel, Amplitude, Google Analytics, Hotjar/FullStory, and LaunchDarkly in one stack.
 </FaqItem>
-<FaqItem question="What's included in the open-source version?">
+<FaqItem question="What's included in the open source version?">
-PostHog Open Source (MIT) includes almost every feature but is limited to a single project per instance and comes without an uptime guarantee—ideal for hobby or proof-of-concept use.
+PostHog Open Source (MIT) includes almost every feature but is limited to a single project per instance and comes without an uptime guarantee — ideal for hobby or proof-of-concept use.
 </FaqItem>
 <FaqItem question="What are the self-hosting requirements?">
-The team recommends ≥ 4 vCPU, 16 GB RAM and 30 GB+ storage. Self-hosting works best up to ~300 k events / month; beyond that, PostHog Cloud scales for you.
+The team recommends at least 4 vCPU, 16 GB RAM and 30 GB+ storage. Self-hosting works best up to ~300K events/month; beyond that, PostHog Cloud handles scaling for you.
 </FaqItem>
 <FaqItem question="Is there a hosted option?">
-Yes. PostHog Cloud offers a free tier (1 M events, 5 k recordings, 1 M flag API requests) with US or EU data residency, then pay-as-you-go pricing after the limits.
+Yes. PostHog Cloud offers a free tier (1M events, 5K recordings, 1M flag API requests) with US or EU data residency, then pay-as-you-go pricing after the free limits.
 </FaqItem>
 </Faqs>
 
@@ -168,57 +197,60 @@ Yes. PostHog Cloud offers a free tier (1 M events, 5 k recordings, 1 M flag API
 > See our detailed comparison: [OpenPanel vs Plausible](/compare/plausible-alternative)
 
 ### Summary
-Plausible is an open-source, privacy-friendly web analytics tool. It tracks pageviews and custom events without cookies or personal data. You get real-time reports, goals, custom events, email or Slack reports, and GDPR/CCPA compliance. You can self-host for free or use their cloud service.
+Plausible is an open source, privacy-friendly web analytics tool built as a lightweight alternative to Google Analytics. It tracks pageviews and custom events without cookies or personal data. You get real-time reports, goals, custom events, email/Slack reports, and GDPR/CCPA compliance out of the box. It's the go-to choice if you want simple, clean analytics without complexity.
 
 - Homepage: [**https://plausible.io**](https://plausible.io)  
-- Github: [**https://github.com/plausible/analytics**](https://github.com/plausible/analytics)  
+- GitHub: [**https://github.com/plausible/analytics**](https://github.com/plausible/analytics)  
 - License: **AGPL v3**
 - Rating: **4/5**
 
 ### Pricing
 
-Plausible offers traffic-based plans you can bill monthly or yearly (2 months free on annual). All plans include unlimited data retention, unlimited team members, Google Analytics import, and core features.
+Plausible uses traffic-based plans billed monthly or yearly (2 months free on annual). All plans include unlimited data retention, unlimited team members, Google Analytics import, and all core features.
 
-| Plan      | Pageviews per Month | Price (Monthly) | Price (Yearly) | Sites | Team Members | Data Retention |
+| Plan      | Pageviews per Month | Price (Monthly) | Price (Yearly) | Sites | Data Retention |
-|-----------|---------------------|-----------------|----------------|-------|--------------|----------------|
+|-----------|---------------------|-----------------|----------------|-------|----------------|
-| Starter   | Up to 10 000        | \$9             | \$90           | 1     | Unlimited    | Unlimited      |
+| Starter   | Up to 10,000        | $9              | $90            | 1     | Unlimited      |
-| Growth    | Up to 100 000       | \$14            | \$140          | 3     | 3            | Unlimited      |
+| Growth    | Up to 100,000       | $14             | $140           | 3     | Unlimited      |
-| Business  | Up to 200 000       | \$19            | \$190          | 10    | 10           | Unlimited      |
+| Business  | Up to 200,000       | $19             | $190           | 10    | Unlimited      |
-| Enterprise| 200 001+            | Custom          | Custom         | 10+   | 10+          | Unlimited      |
+| Enterprise| 200,001+            | Custom          | Custom         | 10+   | Unlimited      |
 
 ### Pros
-- Designed for privacy, with no cookies or personal data tracking  
+- Designed for privacy — no cookies, no personal data tracking
-- Simple, intuitive dashboard and easy setup  
+- Simple, intuitive dashboard that anyone can understand
-- Open source, with free self-host option and transparent pricing  
+- Open source with free self-host option and transparent pricing
+- Very lightweight script (~1 KB) that doesn't slow your site
 
 ### Cons
-- No free tier beyond self-hosting  
+- No free tier beyond self-hosting
-- Costs can rise quickly as traffic grows  
+- Costs can rise quickly as traffic grows
-- Fewer advanced features (like funnels or session replay) than some competitors  
+- No product analytics features (no [funnels](/features/funnels), retention, or user-level tracking)
+- No session replay or heatmaps
 
 ### FAQ
 
 <Faqs>
-<FaqItem question="What's the differnece between OpenPanel?">
+<FaqItem question="What's the difference between Plausible and OpenPanel?">
-OpenPanel is similar to Plausible in that both offer privacy-friendly, open-source web analytics with easy self-hosting. However, OpenPanel goes further by including advanced product analytics features—such as event tracking, user journeys, and session replays—making it suitable for teams that need deeper insights into user behavior, not just website traffic. If you want a simple, privacy-focused analytics tool, Plausible is great; if you need more advanced product analytics in addition to web stats, OpenPanel is a better fit.
+Both offer privacy-friendly, open source web analytics with easy self-hosting. However, OpenPanel goes further by including advanced product analytics features — such as event tracking, user journeys, funnels, and retention analysis — making it suitable for teams that need deeper insights into user behavior, not just website traffic. If you want the simplest possible analytics, Plausible is great; if you need product analytics too, OpenPanel is the better fit.
 </FaqItem>
 <FaqItem question="How does Plausible protect user privacy?">
-Plausible does not use cookies or collect personal data. All tracking is aggregated and anonymized, making it GDPR and CCPA compliant by design.
+Plausible does not use cookies or collect personal data. All tracking is aggregated and anonymized, making it GDPR and CCPA compliant by design. No consent banners needed.
 </FaqItem>
 <FaqItem question="What tools can Plausible replace?">
-Plausible is a privacy-first alternative to Google Analytics and other page-view focused trackers, giving you simple dashboards without cookies.
+Plausible is a privacy-first alternative to Google Analytics and other pageview-focused trackers, giving you simple dashboards without cookies or personal data collection.
 </FaqItem>
-<FaqItem question="What's included in the open-source version?">
+<FaqItem question="What's included in the open source version?">
-Everything you see in Plausible Cloud—real-time dashboards, goals, custom events, unlimited retention and team members—is also in the self-hosted AGPL build.
+Everything you see in Plausible Cloud — real-time dashboards, goals, custom events, unlimited retention and team members — is also in the self-hosted AGPL build.
 </FaqItem>
 <FaqItem question="Is there a hosted option?">
-Yes. Plausible Cloud starts at \$9/month for 10 k page-views with simple, traffic-based pricing.
+Yes. Plausible Cloud starts at $9/month for 10K pageviews with simple, traffic-based pricing. A 30-day free trial is available.
 </FaqItem>
 </Faqs>
 
 ### Alternative to Plausible
 **Umami**  
-- Umami is almost a 1-to-1 alternative to Plausible. A great web analytics tool
+- Umami is almost a 1-to-1 alternative to Plausible with an MIT license
+- Free cloud tier with 1M events/month
 
 **OpenPanel**
 - Similar to both Umami and Plausible but also adds product analytics to the mix
@@ -233,58 +265,59 @@ Yes. Plausible Cloud starts at \$9/month for 10 k page-views with simple, traffi
 > See our detailed comparison: [OpenPanel vs Matomo](/compare/matomo-alternative)
 
 ### Summary
-Matomo (formerly Piwik) is an open-source web analytics platform. You can track web and mobile visits, build charts, create dashboards, set goals, run A/B tests, record sessions, view heatmaps, and more. You own all your data and can choose to self-host for free or use Matomo Cloud for hosting and support.
+Matomo (formerly Piwik) is the most established open source web analytics platform. It's been around since 2007 and positions itself as the leading Google Analytics alternative. You can track web and mobile visits, build charts, create dashboards, set goals, run A/B tests, record sessions, view heatmaps, and more. You own all your data and can choose to self-host for free or use Matomo Cloud.
 
 - Homepage: [**https://matomo.org**](https://matomo.org)  
-- Github: [**https://github.com/matomo-org/matomo**](https://github.com/matomo-org/matomo)  
+- GitHub: [**https://github.com/matomo-org/matomo**](https://github.com/matomo-org/matomo)  
 - License: **GNU GPL v3**
 - Rating: **4/5**
 
 ### Pricing
 
-Matomo offers two main options:
+| Plan         | Price                            | Hits per Month        | Support                                    | Websites | Data Retention |
+| ------------ | -------------------------------- | --------------------- | ------------------------------------------ | -------- | -------------- |
+| On-Premise   | €0                               | Unlimited             | Free community support or paid subscriptions | Unlimited| Forever        |
+| Cloud (50K)  | €29/month or €290/year           | Up to 50,000          | Email support & Customer Success Manager    | 30       | 24 months      |
 
-| Plan         | Price                            | Hits per Month        | Billing                     | Support                                    | Websites | Team Members | Data Retention |
+For higher volumes (100K, 300K, 1M+ hits), contact sales for enterprise pricing.
-| ------------ | -------------------------------- | --------------------- | --------------------------- | ------------------------------------------ | -------- | ------------ | -------------- |
-| On-Premise   | €0                               | Unlimited             | Self-host (download)        | Free community support or paid subscriptions | Unlimited| Unlimited    | Forever        |
-| Cloud (50 k) | €29/month or €290/year (2 months free) | Up to 50 000         | Monthly or annual           | Email support & Customer Success Manager    | 30       | 30           | 24 months      |
-
-- For more hits or custom allowances (100 k, 300 k, 1 M, etc.), contact sales for enterprise pricing.
 
 ### Pros
-- You fully own your data and stay GDPR/CCPA compliant  
+- Most mature open source analytics platform (since 2007)
-- Rich feature set: dashboards, A/B tests, heatmaps, session recordings, funnels  
+- Full data ownership and GDPR/CCPA compliance
-- Free self-hosted option with no limits on hits or users  
+- Rich feature set: dashboards, A/B tests, heatmaps, session recordings, funnels
+- Free self-hosted option with no limits on hits or users
+- Large plugin ecosystem
 
 ### Cons
-- Managing self-hosting requires server setup and maintenance  
+- Self-hosting requires server setup, maintenance, and PHP knowledge
-- Cloud costs can rise sharply as traffic grows beyond base tiers  
+- Cloud costs rise sharply beyond the base 50K tier
-- Many advanced plugins incur extra annual fees  
+- Many advanced plugins (A/B testing, heatmaps, etc.) require paid subscriptions even on self-hosted
+- UI can feel dated compared to newer tools
 
 ### FAQ
 
 <Faqs>
 <FaqItem question="What is included in Matomo Cloud's €29/month plan?">
-For €29 per month (or €290 per year), you get up to 50 000 hits, 30 websites, 30 team members, 24 months of raw data retention, email support, and a Customer Success Manager.
+For €29 per month (or €290/year), you get up to 50,000 hits, 30 websites, 30 team members, 24 months of raw data retention, email support, and a Customer Success Manager.
 </FaqItem>
 <FaqItem question="What tools can Matomo replace?">
-Matomo positions itself as a GDPR-compliant alternative to Google Analytics 4.
+Matomo is designed as a direct GDPR-compliant replacement for Google Analytics 4. It covers web analytics, ecommerce tracking, and basic product analytics.
 </FaqItem>
-<FaqItem question="What's included in the open-source version?">
+<FaqItem question="What's included in the open source version?">
-Self-hosted Matomo covers user & event tracking, ecommerce analytics, segmentation and customizable dashboards; premium add-ons (A/B testing, heatmaps, etc.) cost extra.
+Self-hosted Matomo covers user and event tracking, ecommerce analytics, segmentation, and customizable dashboards. However, premium add-ons (A/B testing, heatmaps, session recordings) cost extra.
 </FaqItem>
 <FaqItem question="What are the self-hosting requirements?">
-For ~100 k page-views / month: 2 CPU, 2 GB RAM and 50 GB SSD. Over 1 M page-views Matomo recommends separate app and DB servers.
+For ~100K pageviews/month: 2 CPU, 2 GB RAM and 50 GB SSD. Over 1M pageviews, Matomo recommends separate app and database servers.
 </FaqItem>
 <FaqItem question="Is there a hosted option?">
-Yes. Matomo Cloud charges by "hits per month" and unlocks all paid add-ons out-of-the-box.
+Yes. Matomo Cloud charges by "hits per month" and unlocks all paid add-ons out of the box. Plans start at €29/month for 50K hits.
 </FaqItem>
 </Faqs>
 
 ### Alternative to Matomo
 **Fathom Analytics**  
 - Privacy-focused, simple analytics with no cookies or personal data  
-- Flat monthly pricing (starts at $14/month) for unlimited pageviews  
+- Flat monthly pricing (starts at $15/month) for unlimited sites
 - Easy setup with minimal interface for core metrics  
 
 ## Fathom
@@ -297,51 +330,50 @@ Yes. Matomo Cloud charges by "hits per month" and unlocks all paid add-ons out-o
 > See our detailed comparison: [OpenPanel vs Fathom](/compare/fathom-alternative)
 
 ### Summary
-Fathom is a simple, privacy-focused web analytics tool. It tracks pageviews and events without cookies or personal data. You get real-time reports, unlimited data retention, unlimited sites, and simple dashboards. You can use Fathom's hosted service with a free trial or self-host with their Docker image (self-hosting requires a license).
+Fathom is a privacy-focused web analytics tool that tracks pageviews and events without cookies or personal data. You get real-time reports, unlimited data retention, unlimited sites, and simple dashboards. While Fathom isn't truly open source (it's proprietary with a self-host license available), it's included here because it's a popular alternative in the privacy-first analytics space.
 
 - Homepage: [**https://usefathom.com**](https://usefathom.com)  
-- Github: **Unsure** (no public repo for core analytics)  
+- GitHub: **No public repository** (proprietary)
 - License: **Proprietary** (self-host license available)  
 - Rating: **4/5**
 
 ### Pricing
 
-Fathom bills by monthly data points (pageviews + events). You pay for the tier you need and can move up at any time. All plans include unlimited sites, data retention, email reports, exports, and support.
+Fathom bills by monthly data points (pageviews + events). All plans include unlimited sites, data retention, email reports, exports, and support.
 
 | Plan                   | Data Points / Month | Price (Monthly) | Price (Yearly, 17% off) |
 | ---------------------- | ------------------- | --------------- | ----------------------- |
-| Starter                | Up to 100 000       | \$15            | \$150/yr                |
+| Starter                | Up to 100,000       | $15             | $150/yr                 |
-| Growth                 | Up to 200 000       | \$25            | \$250/yr                |
+| Growth                 | Up to 200,000       | $25             | $250/yr                 |
-| Business               | Up to 500 000       | \$45            | \$450/yr                |
+| Business               | Up to 500,000       | $45             | $450/yr                 |
-| Scale                  | Up to 1 000 000     | \$60            | \$600/yr                |
+| Scale                  | Up to 1,000,000     | $60             | $600/yr                 |
-| Scale+                 | Up to 2 000 000     | \$100           | \$1 000/yr              |
+| Scale+                 | Up to 2,000,000     | $100            | $1,000/yr               |
-| Enterprise Small       | Up to 5 000 000     | \$140           | \$1 400/yr              |
+| Enterprise Small       | Up to 5,000,000     | $140            | $1,400/yr               |
-| Enterprise Medium      | Up to 10 000 000    | \$200           | \$2 000/yr              |
+| Enterprise Medium      | Up to 10,000,000    | $200            | $2,000/yr               |
-| Enterprise Large       | Up to 15 000 000    | \$290           | \$2 900/yr              |
+| Enterprise Large       | Up to 15,000,000    | $290            | $2,900/yr               |
-| Enterprise X-Large     | Up to 20 000 000    | \$380           | \$3 800/yr              |
+| Enterprise X-Large     | Up to 20,000,000    | $380            | $3,800/yr               |
-| Enterprise Custom¹     | Over 25 000 000     | Contact sales   | Contact sales          |
+| Enterprise Custom      | Over 25,000,000     | Contact sales   | Contact sales           |
-
-¹ For volumes above 25 million data points, contact sales.
 
 ### Pros
-- No cookies or personal data collection by design  
+- No cookies or personal data collection by design
-- Real-time, simple dashboard with core metrics only  
+- Real-time, simple dashboard with core metrics
-- Unlimited sites and data retention on every plan  
+- Unlimited sites and data retention on every plan
-- Self-host option lets you run it on your own infrastructure  
+- EU-isolation option available for GDPR compliance
 
 ### Cons
-- Proprietary platform (core code is not open source)  
+- **Not open source** — proprietary platform with no public code
-- Costs rise linearly as traffic grows  
+- Costs rise linearly as traffic grows
-- Lacks advanced features like funnels or session replay  
+- No product analytics features (no funnels, retention, or user tracking)
+- No session replay or heatmaps
 
 ### FAQ
 
 <Faqs>
 <FaqItem question="How does Fathom pricing work after the free trial?">
-Fathom charges by data-point tiers. You start on the plan matching your monthly pageviews and events, and you move up if you exceed your quota at month's end.
+Fathom charges by data-point tiers. You start on the plan matching your monthly pageviews and events, and you move up if you exceed your quota.
 </FaqItem>
 <FaqItem question="What's the difference between Fathom and OpenPanel?">
-Fathom is a hosted, proprietary analytics service with simple, tiered pricing. OpenPanel is open source and privacy friendly, offering both web and product analytics, real-time views, individual session tracking, charts, cookie-free GDPR compliance, and multiple SDKs you can self-host for free.
+Fathom is a hosted, proprietary analytics service with simple, tiered pricing focused on web analytics only. OpenPanel is open source and privacy-friendly, offering both web and product analytics, real-time views, individual [session tracking](/features/session-tracking), funnels, retention, charts, cookieless GDPR compliance, and multiple SDKs you can self-host for free.
 </FaqItem>
 </Faqs>
 
@@ -362,7 +394,7 @@ Fathom is a hosted, proprietary analytics service with simple, tiered pricing. O
 > See our detailed comparison: [OpenPanel vs Umami](/compare/umami-alternative)
 
 ### Summary
-Umami is an open-source, privacy-friendly web analytics tool. It tracks pageviews and basic events without cookies or personal data. The lightweight script (~2 KB) loads fast and is GDPR/CCPA compliant by default. You can self-host it for free or use Umami Cloud with usage-based pricing.
+Umami is an open source, privacy-friendly web analytics tool. It tracks pageviews and basic events without cookies or personal data. The lightweight script (~2 KB) loads fast and is GDPR/CCPA compliant by default. It's one of the simplest open source analytics tools to self-host, making it popular with developers who want a quick Google Analytics replacement.
 
 - Homepage: [**https://umami.is**](https://umami.is)  
 - GitHub: [**https://github.com/umami-software/umami**](https://github.com/umami-software/umami)  
@@ -373,22 +405,24 @@ Umami is an open-source, privacy-friendly web analytics tool. It tracks pageview
 
 Self-hosted Umami is free with unlimited sites and events, managed by you with community support.
 
-Umami Cloud is free for the first 1 million events per month. Beyond that, you pay $0.00002 per additional event. You get unlimited websites, unlimited team members, 5 years of data retention, and email support.
+Umami Cloud is free for the first 1 million events per month. Beyond that, you pay $0.00002 per additional event.
 
 | Plan        | Price                            | Monthly Free Limits | Support       | Retention  |
 | ----------- | -------------------------------- | ------------------- | ------------- | ---------- |
 | Self-host   | $0                               | Unlimited events & sites | Community forum | Unlimited  |
-| Cloud       | $0 + $0.00002 per event over 1 M | 1 000 000 events     | Email support | 5 years    |
+| Cloud       | $0 + $0.00002 per event over 1M  | 1,000,000 events    | Email support | 5 years    |
 
 ### Pros
-- Fully open-source and self-hosted option gives you data control  
+- Fully open source (MIT) and self-hosted option gives you complete data control
-- Privacy-first design with no cookies or personal data collection  
+- Privacy-first design with no cookies or personal data collection
-- Very lightweight tracking script that won't slow your site  
+- Very lightweight tracking script that won't slow your site
+- Simple to self-host with Docker Compose
 
 ### Cons
-- Limited to basic metrics; no session replay, funnels, or heatmaps  
+- Limited to basic web metrics; no product analytics, session replay, or heatmaps
-- Running your own server means more maintenance and updates  
+- Running your own server means maintenance and updates
-- Cloud costs can add up if you exceed free event limits significantly  
+- Cloud costs can add up at high event volumes
+- Fewer advanced features compared to OpenPanel or PostHog
 
 ### FAQ
 
@@ -397,25 +431,25 @@ Umami Cloud is free for the first 1 million events per month. Beyond that, you p
 After the first 1 million events each month, Umami Cloud charges $0.00002 for each additional event. There are no per-site or per-user fees.
 </FaqItem>
 <FaqItem question="What's the difference between Umami and OpenPanel?">
-Umami provides open-source, cookie-free web analytics focused on pageviews and basic events. OpenPanel is also open-source and privacy-friendly but adds product analytics, real-time dashboards, individual session and user tracking, event visualization charts, and multiple SDKs—all cookie-free and GDPR compliant.
+Umami provides open source, cookieless web analytics focused on pageviews and basic events. OpenPanel is also open source and privacy-friendly but adds product analytics, real-time dashboards, individual session and user tracking, funnels, retention analysis, event visualization charts, and multiple SDKs — all cookieless and GDPR compliant.
 </FaqItem>
 <FaqItem question="What tools can Umami replace?">
-Primarily Google Analytics or any lightweight page-view tracker that relies on cookies.
+Umami is primarily a Google Analytics replacement for teams that want cookie-free, privacy-first pageview tracking without the complexity.
 </FaqItem>
-<FaqItem question="What's included in the open-source version?">
+<FaqItem question="What's included in the open source version?">
-There's no feature gap—funnels, user paths, retention and custom events are all in the MIT-licensed build.
+There's no feature gap — funnels, user paths, retention, and custom events are all in the MIT-licensed build.
 </FaqItem>
 <FaqItem question="What are the self-hosting requirements?">
-A server with Node 18+ and either MySQL 8+ or PostgreSQL 12+; official Docker Compose templates make deployment straightforward.
+A server with Node 18+ and either MySQL 8+ or PostgreSQL 12+. Official Docker Compose templates make deployment straightforward.
 </FaqItem>
 <FaqItem question="Is there a hosted option?">
-Yes. Umami Cloud lets you track up to 100 k events each month for free, then bills \$0.00002 per event thereafter (e.g. \$20 for 1 M events).
+Yes. Umami Cloud lets you track up to 1M events each month for free, then bills $0.00002 per event thereafter.
 </FaqItem>
 </Faqs>
 
 ### Alternative to Umami
 **GoatCounter**  
-- Open-source, privacy-focused analytics with simple pageview and event tracking  
+- Open source, privacy-focused analytics with simple pageview and event tracking  
 - Self-host for free or use hosted plans starting at €5/month  
 - Lightweight script, no cookies required, GDPR compliant  
 - Very simple setup and predictable flat pricing  
@@ -430,45 +464,46 @@ Yes. Umami Cloud lets you track up to 100 k events each month for free, then bil
 > See our detailed comparison: [OpenPanel vs Ackee](/compare/ackee-alternative)
 
 ### Summary
-Ackee is an open-source, self-hosted web analytics tool that focuses on privacy and simplicity. It runs on your own server with Node.js and MongoDB, tracks pageviews and custom events without cookies or personal data, and presents stats in a minimal interface. It uses a GraphQL API and keeps all tracked data anonymized by default.
+Ackee is an open source, self-hosted web analytics tool that focuses on privacy and minimalism. It runs on your own server with Node.js and MongoDB, tracks pageviews and custom events without cookies or personal data, and presents stats in a minimal interface. It uses a GraphQL API and keeps all tracked data anonymized by default.
 
 - Homepage: [**https://ackee.electerious.com**](https://ackee.electerious.com)  
-- Github: [**https://github.com/electerious/Ackee**](https://github.com/electerious/Ackee)  
+- GitHub: [**https://github.com/electerious/Ackee**](https://github.com/electerious/Ackee)  
 - License: **MIT**
 - Rating: **4/5**
 
 ### Pricing
 
-Ackee itself is completely free to self-host. You download the code, run it on your server, and there are no limits on sites, pageviews, team members, or data retention.
+Ackee is completely free to self-host. You download the code, run it on your server, and there are no limits on sites, pageviews, team members, or data retention.
 
-> _Note: There is no official Ackee-hosted service. Some third-party providers (for example Elestio) offer managed Ackee hosting on a credits-or-hourly basis, but pricing and terms vary by provider._
+> _Note: There is no official Ackee-hosted service. Some third-party providers (like Elestio) offer managed Ackee hosting, but pricing varies by provider._
 
 ### Pros
-- Fully open-source and free to self-host so you control all your data  
+- Fully open source and free to self-host — you control all your data
-- Privacy-first design: no cookies, anonymized tracking, GDPR/CCPA compliant  
+- Privacy-first design: no cookies, anonymized tracking, GDPR/CCPA compliant
-- Lightweight and minimal UI with fast load times  
+- Lightweight and minimal UI with fast load times
-- GraphQL API allows custom integrations and flexible querying  
+- GraphQL API allows custom integrations and flexible querying
 
 ### Cons
-- Limited to basic metrics (no funnels, session replay, or heatmaps)  
+- Limited to basic metrics (no funnels, session replay, or heatmaps)
-- Requires server setup, maintenance, and security updates  
+- Requires server setup, maintenance, and security updates
-- No official hosted offering—managed hosting depends on third parties  
+- No official hosted offering — managed hosting depends on third parties
-- Minimal feature set may not suit advanced analytics needs  
+- Minimal feature set won't suit teams needing advanced analytics
+- Requires MongoDB, which adds complexity
 
 ### FAQ
 
 <Faqs>
-<FaqItem question="How does Ackee pricing work after the free tier?">
+<FaqItem question="How does Ackee pricing work?">
-Ackee is free forever if you self-host. There is no paid tier or usage fees for the core software.
+Ackee is free forever if you self-host. There is no paid tier or usage fees for the core software. Your only costs are the server infrastructure you run it on.
 </FaqItem>
 <FaqItem question="What's the difference between Ackee and OpenPanel?">
-Ackee is a self-hosted, minimal web analytics tool that tracks pageviews and basic events without cookies. OpenPanel is also open-source and privacy-friendly but adds product analytics, real-time dashboards, individual session and user tracking, event visualization charts, and multiple SDKs you can use via cloud or self-host.
+Ackee is a self-hosted, minimal web analytics tool that tracks pageviews and basic events without cookies. OpenPanel is also open source and privacy-friendly but adds product analytics, real-time dashboards, individual session and user tracking, funnels, retention, event visualization charts, and multiple SDKs you can use via cloud or self-host.
 </FaqItem>
 </Faqs>
 
 ### Alternative to Ackee
 **GoatCounter**  
-- Open-source and privacy-focused, with GDPR-compliant, cookie-free tracking  
+- Open source and privacy-focused, with GDPR-compliant, cookieless tracking  
 - Self-host free or use hosted plans starting at €5/month  
 - Simple pageview and basic event metrics, predictable flat pricing  
 
@@ -482,7 +517,7 @@ Ackee is a self-hosted, minimal web analytics tool that tracks pageviews and bas
 > See our detailed comparison: [OpenPanel vs Pirsch](/compare/pirsch-analytics-alternative)
 
 ### Summary
-Pirsch is a drop-in, server-side, no-cookie, privacy-focused web analytics solution built in Go. It generates anonymized visitor fingerprints, works even with ad blockers, and is GDPR, CCPA, and PECR compliant. You can use the hosted SaaS offering or self-host under an enterprise license.
+Pirsch is a server-side, cookieless, privacy-focused web analytics solution built in Go. It generates anonymized visitor fingerprints, works even with ad blockers, and is GDPR, CCPA, and PECR compliant. The server-side approach means the tracking isn't affected by client-side blockers — a unique advantage.
 
 - Homepage: [**https://pirsch.io**](https://pirsch.io)  
 - GitHub: [**https://github.com/pirsch-analytics/pirsch**](https://github.com/pirsch-analytics/pirsch)  
@@ -493,44 +528,42 @@ Pirsch is a drop-in, server-side, no-cookie, privacy-focused web analytics solut
 
 Pirsch offers a 30-day free trial with no credit card required. After that, plans are usage-based on monthly pageviews:
 
-| Plan        | Monthly Price      | Annual Price (2 mo. free) | Pageviews Included | Websites           | Members           | Data Retention    |
+| Plan            | Monthly Price | Annual Price | Pageviews Included | Websites  |
-|-------------|--------------------|---------------------------|--------------------|--------------------|-------------------|-------------------|
+|-----------------|---------------|--------------|--------------------|-----------| 
-| Standard    | \$6                | \$60                      | Up to 10 000       | Up to 50           | Unlimited         | Unlimited         |
+| Standard        | $6            | $60          | Up to 10,000       | Up to 50  |
-| Plus (Best Value) | \$12           | \$120                     | Custom¹            | Unlimited          | Unlimited         | Unlimited         |
+| Plus            | $12           | $120         | Custom             | Unlimited |
-| Enterprise  | Custom             | Custom                    | Custom             | Custom             | Custom            | Custom            |
+| Enterprise      | Custom        | Custom       | Custom             | Custom    |
 
-¹ Plus plan adds funnels, A/B testing, custom domains/themes, white-labeling, priority support, and event goals.
+Plus plan adds funnels, A/B testing, custom domains/themes, white-labeling, priority support, and event goals.
-
-> _You pay per pageview tier; if you exceed your included pageviews, you move up to the next tier or contact sales for enterprise licensing._
 
 ### Pros
-- Fully privacy-focused with no cookies and anonymized data by default  
+- Server-side tracking works around ad blockers — get more complete data
-- Server-side tracking works around ad blockers and gives full data ownership  
+- Privacy-focused with no cookies and anonymized data by default
-- Lightweight Go library and multiple SDKs (JS, PHP, Laravel, etc.)  
+- Lightweight Go library and multiple SDKs (JS, PHP, Laravel, etc.)
-- Hosted in the EU on German servers (Hetzner)  
+- Hosted in the EU on German servers (Hetzner)
 
 ### Cons
-- Core self-host requires an enterprise license and setup support  
+- Self-hosting requires an enterprise license (not free)
-- Usage tiers can get costly as traffic grows beyond small sites  
+- Usage tiers can get costly as traffic grows
-- Hosted plans have feature gaps vs. self-host (e.g., custom integrations)  
+- No session replay or heatmaps
-- No built-in session replay or heatmaps  
+- Smaller community compared to Plausible or Matomo
 
 ### FAQ
 
 <Faqs>
 <FaqItem question="How does Pirsch pricing work after the free trial?">
-After 30 days, you choose the tier matching your monthly pageviews. If you go over your included pageviews, you upgrade to the next tier or contact sales for enterprise options.
+After 30 days, you choose the tier matching your monthly pageviews. If you exceed your included pageviews, you upgrade to the next tier or contact sales for enterprise options.
 </FaqItem>
 <FaqItem question="What's the difference between Pirsch and OpenPanel?">
-Pirsch is a hosted or enterprise-licensed Go-based analytics service focused on server-side tracking and EU hosting. OpenPanel is fully open-source, privacy-friendly, and cookie-free, offering both web and product analytics, real-time dashboards, individual session/user tracking, charts, GDPR compliance, and multiple SDKs you can self-host for free.
+Pirsch is a server-side Go-based analytics service focused on ad-blocker-resistant tracking and EU hosting. OpenPanel is fully open source, privacy-friendly, and cookieless, offering both web and product analytics, real-time dashboards, individual session/user tracking, funnels, retention, and multiple SDKs you can self-host for free.
 </FaqItem>
 </Faqs>
 
 ### Alternative to Pirsch
 **Plausible Analytics**  
-- Open-source, cookie-free web analytics with a flat pricing model  
+- Open source, cookieless web analytics with a flat pricing model  
 - Simple dashboard, real-time data, and GDPR/CCPA compliance  
-- Self-host for free or use hosted plans starting at \$9/month for 10 000 pageviews  
+- Self-host for free or use hosted plans starting at $9/month for 10,000 pageviews  
 
 
 ## Swetrix
@@ -541,7 +574,7 @@ Pirsch is a hosted or enterprise-licensed Go-based analytics service focused on
 />
 
 ### Summary
-Swetrix is an open-source, cookieless web analytics platform that focuses on privacy and ease of use. You can track pageviews, custom events, user flows, performance metrics, and more—all without showing cookie banners. You can self-host for free or use the hosted service with a 14-day trial.
+Swetrix is an open source, cookieless web analytics platform that focuses on privacy and ease of use. You can track pageviews, custom events, user flows, performance metrics, and more — all without cookie banners. It also includes web performance monitoring, which most other tools in this list don't offer.
 
 - Homepage: [**https://swetrix.com**](https://swetrix.com)  
 - GitHub: [**https://github.com/Swetrix/swetrix**](https://github.com/Swetrix/swetrix)  
@@ -550,31 +583,31 @@ Swetrix is an open-source, cookieless web analytics platform that focuses on pri
 
 ### Pricing
 
-Swetrix offers a 14-day free trial with no credit card required. After that, you pick a plan based on monthly events. If you need more than 10 million events, you contact sales.
+Swetrix offers a 14-day free trial with no credit card required. After that, you pick a plan based on monthly events:
 
 | Plan               | Events per Month | Price (USD/month) |
 | ------------------ | ---------------- | ----------------- |
-| Basic              | Up to 10 000     | \$5               |
+| Basic              | Up to 10,000     | $5                |
-| Growth             | Up to 100 000    | \$15              |
+| Growth             | Up to 100,000    | $15               |
-| Pro                | Up to 200 000    | \$25              |
+| Pro                | Up to 200,000    | $25               |
-| Business           | Up to 500 000    | \$45              |
+| Business           | Up to 500,000    | $45               |
-| Premium            | Up to 1 000 000  | \$59              |
+| Premium            | Up to 1,000,000  | $59               |
-| Enterprise Small   | Up to 2 000 000  | \$84              |
+| Enterprise Small   | Up to 2,000,000  | $84               |
-| Enterprise Medium  | Up to 5 000 000  | \$110             |
+| Enterprise Medium  | Up to 5,000,000  | $110              |
-| Enterprise Large   | Up to 10 000 000 | \$150             |
+| Enterprise Large   | Up to 10,000,000 | $150              |
-| Enterprise X-Large | Over 10 000 000  | Contact sales     |   
+| Enterprise X-Large | Over 10,000,000  | Contact sales     |   
 
 ### Pros
-- Fully open source and self-hostable so you keep full control of your data  
+- Fully open source and self-hostable for complete data control
-- Cookie-free tracking that is GDPR/CCPA compliant by design  
+- Cookieless tracking that is GDPR/CCPA compliant by design
-- Clean, simple dashboard with user flows, alerts, exports, and performance monitoring  
+- Includes web performance monitoring (page load times, Core Web Vitals)
-- No limits on sites or data exports in any plan  
+- Clean, simple dashboard with user flows, alerts, and exports
 
 ### Cons
-- Hosted plans use usage-based tiers, so costs rise with traffic  
+- Hosted plans use usage-based tiers, so costs rise with traffic
-- Self-hosting requires setup, maintenance, and hosting infrastructure  
+- Self-hosting requires setup, maintenance, and hosting infrastructure
-- Lacks advanced features like session replay or heatmaps  
+- No session replay or heatmaps
-- Smaller community compared to older analytics platforms  
+- Smaller community compared to more established tools
 
 ### FAQ
 
@@ -583,13 +616,74 @@ Swetrix offers a 14-day free trial with no credit card required. After that, you
 After your 14-day trial, you choose the plan that covers your monthly events. If you exceed your plan's limit, you move up to the next tier or contact sales for a custom enterprise plan.
 </FaqItem>
 <FaqItem question="What's the difference between Swetrix and OpenPanel?">
-Swetrix is a cookieless, open-source web analytics tool focused on pageviews, events, performance, and user flows. OpenPanel also tracks product events and sessions, offers real-time dashboards, individual user views, and multiple SDKs, all cookie-free and GDPR compliant.
+Swetrix is a cookieless, open source web analytics tool focused on pageviews, events, performance monitoring, and user flows. OpenPanel also offers web analytics but adds product analytics with event tracking, funnels, retention, individual user/session views, and multiple SDKs — all cookieless and GDPR compliant.
 </FaqItem>
 </Faqs>
 
 ### Alternative to Swetrix
 **Plausible Analytics**  
-- Open-source, privacy-first web analytics with flat pricing  
+- Open source, privacy-first web analytics with flat pricing  
 - Tracks pageviews and goals with no cookies required  
-- Self-host for free or start hosted plans at \$9/month for 10 000 pageviews  
+- Self-host for free or start hosted plans at $9/month for 10,000 pageviews  
-- Simple setup and predictable costs  
+- Simple setup and predictable costs  
+
+## Pricing Comparison: All 9 Tools at a Glance
+
+Here's how the cloud/hosted pricing compares across all tools at common event volumes:
+
+| Monthly Events | OpenPanel | PostHog | Plausible | Matomo Cloud | Fathom | Umami Cloud | Pirsch | Swetrix |
+|---------------|-----------|---------|-----------|-------------|--------|-------------|--------|---------|
+| 10K | $5 | $0 | $9 | €29 | $15 | $0 | $6 | $5 |
+| 100K | $20 | $0 | $14 | €29 | $15 | $0 | ~$12+ | $15 |
+| 500K | $50 | $0 | ~$19+ | Custom | $45 | $0 | Custom | $45 |
+| 1M | $90 | $0 | Custom | Custom | $60 | $0 | Custom | $59 |
+| 5M | $250 | ~$187 | Custom | Custom | $140 | ~$80 | Custom | $110 |
+| 10M | $350 | ~$393 | Custom | Custom | $200 | ~$180 | Custom | $150 |
+
+*PostHog and Umami include 1M free events/month. Plausible prices by pageviews, not events. Matomo prices by "hits." Exact pricing varies — check each provider for current rates.*
+
+## How to Choose the Right Open Source Analytics Tool
+
+**Choose OpenPanel if** you want the power of product analytics (funnels, retention, user tracking) combined with web analytics, at an affordable price. Best for startups and growing companies.
+
+**Choose PostHog if** you need an all-in-one developer platform with analytics, feature flags, experiments, error tracking, and surveys. Best for engineering-heavy teams.
+
+**Choose Plausible if** you want the simplest possible privacy-first web analytics. No complexity, just clean traffic data. Best for blogs, marketing sites, and simple web projects.
+
+**Choose Matomo if** you need a mature, full-featured Google Analytics replacement with heatmaps, session recordings, and A/B testing. Best for enterprises moving away from GA4. See our full [Google Analytics alternative comparison](/compare/google-analytics-alternative) for a detailed breakdown.
+
+**Choose Umami if** you want a lightweight, MIT-licensed tool to self-host with minimal setup. Best for developers who want basic analytics on personal projects.
+
+**Choose Fathom if** you want simple privacy analytics without any self-hosting. Best for businesses that want zero maintenance.
+
+**Choose Pirsch if** you need server-side tracking that works around ad blockers. Best for sites where tracking accuracy is critical.
+
+**Choose Swetrix if** you want web analytics plus performance monitoring in one tool. Best for teams focused on web performance.
+
+**Choose Ackee if** you want the most minimal self-hosted solution possible. Best for personal projects or developers who want maximum simplicity.
+
+<Faqs>
+<FaqItem question="What is the best open source web analytics tool?">
+The best open source web analytics tool depends on your needs. For combined web and product analytics, OpenPanel offers the best value. For simplicity, Plausible is hard to beat. For an all-in-one developer platform, PostHog is the most comprehensive. For a mature Google Analytics replacement, Matomo has the longest track record. All four offer self-hosting and GDPR compliance.
+</FaqItem>
+
+<FaqItem question="What is the best open source alternative to Google Analytics?">
+The top open source alternatives to Google Analytics are Matomo (most similar feature set), Plausible (simplest and most privacy-focused), OpenPanel (adds product analytics), and Umami (lightest weight). All are GDPR compliant and can be self-hosted for free. Matomo is the most direct replacement since it tracks similar metrics to GA4. For a detailed comparison, see our [Google Analytics alternative page](/compare/google-analytics-alternative). Ready to switch? Follow our step-by-step [migration guide](/guides/migrate-from-google-analytics).
+</FaqItem>
+
+<FaqItem question="Can I self-host open source analytics for free?">
+Yes. OpenPanel, PostHog, Plausible, Matomo, Umami, Ackee, and Swetrix all offer free self-hosting. Your only cost is the server infrastructure, which typically runs $5-50/month for a VPS depending on your traffic volume. Self-hosting gives you complete data ownership and privacy control.
+</FaqItem>
+
+<FaqItem question="What is the best open source product analytics tool?">
+For open source product analytics (event tracking, funnels, retention, user journeys), the top options are OpenPanel and PostHog. OpenPanel is more affordable and simpler to self-host, while PostHog offers additional features like feature flags, experiments, and error tracking. Both support self-hosting and have generous free tiers on their cloud platforms.
+</FaqItem>
+
+<FaqItem question="Which open source analytics tools don't use cookies?">
+Most modern open source analytics tools are cookieless by design. OpenPanel, Plausible, Umami, Pirsch, Fathom, Swetrix, and Ackee all track without cookies. Matomo offers a cookieless tracking mode. PostHog uses cookies by default but can be configured for cookieless tracking. Cookieless tools don't require consent banners, improving both user experience and data accuracy.
+</FaqItem>
+
+<FaqItem question="Is open source analytics secure?">
+Open source analytics can be more secure than proprietary alternatives because the code is publicly auditable. With self-hosted solutions, your data never leaves your servers. Tools like OpenPanel, Matomo, and PostHog are GDPR and CCPA compliant by design, with built-in privacy features like IP anonymization and data minimization.
+</FaqItem>
+</Faqs>

apps/public/content/articles/recap-2024.mdx

@@ -2,6 +2,7 @@
 title: Recap of 2024
 description: As we approach the end of the year, I wanted to share a summary of how this year unfolded and how everything began.
 date: 2024-12-30
+updated: 2026-02-07
 tag: Article
 team: Carl-Gerhard Lindesvärd
 cover: /content/recap-2024.jpg
@@ -19,7 +20,7 @@ And here we are...
 
 ## Inspiration
 
-I've always been a fan of Mixpanel - they crush it at product analytics. But I felt they were missing something when it came to web analytics.
+I've always been a fan of Mixpanel - they crush it at product analytics. But I felt they were missing something when it came to [web analytics](/features/web-analytics).
 
 I also noticed all these privacy-focused web analytics tools popping up in the last few years, which I love. That's where OpenPanel comes in. I wanted to build something that takes privacy seriously, has both web and product analytics, great support for native apps but is still super easy to use, even if you're new to the whole analytics game.
 
@@ -53,10 +54,10 @@ Making OpenPanel [open-source](https://git.new/openpanel) and [self-hosted](http
 
 Exciting developments are coming in 2025. Here are some of the priorities:
 
-- Revenue tracking 💸
+- [Revenue tracking](/features/revenue-tracking) 💸
 - Release Android and iOS apps. 📱
 - Improve report creation. 📊
-- Add more conversion rate charts (conversion is one of the best ways to understand your product). 📈
+- Add more [conversion rate](/features/conversion) charts (conversion is one of the best ways to understand your product). 📈
 - Enable report sharing. 🔗
 - Customize the overview page. 🎨
 - Enhance the real-time view. 📈

apps/public/content/articles/self-hosted-product-analytics.mdx

@@ -0,0 +1,381 @@
+---
+title: "Best Self-Hosted Product Analytics Tools in 2026 (Compared)"
+description: "Compare the best self-hosted product analytics tools in 2026. Detailed breakdown of OpenPanel, PostHog, Countly, Matomo, and more — with features, pricing, deployment, and honest pros/cons."
+tag: Comparison
+team: OpenPanel Team
+date: 2026-02-16
+updated: 2026-02-16
+cover: /content/self-hosted-analytics.jpg
+---
+import { Faqs, FaqItem } from '@/components/faq';
+
+Product analytics tells you *what users do* inside your product — which features they use, where they drop off, how often they come back, and what paths they take before converting. It's the difference between knowing "we got 10,000 pageviews" and knowing "40% of users who start onboarding never finish step 3."
+
+If you want those insights without sending user behavior data to a third party, self-hosted product analytics is the way to go.
+
+But here's the problem: most self-hosted analytics tools only cover **web analytics** — pageviews, traffic sources, and referrals. Product analytics features like funnels, retention, cohorts, and user identification require a different class of tool.
+
+We compared every self-hosted tool that offers real product analytics capabilities. Here's what's worth your time.
+
+## Quick Comparison
+
+| Tool | Focus | License | Self-Host Cost | Cloud Pricing (from) | Best For |
+|------|-------|---------|---------------|---------------------|----------|
+| [**OpenPanel**](#openpanel) | Web + Product | AGPL-3.0 | Free | $2.50/mo | Teams wanting Mixpanel-like analytics, self-hosted |
+| [**PostHog**](#posthog) | Product + Web | MIT | Free | $0 + usage | Dev teams needing analytics + flags + experiments |
+| [**Countly**](#countly) | Product + Mobile | AGPL-3.0 | Free (Community) | Custom | Mobile-first product analytics |
+| [**Matomo**](#matomo) | Web (+ Product plugins) | GPL-3.0 | Free (core) | €29/mo | GA replacement with product add-ons |
+| [**Mitzu**](#mitzu) | Product | Source Available | Paid | Custom | Warehouse-native product analytics |
+
+## What Makes Product Analytics Different from Web Analytics
+
+Web analytics answers questions about your **website traffic**: where visitors come from, which pages they view, and how long they stay. Tools like [Plausible](/compare/plausible-alternative), [Umami](/compare/umami-alternative), and [GoatCounter](/compare/goatcounter-alternative) do this well.
+
+Product analytics goes deeper. It answers questions about **user behavior**:
+
+- **Funnels**: What percentage of users complete signup? Where exactly do they drop off?
+- **Retention**: Are users coming back after their first week? First month?
+- **User journeys**: What do users do before upgrading to a paid plan?
+- **Cohort analysis**: Do users who onboard on mobile retain better than desktop users?
+- **Event tracking**: Which features get used? How often? By whom?
+
+If you're building a SaaS, mobile app, or any product where understanding user behavior matters, you need product analytics — not just pageview counts.
+
+For a comparison of self-hosted tools focused purely on web analytics, see our [self-hosted web analytics guide](/articles/self-hosted-web-analytics).
+
+---
+
+## OpenPanel
+
+**Best for: Teams that want Mixpanel-like product analytics with a self-hosted option**
+
+[OpenPanel](/) was built to give you the power of tools like [Mixpanel](/compare/mixpanel-alternative) and [Amplitude](/compare/amplitude-alternative) without sending your data to a third party. It combines web analytics and product analytics in one platform, with cookieless tracking and a straightforward self-hosting setup.
+
+![OpenPanel Dashboard](/content/tools/openpanel.png)
+
+### Product Analytics Features
+
+- **[Funnels](/features/funnels)**: Build multi-step conversion funnels with any events. See where users drop off and break down by properties.
+- **[Retention](/features/retention)**: Analyze how many users come back over time. Compare retention across cohorts, plans, or acquisition channels.
+- **[Event tracking](/features/event-tracking)**: Track any custom event with properties. Visualize with charts, tables, and breakdowns.
+- **User identification**: Link events to individual users. View complete user profiles with their full event history.
+- **[Session tracking](/features/session-tracking)**: See individual sessions with the full sequence of events and pages.
+- **Real-time dashboards**: Custom dashboards with multiple chart types, updated in real time.
+
+### Deployment
+
+Four commands to self-host:
+
+```bash
+git clone -b self-hosting https://github.com/Openpanel-dev/openpanel && cd openpanel/self-hosting && ./setup
+./start
+```
+
+Runs on Docker Compose with ClickHouse, PostgreSQL, and Redis. A mid-range VPS (4 vCPU, 8 GB RAM) handles millions of events. The setup wizard handles configuration, database setup, and SSL.
+
+Full guide: [How to self-host OpenPanel](/articles/how-to-self-host-openpanel) | [Self-hosting docs](/docs/self-hosting/self-hosting)
+
+### Pricing
+
+Self-hosting is free. All features included — the self-hosted version is identical to the cloud version with no feature gating.
+
+Cloud plans start at $2.50/month (5,000 events) and scale to $90/month for 1 million events. Every tier includes every feature.
+
+### Pros
+- Full product analytics (funnels, retention, user profiles) plus web analytics in one tool
+- Simplest self-hosting setup among tools with comparable features
+- Cookieless tracking — no consent banners needed
+- Self-hosted and cloud versions are identical
+- Multiple SDKs: JavaScript, React, Next.js, Vue, React Native, Flutter, and more
+
+### Cons
+- Newer project — smaller community than PostHog or Matomo
+- No built-in session replay or heatmaps yet
+- No built-in feature flags or A/B testing
+
+---
+
+## PostHog
+
+**Best for: Engineering teams that want analytics, feature flags, and experiments in one platform**
+
+[PostHog](https://posthog.com/) is the most feature-rich self-hosted product analytics tool. It bundles product analytics with session replay, feature flags, A/B testing, surveys, and error tracking. If you want a Swiss Army knife for product development, PostHog is the most complete option.
+
+![PostHog Dashboard](/content/tools/posthog.png)
+
+### Product Analytics Features
+
+- **Funnels**: Multi-step funnel analysis with breakdown by user properties
+- **Retention**: Cohort-based retention analysis
+- **User paths**: Visualize how users navigate through your product
+- **Cohorts**: Group users by behavior, properties, or lifecycle stage
+- **Session replay**: Watch recordings of actual user sessions
+- **Feature flags**: Roll out features to specific user segments
+- **A/B testing**: Run experiments and measure impact on metrics
+- **Surveys**: Collect in-product feedback
+
+### Deployment
+
+PostHog self-hosting uses Docker Compose for small deployments or Kubernetes (Helm charts) for production. The infrastructure stack includes PostgreSQL, Redis, ClickHouse, and Kafka — significantly more complex than other options.
+
+Requirements: Minimum 4 vCPU, 16 GB RAM, 30 GB+ storage. PostHog recommends self-hosting only for up to ~300K events/month. Beyond that, they push you toward their cloud offering.
+
+### Pricing
+
+Self-hosting is free under MIT license. Cloud has a generous free tier: 1 million analytics events, 5,000 session recordings, and 1 million feature flag requests per month. Beyond that, usage-based pricing kicks in (roughly $0.00005 per event for the next million).
+
+### Pros
+- Most comprehensive feature set of any self-hosted analytics tool
+- MIT license — very permissive
+- Generous cloud free tier for getting started
+- Active community and rapid development cycle
+
+### Cons
+- Complex self-hosting with multiple infrastructure dependencies
+- Resource-heavy — needs 4x the RAM of simpler tools
+- Self-hosted and cloud versions aren't feature-equivalent
+- Can be overwhelming — lots of features most teams won't use
+- PostHog actively discourages self-hosting at scale
+
+Compare with OpenPanel: [PostHog vs OpenPanel](/compare/posthog-alternative)
+
+---
+
+## Countly
+
+**Best for: Mobile-first product analytics with self-hosting**
+
+[Countly](https://countly.com/) is a product analytics platform with strong mobile analytics roots. It supports web, mobile, and desktop apps with SDKs for iOS, Android, React Native, Flutter, and more. The Community Edition is self-hostable under AGPL-3.0.
+
+### Product Analytics Features
+
+- **Funnels**: Define conversion funnels and track drop-off rates
+- **Retention**: Cohort retention analysis with configurable time periods
+- **User profiles**: Individual user tracking with event history
+- **Segmentation**: Filter and segment users by properties and behaviors
+- **Push notifications**: Built-in push notification system (mobile)
+- **Crash reporting**: Crash analytics for mobile apps
+
+### Deployment
+
+Countly self-hosts with Docker or manual installation on Linux. It uses MongoDB as its primary database. The setup is straightforward but requires MongoDB expertise for production deployments.
+
+Requirements: 4 vCPU, 8 GB RAM minimum. MongoDB 6+. More resources needed for high-traffic mobile apps.
+
+### Pricing
+
+The Community Edition is free under AGPL-3.0 but has limited features. Enterprise pricing is custom and includes advanced analytics, push notifications, crash reporting, and dedicated support. Expect significant cost for the Enterprise version.
+
+### Pros
+- Strong mobile analytics with native SDKs for all major platforms
+- Built-in push notifications and crash reporting
+- Established platform with enterprise customers
+- Good for mobile-first or hybrid app analytics
+
+### Cons
+- Community Edition is feature-limited — most product analytics features require Enterprise
+- Enterprise pricing is opaque and expensive
+- MongoDB-only — no PostgreSQL or ClickHouse option
+- UI feels dated compared to newer tools
+- Smaller open source community than PostHog
+
+Compare with OpenPanel: [Countly vs OpenPanel](/compare/countly-alternative)
+
+---
+
+## Matomo
+
+**Best for: Organizations that want a Google Analytics replacement with optional product analytics features**
+
+[Matomo](https://matomo.org/) is primarily a web analytics tool, but it offers product analytics capabilities through its plugin system. Heatmaps, session recordings, A/B testing, and funnels are available as paid plugins — even on self-hosted instances.
+
+![Matomo Dashboard](/content/tools/matomo.png)
+
+### Product Analytics Features
+
+- **Funnels** (paid plugin): Multi-step conversion funnels
+- **Cohorts** (paid plugin): Group users by behavior and analyze over time
+- **Heatmaps** (paid plugin): See where users click, scroll, and hover
+- **Session recordings** (paid plugin): Watch recordings of user sessions
+- **A/B testing** (paid plugin): Run experiments on your site
+- **Custom events**: Track custom events and goals
+
+### Deployment
+
+Matomo runs on PHP + MySQL/MariaDB. Deploy on any LAMP stack or use their Docker images. More complex than Docker-only tools because it requires a PHP environment and web server configuration.
+
+Full details in our [open source web analytics comparison](/articles/open-source-web-analytics#matomo).
+
+### Pricing
+
+The core platform is free under GPL-3.0. Product analytics plugins are sold separately:
+- Funnels: €199/year
+- Heatmaps + Session Recording: €249/year
+- A/B Testing: €199/year
+- Cohorts: €79/year
+
+These costs add up. A full product analytics setup on self-hosted Matomo can cost €500-700+/year in plugin licenses.
+
+### Pros
+- Most mature self-hosted analytics platform (since 2007)
+- Closest feature parity to Google Analytics
+- Large plugin ecosystem
+- Strong compliance track record
+
+### Cons
+- Product analytics features are paid add-ons, not included in the core
+- Plugin costs add up significantly
+- PHP stack requires more maintenance
+- Not a native product analytics tool — it's web analytics with product features bolted on
+
+Compare with OpenPanel: [Matomo vs OpenPanel](/compare/matomo-alternative)
+
+---
+
+## Mitzu
+
+**Best for: Data teams that want product analytics on top of their existing data warehouse**
+
+[Mitzu](https://www.mitzu.io/) takes a different approach. Instead of ingesting data into its own database, it runs analytics queries directly on your existing data warehouse (BigQuery, Snowflake, Databricks, etc.). If you already have event data in a warehouse, Mitzu gives you product analytics without duplicating data.
+
+### Product Analytics Features
+
+- **Funnels**: Conversion funnel analysis running on your warehouse
+- **Retention**: Cohort retention directly on warehouse data
+- **Segmentation**: Filter users by any property in your warehouse
+- **User journeys**: Path analysis on warehouse data
+- **Revenue analytics**: Connect events to revenue data
+
+### Deployment
+
+Mitzu deploys as a web application that connects to your existing warehouse. Self-hosting is available but requires a paid license.
+
+Requirements: An existing data warehouse (BigQuery, Snowflake, Databricks, ClickHouse, or PostgreSQL) with event data already flowing in.
+
+### Pricing
+
+Self-hosting requires a paid license (pricing available on request). Cloud plans are also custom-priced. There is no free tier for self-hosting.
+
+### Pros
+- No data duplication — queries your existing warehouse
+- Works with the data infrastructure you already have
+- Strong for data teams who live in SQL and warehouses
+- Good for organizations with complex data pipelines
+
+### Cons
+- Requires an existing data warehouse with event data
+- Self-hosting requires a paid license
+- Not suitable for teams starting from scratch
+- Smaller community and less documentation
+
+---
+
+## Self-Hosted Product Analytics vs Cloud: When to Self-Host
+
+The case for self-hosting product analytics is even stronger than for web analytics. Product analytics involves **user-level data** — individual users, their behaviors, their journeys through your product. This data is more sensitive than aggregate pageview counts.
+
+### Self-host product analytics when:
+
+- **You handle sensitive user data.** Healthcare (HIPAA), finance, or any industry where user behavior data is regulated. Self-hosting eliminates third-party data transfers entirely. See our [compliance guide](/articles/better-compliance-self-hosted-analytics).
+- **You need user-level data control.** Product analytics tracks individual users. Under GDPR, this is personal data. Self-hosting gives you full control over retention, deletion, and access.
+- **You want cost predictability.** Cloud product analytics pricing scales with events and identified users. At scale, this gets expensive fast. Self-hosting costs are your server costs.
+- **You have data residency requirements.** Some regulations require data to stay in specific geographic regions. Self-hosting on your own infrastructure solves this.
+
+### Use cloud when:
+
+- **You're just getting started with product analytics.** Cloud gets you insights faster. Self-host later when you've validated the tool fits your needs.
+- **You don't have ops capacity.** Product analytics tools with ClickHouse backends need some database knowledge to maintain.
+- **You need guaranteed uptime.** If analytics downtime directly impacts product decisions, a managed service with SLAs may be worth the cost.
+
+With [OpenPanel](/pricing), you can start on Cloud and migrate to self-hosting at any time. The features are identical in both versions.
+
+---
+
+## How to Get Started
+
+### 1. Pick a server
+
+For self-hosted product analytics, you'll want slightly more resources than for basic web analytics since product analytics involves more complex queries (funnels, retention calculations).
+
+Recommended starting point: 4 vCPU, 8 GB RAM, 80 GB SSD. This handles most small-to-medium products comfortably.
+
+- **[Hetzner](https://hetzner.cloud/?ref=7Hq0H5mQh7tM)** — A CX31 (4 vCPU, 8 GB RAM) for around €8.50/month
+- **DigitalOcean** — Equivalent droplet for ~$48/month
+- **Vultr** — Similar pricing to DigitalOcean
+
+### 2. Install and configure
+
+For OpenPanel:
+
+```bash
+git clone -b self-hosting https://github.com/Openpanel-dev/openpanel && cd openpanel/self-hosting && ./setup
+./start
+```
+
+The setup wizard walks you through domain configuration, database setup, SSL, and worker settings. Full guide: [How to self-host OpenPanel](/articles/how-to-self-host-openpanel).
+
+### 3. Instrument your product
+
+Product analytics requires event tracking in your codebase. With OpenPanel, install the SDK for your framework:
+
+```bash
+npm install @openpanel/nextjs
+# or @openpanel/react, @openpanel/vue, @openpanel/sdk
+```
+
+Then track events where they happen:
+
+```typescript
+import { op } from '@openpanel/nextjs';
+
+// Track a custom event
+op.track('signup_completed', {
+  plan: 'pro',
+  source: 'landing_page'
+});
+
+// Identify a user
+op.identify({
+  profileId: 'user_123',
+  email: 'user@example.com',
+  plan: 'pro'
+});
+```
+
+See the [SDK documentation](/docs/get-started/install-openpanel) for your specific framework.
+
+### 4. Build your first funnel
+
+Once events are flowing, create your first conversion funnel. A common starting point: **Visit landing page > Sign up > Complete onboarding > First key action**. This immediately shows you where users drop off in your core flow.
+
+---
+
+<Faqs>
+<FaqItem question="What is the best self-hosted product analytics tool?">
+For most teams, OpenPanel offers the best balance of product analytics features, ease of self-hosting, and cost. PostHog is more feature-rich (session replay, feature flags) but significantly more complex to self-host. Countly is best for mobile-first products.
+</FaqItem>
+
+<FaqItem question="Can I self-host Mixpanel or Amplitude?">
+No. Mixpanel and Amplitude are cloud-only platforms with no self-hosting option. The closest self-hosted alternatives are OpenPanel (most similar to Mixpanel in product analytics features) and PostHog (broader feature set with more complexity).
+</FaqItem>
+
+<FaqItem question="What is the difference between product analytics and web analytics?">
+Web analytics tracks website traffic — pageviews, referrals, devices, and geographic data. Product analytics tracks user behavior — events, funnels, retention, cohorts, and user journeys. Most self-hosted tools only offer web analytics. OpenPanel, PostHog, and Countly offer both. See our [self-hosted web analytics comparison](/articles/self-hosted-web-analytics) for web-focused tools.
+</FaqItem>
+
+<FaqItem question="How much does self-hosted product analytics cost?">
+The software is free for OpenPanel (AGPL-3.0) and PostHog (MIT). Your cost is server infrastructure — typically $10-50/month for a VPS, depending on traffic. Countly's Enterprise features and Matomo's product analytics plugins require paid licenses on top of server costs.
+</FaqItem>
+
+<FaqItem question="Do I need separate tools for web and product analytics?">
+Not necessarily. OpenPanel and PostHog both combine web analytics and product analytics in one platform. This means a single tracking snippet, one dashboard, and unified user profiles. If you only need web analytics, simpler tools like Plausible or Umami are better suited.
+</FaqItem>
+
+<FaqItem question="Is self-hosted product analytics GDPR compliant?">
+Self-hosting is one of the strongest approaches for GDPR compliance because user data never leaves your infrastructure. Combined with cookieless tracking (available in OpenPanel), you can run product analytics without consent banners and with full control over data retention and deletion.
+</FaqItem>
+
+<FaqItem question="Can I start with cloud and migrate to self-hosting later?">
+With OpenPanel, yes. The cloud and self-hosted versions are identical in features. You can start with Cloud to validate the tool and migrate to self-hosting when you're ready. PostHog also supports both, though there are some feature differences between their cloud and self-hosted versions.
+</FaqItem>
+</Faqs>

apps/public/content/articles/self-hosted-web-analytics.mdx

@@ -1,96 +1,405 @@
 ---
-title: Self-hosted web analytics
+title: "Best Self-Hosted Web Analytics Tools in 2026 (Compared)"
-description: Self-host your web analytics on your own infrastructure.
+description: "Compare the best self-hosted web analytics tools in 2026. Detailed breakdown of OpenPanel, Plausible, Matomo, Umami, GoatCounter, and more — with pricing, features, deployment, and honest pros/cons."
-tag: Hosting
+tag: Comparison
 team: OpenPanel Team
 date: 2024-11-14
-updated: 2025-12-02
+updated: 2026-02-16
 cover: /content/self-hosted-analytics.jpg
 ---
+import { Faqs, FaqItem } from '@/components/faq';
 
-In the digital age, understanding website traffic is crucial for any online presence. However, traditional analytics tools often come with privacy concerns and complex interfaces.
+Self-hosted web analytics gives you something cloud-only tools can't: **complete ownership of your data**. No third-party servers. No vendor lock-in. No surprise pricing changes. Your analytics data lives on your infrastructure, under your control.
 
-Self-hosted web analytics empowers you to maintain control over your data while gaining valuable insights into your website's performance. By hosting your own analytics platform, you can ensure data privacy and tailor the tool to your specific needs.
+But which self-hosted analytics tool should you actually use? There are over a dozen options, and they vary wildly in features, deployment complexity, and what they're good at.
 
-## Why Choose Self-Hosted Web Analytics?
+We tested and compared the most popular self-hosted web analytics tools so you don't have to. Here's what we found.
 
-You own your data - completely. No more worrying about what third-party services are doing with your information.
+## Quick Comparison
 
-Think about it: with your own analytics setup, you're in the driver's seat. You can:
+| Tool | Type | License | Deployment | Cloud Option | Best For |
-- Keep your data private and GDPR-compliant
+|------|------|---------|------------|-------------|----------|
-- Customize everything to work exactly how you want
+| [**OpenPanel**](#openpanel) | Web + Product | AGPL-3.0 | Docker Compose | From $2.50/mo | Teams needing web and product analytics |
-- Skip paying for expensive services (but keep in mind that you'll have to pay for your own server and maintenance)
+| [**Plausible**](#plausible) | Web | AGPL-3.0 | Docker Compose | From $9/mo | Simple, privacy-first pageview tracking |
+| [**Matomo**](#matomo) | Web | GPL-3.0 | PHP + MySQL | From €29/mo | Full Google Analytics replacement |
+| [**Umami**](#umami) | Web | MIT | Docker Compose | Free tier | Lightweight self-hosted analytics |
+| [**GoatCounter**](#goatcounter) | Web | EUPL | Single binary | Free tier | Minimalist analytics for small sites |
+| [**PostHog**](#posthog) | Product + Web | MIT | Docker/K8s | Free tier | Developer teams needing analytics + flags |
+| [**Ackee**](#ackee) | Web | MIT | Docker + MongoDB | None | Privacy-focused minimalist tracking |
 
-If you've been using tools like Mixpanel or Google Analytics, you might be surprised by how liberating it feels to have full control over your analytics.
+## How to Choose the Right Self-Hosted Analytics Tool
 
-## Self-Hosted Analytics as an Alternative to Mixpanel and Google Analytics
+Before picking a tool, think about what you actually need:
 
-While Google Analytics and Mixpanel are powerful tools, they come with their own set of limitations, particularly regarding data privacy and customization. Here’s how self-hosted analytics can serve as a viable alternative:
+**Web analytics vs product analytics.** If you only need pageviews, traffic sources, and referrals, a simple web analytics tool like Plausible or Umami will do. If you also need [funnels](/features/funnels), [retention analysis](/features/retention), user identification, and [event tracking](/features/event-tracking), you need a tool with product analytics capabilities.
 
-- **Google Analytics Alternatives**: Google Analytics is a comprehensive tool, but it often involves data sharing with Google itself. Self-hosted solutions eliminate this concern, providing similar functionalities without compromising privacy.
+**Deployment complexity.** Some tools deploy in under 5 minutes with a single Docker Compose command. Others need Kubernetes clusters, multiple databases, or PHP environments. Be honest about your ops capacity.
 
-- [**Mixpanel Alternatives**](/articles/alternatives-to-mixpanel): Mixpanel is known for its in-depth user analytics but can be costly and complex. Self-hosted alternatives offer a more cost-effective solution with the ability to customize and scale based on your unique requirements.
+**Maintenance burden.** Self-hosting means you handle updates, backups, and scaling. Simpler tools like GoatCounter or Umami need minimal maintenance. Feature-rich tools like Matomo or PostHog require more attention.
 
-## Simple analytics is key
+**Privacy and compliance.** All self-hosted tools keep data on your servers. But some go further with cookieless tracking (no consent banners needed), while others still use cookies by default.
 
-Most of the analytics tools out there are complex, feature packed and have a steep learning curve.
+**Cost at scale.** Self-hosting isn't free — you pay for server infrastructure. A $5/month VPS handles most small-to-medium sites, but high-traffic sites need more resources.
 
-**Look at Google Analytics**, for example. It's a powerful tool, but most often people don't even use a fraction of what it offers.
+---
 
-It's because they have made a tool that is so complex that it's hard to know where to start.
+## OpenPanel
 
-**Mixpanel has done it right**, but with their constant pricing changes, you never know what you're paying for.
+**Best for: Teams that need both web analytics and product analytics in one self-hosted tool**
 
-Open-source tools tend to be simpler and easier to understand, since they don't have to deal with the complexity of a big company with lots of stakeholders.
+[OpenPanel](/) combines [web analytics](/features/web-analytics) and product analytics in a single platform. You get pageviews and traffic sources alongside funnels, retention, user journeys, and event tracking. It uses cookieless tracking by default, which means no consent banners.
 
-## Privacy and security
+![OpenPanel Dashboard](/content/tools/openpanel.png)
 
-With growing concerns about data privacy, using a self-hosted solution ensures that your website's data is stored securely on your own servers. This approach minimizes the risk of data breaches and unauthorized access, providing peace of mind to both you and your website visitors. 
+### Deployment
 
-By removing the need for cookie consent banners, you create a smoother user experience while still adhering to privacy standards. This level of control makes self-hosted solutions attractive for those prioritizing privacy.
+OpenPanel is one of the easiest tools to self-host. Four commands and you're running:
 
-## Setting Up Your Self-Hosted Analytics
+```bash
+git clone -b self-hosting https://github.com/Openpanel-dev/openpanel && cd openpanel/self-hosting && ./setup
+./start
+```
 
-Transitioning to a self-hosted analytics solution may seem daunting, but it can be straightforward with the right approach:
+The setup wizard handles Docker, database configuration, and SSL. It runs on a single VPS with Docker Compose. A mid-range VPS (4 vCPU, 8 GB RAM) handles millions of events per month.
 
-### 1. Pick a server provider
+For detailed instructions, see the [self-hosting guide](/docs/self-hosting/self-hosting).
 
-Picking a server provider not an easy task. There are many things to consider, such as cost, performance, and security. We would advice you to do your own research and choose a provider that fits your needs.
+### Key Features
+- Real-time web analytics dashboard with traffic, referrals, pages, and devices
+- Product analytics: funnels, retention, user identification, custom events
+- Cookieless tracking — GDPR/CCPA compliant without consent banners
+- Multiple SDKs (JavaScript, React, Next.js, Vue, and more)
+- Self-hosted version is identical to the cloud version — no feature gating
 
-Here is a list of some providers that differ in both price and complexity:
+### Pricing
+Self-hosting is free. Cloud plans start at $2.50/month for up to 5,000 events, scaling to $90/month for 1 million events. All features included at every tier.
 
-- **AWS** - Complex but you can do almost anything
+### Pros
-- **Google Cloud** - Complex but you can do almost anything
+- Only self-hosted tool that combines web and product analytics at this price point
-- **DigitalOcean** - Easy to use but limited, great price
+- Simple Docker Compose deployment with guided setup
-- **Hetzner** - Easy to use but limited, best price!
+- Cookieless by default — no cookie banners needed
-- **Vultr** - Easy to use but limited, great price
+- Open source (AGPL-3.0) with no feature differences between cloud and self-hosted
 
-### 2. Pick a open-source analytics platform
+### Cons
+- Newer project with a smaller community than Matomo or PostHog
+- No built-in session replay or heatmaps (yet)
+- Self-hosting still requires server maintenance
 
-We're of course biased, but we think OpenPanel is the best self-hosted analytics platform out there since it has both product and web analytics. Most of the self-hosted analytics tools out there is just for web analytics.
+---
 
-So depending on your needs you might consider what you choose.
+## Plausible
 
-- **Plausible** - Simple and privacy focused ([compare with OpenPanel](/compare/plausible-alternative))
+**Best for: Simple, privacy-first pageview analytics with minimal setup**
-- **Simple Analytics** - Simple and privacy focused
-- **Fathom** - Simple and privacy focused ([compare with OpenPanel](/compare/fathom-alternative))
-- **OpenPanel** - Best of both worlds, easy to use and privacy focused
-- **Umami** - Lightweight and privacy focused ([compare with OpenPanel](/compare/umami-alternative))
 
-For a detailed comparison of all options, see our guide on the [best open source web analytics tools](/articles/open-source-web-analytics).
+[Plausible](https://plausible.io/self-hosted-web-analytics) is the go-to choice if you want clean, simple web analytics without complexity. It tracks pageviews, referrals, and goals without cookies. The dashboard fits on a single screen — no training required.
 
-Each of these platforms has guides how to set up on your own server, here is ours: [How to install OpenPanel on your own server](/docs/self-hosting/self-hosting)
+![Plausible Dashboard](/content/tools/plausible.png)
 
-### 3. Secure your server
+### Deployment
 
-Before you start installning your analytics platform, you should secure your server.
+Plausible self-hosts with Docker Compose. The setup involves cloning their hosting repo, configuring a `plausible-conf.env` file, and running `docker compose up`.
 
-Read our guide on [how to secure your server](/articles/how-to-secure-ubuntu-server) for more information.
+Requirements: A server with Docker, at least 2 GB RAM. Uses PostgreSQL and ClickHouse under the hood.
 
-### 4. Install your analytics platform
+### Key Features
+- Single-screen dashboard with real-time data
+- Cookieless tracking — no consent banners
+- Goal tracking and custom events
+- Google Search Console integration
+- Lightweight script (~1 KB)
 
-Each of the platforms has guides how to install on your own server. Usually this information is available on the project's website or GitHub repository.
+### Pricing
+Self-hosting is free under AGPL-3.0. Cloud plans start at $9/month for 10,000 pageviews.
 
-## Conclusion
+### Pros
+- The simplest analytics dashboard available — anyone can use it
+- Very lightweight tracking script that won't slow your site
+- Active open source community
+- Clean Docker Compose deployment
 
-Self-hosted web analytics is a strategic move for anyone looking to prioritize privacy and control over their website data. By opting for a solution that aligns with your values and needs, you can gain valuable insights without compromising on security. For those exploring [Mixpanel alternatives](/articles/alternatives-to-mixpanel) or Google Analytics alternatives, self-hosted platforms provide a robust and private solution. Take the leap into self-hosting today and experience the benefits of a more private and streamlined analytics process.
+### Cons
+- No product analytics (no funnels, retention, or user-level tracking)
+- No session replay or heatmaps
+- Self-hosted version requires manual updates
+- AGPL license requires source disclosure if you modify and distribute
+
+Compare with OpenPanel: [Plausible vs OpenPanel](/compare/plausible-alternative)
+
+---
+
+## Matomo
+
+**Best for: Organizations that need a full Google Analytics replacement**
+
+[Matomo](https://matomo.org/) (formerly Piwik) has been around since 2007 and is the most feature-rich self-hosted web analytics tool available. If you're migrating from Google Analytics and want a similar experience under your own control, Matomo is the closest match.
+
+![Matomo Dashboard](/content/tools/matomo.png)
+
+### Deployment
+
+Matomo runs on PHP + MySQL/MariaDB. You can deploy it on any LAMP stack or use their Docker images. The setup is more involved than Docker-only tools — you'll need PHP, a web server (Apache/Nginx), and a database.
+
+Requirements: PHP 8.1+, MySQL 8+ or MariaDB 10.4+, at least 2 GB RAM. For high traffic (1M+ pageviews/month), separate app and database servers are recommended.
+
+### Key Features
+- Full web analytics suite (traffic, referrals, campaigns, goals, ecommerce)
+- Heatmaps and session recordings (paid plugins)
+- A/B testing (paid plugin)
+- Google Analytics data import
+- Large plugin ecosystem
+
+### Pricing
+Self-hosting the core platform is free under GPL-3.0. However, advanced features like heatmaps, session recordings, and A/B testing require paid plugin subscriptions even on self-hosted instances. Cloud starts at €29/month.
+
+### Pros
+- Most mature and feature-rich self-hosted analytics tool
+- Closest replacement for Google Analytics
+- Huge plugin ecosystem
+- Strong compliance track record (used by governments and enterprises)
+
+### Cons
+- PHP stack is more complex to deploy and maintain than Docker-only tools
+- Premium plugins add cost even on self-hosted
+- UI feels dated compared to newer tools
+- Resource-heavy at scale
+
+Compare with OpenPanel: [Matomo vs OpenPanel](/compare/matomo-alternative)
+
+---
+
+## Umami
+
+**Best for: Developers who want a lightweight, MIT-licensed analytics tool**
+
+[Umami](https://umami.is/) is a lightweight, privacy-focused web analytics tool. It's one of the simplest tools to self-host and maintain. If you want basic web analytics with minimal overhead, Umami delivers.
+
+![Umami Dashboard](/content/tools/umami.png)
+
+### Deployment
+
+Umami self-hosts with Docker Compose or directly with Node.js. Clone the repo, configure your database connection, and start. It supports PostgreSQL and MySQL.
+
+Requirements: Node 18+ with PostgreSQL 12+ or MySQL 8+. Very lightweight — runs comfortably on a $5/month VPS for small to medium sites.
+
+### Key Features
+- Clean dashboard with real-time data
+- Pageviews, referrals, devices, and basic events
+- Cookieless tracking
+- Multiple website support
+- API access for custom integrations
+
+### Pricing
+Self-hosting is completely free under MIT license. Umami Cloud offers a free tier with 1 million events/month, then $0.00002 per additional event.
+
+### Pros
+- MIT license — the most permissive license among comparable tools
+- Very lightweight and easy to maintain
+- Simple deployment with Docker Compose
+- Free cloud tier for those who want to try before self-hosting
+
+### Cons
+- Limited to basic web metrics
+- No funnels, retention, or product analytics
+- Fewer features than Plausible (no Google Search Console integration)
+- No session replay or heatmaps
+
+Compare with OpenPanel: [Umami vs OpenPanel](/compare/umami-alternative)
+
+---
+
+## GoatCounter
+
+**Best for: Minimalist analytics for personal sites and blogs**
+
+[GoatCounter](https://goatcounter.com/) takes minimalism to the extreme. It's a single Go binary that tracks pageviews without cookies. No Docker, no complex setup — just download and run.
+
+### Deployment
+
+GoatCounter ships as a single binary. Download it, run it, point your domain at it. You can also run it with SQLite (default) or PostgreSQL. No Docker required, though Docker images are available.
+
+Requirements: Minimal. Runs on the smallest VPS you can find. SQLite mode needs almost no resources.
+
+### Key Features
+- Pageview tracking without cookies or JavaScript (optional)
+- Single binary deployment
+- SQLite or PostgreSQL backend
+- Basic referral and browser tracking
+- Public dashboard option
+
+### Pricing
+Self-hosting is free under EUPL license. The hosted service is free for non-commercial use, with paid plans starting at €5/month.
+
+### Pros
+- Simplest deployment of any analytics tool — single binary
+- Runs on minimal resources
+- Can work without JavaScript (server-side counting)
+- Free hosted tier for personal sites
+
+### Cons
+- Very basic feature set — pageviews and referrals only
+- No event tracking or custom properties
+- No product analytics features
+- Small development team (mostly one person)
+
+---
+
+## PostHog
+
+**Best for: Developer teams that need analytics, feature flags, and experiments in one platform**
+
+[PostHog](https://posthog.com/) is an all-in-one product analytics platform with web analytics, session replay, feature flags, A/B testing, and surveys. It's the most feature-rich option here, but also the most complex to self-host.
+
+![PostHog Dashboard](/content/tools/posthog.png)
+
+### Deployment
+
+PostHog self-hosting uses Docker Compose for small deployments or Kubernetes via Helm charts for production. The setup requires PostgreSQL, Redis, ClickHouse, and Kafka. It's significantly more complex than other tools on this list.
+
+Requirements: Minimum 4 vCPU, 16 GB RAM, 30 GB+ storage. The team recommends self-hosting only for up to ~300K events/month; beyond that, PostHog Cloud handles scaling better.
+
+### Key Features
+- Product analytics with funnels, retention, and cohorts
+- Web analytics dashboard
+- Session replay
+- Feature flags and A/B testing
+- Surveys and error tracking
+
+### Pricing
+Self-hosting is free under MIT license. Cloud has a generous free tier (1M analytics events, 5K session recordings/month), then usage-based pricing.
+
+### Pros
+- Most comprehensive feature set — replaces multiple tools
+- MIT license
+- Generous cloud free tier
+- Active community and rapid development
+
+### Cons
+- Complex self-hosting setup with multiple infrastructure dependencies
+- Resource-heavy — needs significantly more server power
+- Self-hosted vs cloud is not feature-equivalent
+- Overkill if you just need web analytics
+
+Compare with OpenPanel: [PostHog vs OpenPanel](/compare/posthog-alternative)
+
+---
+
+## Ackee
+
+**Best for: Privacy-focused minimalist tracking on small projects**
+
+[Ackee](https://github.com/electerious/Ackee) is a self-hosted analytics tool that focuses on privacy and minimalism. It tracks pageviews and basic events with a clean, minimal interface.
+
+### Deployment
+
+Ackee runs on Node.js with MongoDB. Deploy with Docker Compose or directly on a server with Node and MongoDB installed.
+
+Requirements: Node 18+, MongoDB 7+. Lightweight on resources.
+
+### Key Features
+- Pageview and event tracking
+- Cookieless, anonymized tracking
+- GraphQL API for custom integrations
+- Multiple domain support
+- Minimal, clean UI
+
+### Pricing
+Completely free to self-host under MIT license. No cloud offering from the team.
+
+### Pros
+- Fully free with MIT license
+- Privacy-first with anonymized data
+- GraphQL API for flexible querying
+- Very simple and focused
+
+### Cons
+- Requires MongoDB (adds complexity vs PostgreSQL-based tools)
+- Minimal feature set
+- No cloud option
+- Development has slowed in recent years
+
+Compare with OpenPanel: [Ackee vs OpenPanel](/compare/ackee-alternative)
+
+---
+
+## Self-Hosted vs Cloud Analytics: When to Self-Host
+
+Self-hosting isn't always the right choice. Here's when it makes sense — and when it doesn't.
+
+### Self-host when:
+
+- **You need data sovereignty.** Regulations like GDPR, HIPAA, or industry-specific rules require data to stay on your infrastructure. Self-hosting eliminates third-party data transfers entirely. Read more in our [compliance guide](/articles/better-compliance-self-hosted-analytics).
+- **You want predictable costs.** Cloud analytics pricing scales with events or pageviews. Self-hosting costs are your server costs, which are more predictable and often cheaper at scale.
+- **You have ops capacity.** Someone on your team can manage Docker, handle updates, and monitor uptime.
+- **You want full control.** Custom retention policies, direct database access, integration with internal systems.
+
+### Use cloud when:
+
+- **You want zero maintenance.** No server management, no updates, no uptime monitoring.
+- **You're just getting started.** Cloud gets you analytics in minutes. Self-hosting takes longer to set up.
+- **Your team is small.** If nobody on the team is comfortable managing infrastructure, cloud is safer.
+- **You need guaranteed uptime.** Cloud providers handle redundancy and failover.
+
+Most self-hosted analytics tools also offer cloud versions. With [OpenPanel](/pricing), you can start with Cloud and migrate to self-hosting later — or vice versa — since the features are identical.
+
+## How to Get Started with Self-Hosted Analytics
+
+### 1. Pick a server
+
+You need a VPS. For most self-hosted analytics tools, a server with 2-4 vCPU, 4-8 GB RAM, and 40 GB SSD is enough to start.
+
+Recommended providers:
+- **[Hetzner](https://hetzner.cloud/?ref=7Hq0H5mQh7tM)** — Best price-to-performance. A CX31 (4 vCPU, 8 GB RAM) costs around €8.50/month.
+- **DigitalOcean** — Easy to use, good documentation. Droplets from $6/month.
+- **Vultr** — Similar to DigitalOcean with competitive pricing.
+- **AWS/GCP** — More complex, but useful if you're already in their ecosystem.
+
+### 2. Secure your server
+
+Before installing anything, lock down your server. At minimum: disable root login, set up SSH keys, configure a firewall. We have a full guide on [how to secure your Ubuntu server](/articles/how-to-secure-ubuntu-server).
+
+### 3. Install your analytics tool
+
+Each tool has its own installation process. For OpenPanel, it's four commands:
+
+```bash
+git clone -b self-hosting https://github.com/Openpanel-dev/openpanel && cd openpanel/self-hosting && ./setup
+./start
+```
+
+The setup wizard handles everything — Docker, databases, SSL certificates. Full walkthrough: [How to self-host OpenPanel](/articles/how-to-self-host-openpanel).
+
+### 4. Add tracking to your site
+
+Install the tracking script on your website. With OpenPanel, you add a small JavaScript snippet or use one of the framework-specific SDKs (React, Next.js, Vue, and more). Check the [SDK documentation](/docs/get-started/install-openpanel) for your stack.
+
+---
+
+<Faqs>
+<FaqItem question="What is the best self-hosted web analytics tool?">
+It depends on your needs. For combined web and product analytics, OpenPanel offers the best value. For simple pageview tracking, Plausible is the most popular. For a full Google Analytics replacement, Matomo has the most features. For the lightest option, GoatCounter or Umami work well.
+</FaqItem>
+
+<FaqItem question="Is self-hosted analytics free?">
+The software is free for most tools (OpenPanel, Plausible, Matomo, Umami, GoatCounter, PostHog, and Ackee all offer free self-hosting). Your cost is the server infrastructure — typically $5-50/month for a VPS depending on your traffic volume.
+</FaqItem>
+
+<FaqItem question="Do I need a cookie banner with self-hosted analytics?">
+Not if your tool uses cookieless tracking. OpenPanel, Plausible, Umami, GoatCounter, and Ackee all track without cookies, so no cookie consent banner is needed for basic analytics. Matomo uses cookies by default but offers a cookieless mode.
+</FaqItem>
+
+<FaqItem question="Can I self-host analytics and be GDPR compliant?">
+Yes. Self-hosting is one of the strongest approaches for GDPR compliance because your data never leaves your infrastructure. There are no third-party data transfers to worry about, and you have full control over data retention and deletion. Tools like OpenPanel and Plausible add cookieless tracking on top, making compliance even simpler.
+</FaqItem>
+
+<FaqItem question="How much server resources do I need for self-hosted analytics?">
+For most tools: 2-4 vCPU, 4-8 GB RAM, and 40 GB SSD handles up to a few hundred thousand events per month. PostHog needs more (16 GB RAM minimum). GoatCounter and Ackee run on minimal resources. Scale up as your traffic grows.
+</FaqItem>
+
+<FaqItem question="What is the difference between self-hosted web analytics and product analytics?">
+Web analytics tracks website traffic — pageviews, referrals, devices, and geographic data. Product analytics tracks user behavior within your product — events, funnels, retention, and user journeys. Some tools like OpenPanel and PostHog offer both. Most self-hosted tools (Plausible, Umami, GoatCounter) focus on web analytics only. See our guide on [self-hosted product analytics](/articles/self-hosted-product-analytics) for tools that cover the product side.
+</FaqItem>
+
+<FaqItem question="Can I migrate from Google Analytics to a self-hosted tool?">
+Yes. Matomo offers direct Google Analytics data import. Other tools like OpenPanel and Plausible let you start fresh with their tracking. You can run both in parallel during the transition to make sure you're comfortable with the new tool before removing GA.
+</FaqItem>
+</Faqs>

apps/public/content/articles/vs-mixpanel.mdx

@@ -1,110 +0,0 @@
----
-title: Mixpanel vs OpenPanel
-description: A comparison between Mixpanel and OpenPanel
-date: 2024-11-13
-updated: 2025-12-02
-tag: Comparison
-team: OpenPanel Team
-cover: /content/cover-mixpanel.jpg
----
-import { Figure } from "@/components/figure";
-
-OpenPanel is based on the same principles as Mixpanel, but with a few key differences. We'll go through some of the features and see how they compare.
-
-> See our detailed comparison: [OpenPanel vs Mixpanel](/compare/mixpanel-alternative)
->
-> Looking for pricing details? Check out our [complete Mixpanel pricing breakdown](/articles/mixpanel-pricing)
-
-## Web analytics
-
-Mixpanel is a great product analytics tool but in our minds its lacking in this area. Web analytics should always be easy to get going and we think Mixpanel has to much focus on product analytics.
-
-In OpenPanel you do not need to do anything to get your web analytics up and running. Just add the tracking snippet to your website or app and you're up and running.
-
-<Figure
-  src="/content/screenshot-web-analytics.png"
-  alt="OpenPanel web analytics dashboard showing pageviews, sessions and other key metrics"
-  caption="OpenPanel's web analytics dashboard provides key metrics at a glance"
-/>
-
-## Product analytics
-
-Mixpanel's strength is in product analytics and it's hard to beat (to be honest). Nevertheless we aim to have the same great features in OpenPanel.
-
-Probably the most used feature in Mixpanel is their report tool, where you can create all kinds of charts and see how different things are doing. We have tried to make a similar experiance where you can pick and choose different metrics and dimensions to create your own custom reports.
-
-Some of the features we have added are:
-
-- **Funnels**
-- **Retention**
-- **Line charts**
-- **Bar charts**
-- **Histogram charts**
-- **Area charts**
-- **Pie charts**
-- **Map charts**
-- **Events**
-- **Profiles**
-
-<Figure
-  src="/content/screenshot-report-funnel.png"
-  alt="OpenPanel report tool showing a funnel"
-  caption="OpenPanel's report tool provides a wide range of charts and metrics"
-/>
-
-## Cookies vs Cookieless
-
-Mixpanel is a cookie-based tool, which means that it relies on cookies to track users. This provides advantages like:
-- More accurate user identification across sessions
-- Better cross-domain tracking
-- Easier integration with existing cookie-based systems
-
-However, it also comes with challenges:
-- Requires cookie consent banners in many jurisdictions
-- Can be blocked by ad blockers and privacy-focused browsers
-- May not work with upcoming cookie restrictions
-
-OpenPanel uses a cookieless approach, relying instead on privacy-preserving techniques like fingerprinting and session-based tracking. This offers benefits such as:
-- No cookie consent banners required
-- Works even when cookies are blocked
-- Future-proof against upcoming cookie restrictions
-
-> Its up to you to decide what's best for your users and your business.
-
-## Realtime
-
-Both Mixpanel and OpenPanel have real-time analytics. Its just a matter of seconds before you can see what's happening in your product or website. 
-
-But we have added a new feature in OpenPanel which we call `Realtime`. It's similar to Google Analytics' real-time view since we love looking at big screens with live data.
-
-<Figure
-  src="/content/screenshot-realtime.png"
-  alt="OpenPanel real-time analytics dashboard showing active users and other key metrics"
-  caption="See where all your users are at the moment in OpenPanel's realtime view"
-/>
-
-## Notifications
-
-In OpenPanel you can create notifications for different events. This is a great way to stay on top of things and get notified when something is happening.
-
-You can define advanced conditions when and what to notify you about. We have several integrations with other tools so you can easily connect your notifications to other tools you use.
-
-As of now, we don't believe Mixpanel has this feature.
-
-## Similarities
-
-### Profiles
-
-Both Mixpanel and OpenPanel allow you to see profiles of your users. This is a great way to understand your users and see how they are doing.
-
-### Events
-
-You get new events in realtime in both Mixpanel and OpenPanel, you can search and filter on any property. Mixpanel might be a bit faster but it's not a big difference.
-
-## Conclusion
-
-Mixpanel is a great product analytics tool but in our minds its lacking in this area. Web analytics should always be easy to get going and we think Mixpanel has to much focus on product analytics.
-
-**OpenPanel is a great alternative to Mixpanel** if you want to get started with analytics quickly and easily.
-
-Looking for more options? Check out our guide on [9 best open source web analytics tools](/articles/open-source-web-analytics) for a comprehensive comparison.

apps/public/content/compare/ackee-alternative.json

@@ -2,12 +2,12 @@
   "slug": "ackee-alternative",
   "page_type": "alternative",
   "seo": {
-    "title": "Ackee Alternative: Why Teams Choose OpenPanel",
+    "title": "Best Ackee Alternative 2026 - Open Source & Free",
-    "description": "Compare OpenPanel vs Ackee Analytics. Discover why teams choose OpenPanel as their Ackee alternative for product analytics, user identification, and scalable analytics while maintaining privacy.",
+    "description": "Looking for an Ackee alternative? OpenPanel offers deeper product analytics with funnels, retention, and user identification \u2014 plus cloud and self-hosting options. Open source and free to start.",
     "noindex": false
   },
   "hero": {
-    "heading": "Ackee Alternative",
+    "heading": "Best Ackee Alternative",
     "subheading": "Love Ackee's privacy-first approach and self-hosting simplicity? OpenPanel adds product analytics capabilities - funnels, cohorts, retention, and user identification - with a modern architecture built for scale.",
     "badges": [
       "Open-source",
@@ -24,6 +24,15 @@
     "founded": 2016,
     "headquarters": "Germany"
   },
+  "overview": {
+    "title": "Why consider OpenPanel over Ackee?",
+    "paragraphs": [
+      "Ackee is an ultra-minimal, self-hosted analytics tool that prioritizes anonymous tracking and a clean interface. Built on MongoDB, it's a solid choice for developers who want basic web metrics on their own server without any third-party data sharing. But its intentional minimalism means no user identification, no product analytics, and no cloud-hosted option.",
+      "OpenPanel provides everything Ackee offers \u2014 privacy-focused, open-source, and self-hostable \u2014 while adding the product analytics capabilities that help you actually grow your product. Funnels let you understand where users drop off, retention analysis shows whether they come back, and user identification connects anonymous visits to real accounts once users sign in.",
+      "The database architecture is a fundamental difference. Ackee uses MongoDB, which works for small sites but isn't designed for analytical queries. OpenPanel uses ClickHouse, a column-oriented database purpose-built for analytics, which means fast queries even with millions of events. And if you don't want to manage servers, OpenPanel offers a cloud option with a free tier \u2014 something Ackee doesn't provide.",
+      "If you appreciate Ackee's self-hosted simplicity but need mobile app analytics through native SDKs, deeper insights into user behavior, or the option to use a managed cloud service, OpenPanel is the natural upgrade path."
+    ]
+  },
   "summary_comparison": {
     "title": "OpenPanel vs Ackee: Which is right for you?",
     "intro": "Both are privacy-focused open source analytics tools. Ackee focuses on simple web metrics with anonymous tracking. OpenPanel adds product analytics capabilities with user identification.",
@@ -495,6 +504,20 @@
     ]
   },
   "related_links": {
+    "guides": [
+      {
+        "title": "Website analytics setup",
+        "url": "/guides/website-analytics-setup"
+      },
+      {
+        "title": "Node.js analytics setup",
+        "url": "/guides/nodejs-analytics"
+      },
+      {
+        "title": "Migrate from Google Analytics",
+        "url": "/guides/migrate-from-google-analytics"
+      }
+    ],
     "articles": [
       {
         "title": "9 best open source web analytics tools",

apps/public/content/compare/amplitude-alternative.json

@@ -2,12 +2,12 @@
   "slug": "amplitude-alternative",
   "page_type": "alternative",
   "seo": {
-    "title": "Amplitude alternative",
+    "title": "Best Amplitude Alternatives 2026 - Open Source, Free & Paid",
-    "description": "Compare OpenPanel with Amplitude: open-source, privacy-first analytics with a lighter SDK. Get web and product analytics without the complexity or enterprise pricing.",
+    "description": "Compare the best Amplitude alternatives in 2026: OpenPanel, PostHog, Mixpanel, Heap, and Plausible. Open source, privacy-first, and affordable options for every team size. See which fits you best.",
     "noindex": false
   },
   "hero": {
-    "heading": "Amplitude alternative",
+    "heading": "Best Amplitude Alternatives",
     "subheading": "OpenPanel is an open-source, privacy-first alternative to Amplitude. Get powerful product analytics with web analytics built in, cookie-free tracking, and the freedom to self-host or use our cloud.",
     "badges": [
       "Open-source",
@@ -24,6 +24,15 @@
     "founded": 2012,
     "headquarters": "San Francisco, CA"
   },
+  "overview": {
+    "title": "Why consider OpenPanel over Amplitude?",
+    "paragraphs": [
+      "Amplitude is one of the leading enterprise product analytics platforms, trusted by large companies for behavioral analytics, experimentation, and customer data management. But its power comes with significant complexity \u2014 a steep learning curve, enterprise-level pricing that can scale to six figures annually, and a cloud-only architecture that gives you no option to self-host your data.",
+      "OpenPanel offers a simpler, more affordable approach to product analytics without sacrificing the features that matter most. You get event tracking, funnels, retention analysis, cohort breakdowns, and user profiles \u2014 all in a clean interface that doesn't require a dedicated analytics team to operate. And because OpenPanel is open source, you can inspect the code, self-host on your own infrastructure, and avoid vendor lock-in entirely.",
+      "One of the biggest differences is privacy. Amplitude uses cookies and stores data on US servers by default, which means consent banners and GDPR complexity for European users. OpenPanel is cookie-free by default with EU-only data storage, so you can track user behavior without privacy trade-offs. The SDK is also dramatically smaller \u2014 2.3 KB compared to Amplitude's 36-96 KB \u2014 which directly impacts your page performance and Core Web Vitals.",
+      "For startups and growing teams who need solid product analytics without the enterprise overhead, OpenPanel delivers the insights you need at a price point that makes sense from day one."
+    ]
+  },
   "summary_comparison": {
     "title": "OpenPanel vs Amplitude: Which is right for you?",
     "intro": "Both platforms help product teams understand user behavior. The key differences are pricing model, complexity, privacy approach, and deployment options.",
@@ -419,10 +428,44 @@
       }
     ]
   },
+  "benefits_section": {
+    "label": "Why teams switch",
+    "title": "Everything you need, none of what you don't",
+    "description": "Amplitude packs in features most teams never use — and charges accordingly. OpenPanel focuses on the analytics that actually drive product decisions, at a price that makes sense from day one.",
+    "cta": {
+      "label": "Start free with OpenPanel",
+      "href": "https://dashboard.openpanel.dev/onboarding"
+    },
+    "benefits": [
+      "Event tracking, funnels, retention, and cohorts — without the enterprise learning curve",
+      "Cookie-free by default: no consent banners, no GDPR headaches for EU users",
+      "2.3 KB SDK vs Amplitude's 36–96 KB — real impact on page speed and Core Web Vitals",
+      "Self-host on your own infrastructure with Docker, or use our EU-only cloud",
+      "Transparent pricing from $2.50/month — no MTU surprises, no overage fees at 1.2x",
+      "Open source (AGPL-3.0): inspect the code, fork it, run it yourself",
+      "Web analytics and product analytics in one tool — no stitching together separate products"
+    ]
+  },
   "faqs": {
     "title": "Frequently asked questions",
-    "intro": "Common questions about switching from Amplitude to OpenPanel.",
+    "intro": "Common questions about Amplitude alternatives and switching to OpenPanel.",
     "items": [
+      {
+        "question": "What are the best Amplitude alternatives in 2026?",
+        "answer": "The top Amplitude alternatives depend on your team's needs: OpenPanel (open source, self-hostable, cookie-free — best for privacy-conscious teams and startups), PostHog (open source all-in-one with session replay and feature flags — best for developer-led teams who want everything in one tool), Mixpanel (mature event-based analytics with strong funnels and cohorts — best for established product teams), Heap (automatic event capture with retroactive analysis — best for teams who don't want to instrument events manually), and Plausible (simple, lightweight web analytics — best for teams who only need traffic data, not product analytics). OpenPanel is the strongest open-source alternative if self-hosting or cookie-free tracking matters to you."
+      },
+      {
+        "question": "How does Amplitude compare to PostHog?",
+        "answer": "Both Amplitude and PostHog are powerful product analytics platforms, but they differ significantly in approach. PostHog is fully open source and self-hostable, bundles session replay, feature flags, and A/B testing natively, and has a generous free tier. Amplitude is more mature in behavioral analytics and experimentation but is cloud-only, charges based on MTUs, and its pricing can reach six figures annually for large teams. PostHog tends to appeal to developer-led companies; Amplitude fits enterprise product and growth teams with dedicated analysts."
+      },
+      {
+        "question": "How does Amplitude compare to Mixpanel?",
+        "answer": "Amplitude and Mixpanel are the two most common enterprise product analytics tools and are often evaluated together. Mixpanel charges per event (not per user like Amplitude), which can be cheaper or more expensive depending on your usage pattern. Amplitude has stronger experimentation features and ML-powered predictions; Mixpanel is generally considered easier to set up and use. Neither offers self-hosting. For teams looking for an open-source alternative to both, OpenPanel covers core funnels, retention, and cohorts without the enterprise pricing of either."
+      },
+      {
+        "question": "Is there a free Amplitude alternative?",
+        "answer": "Yes — OpenPanel is free to self-host with unlimited events. You run it on your own infrastructure using Docker, and there are no per-event or per-user fees. The cloud-hosted version starts at $2.50/month. PostHog also has a generous free tier (1M events/month). Mixpanel's free plan includes up to 1M events. If you're looking for something completely free with no limits, self-hosted OpenPanel is the strongest option."
+      },
       {
         "question": "Is Amplitude free?",
         "answer": "Amplitude offers a free Starter plan with up to 50,000 Monthly Tracked Users (MTUs) and 10 million events. However, it has limited features, no customer support, and you'll need to upgrade quickly as you grow. The Plus plan starts at $49/month for just 1,000 MTUs."
@@ -458,10 +501,28 @@
     ]
   },
   "related_links": {
+    "guides": [
+      {
+        "title": "Migrate from Mixpanel",
+        "url": "/guides/migrate-from-mixpanel"
+      },
+      {
+        "title": "Track custom events",
+        "url": "/guides/track-custom-events"
+      },
+      {
+        "title": "Ecommerce event tracking",
+        "url": "/guides/ecommerce-tracking"
+      }
+    ],
     "articles": [
       {
-        "title": "Find an alternative to Mixpanel",
+        "title": "Best Mixpanel alternatives in 2026",
-        "url": "/articles/alternatives-to-mixpanel"
+        "url": "/articles/mixpanel-alternatives"
+      },
+      {
+        "title": "Best self-hosted product analytics tools",
+        "url": "/articles/self-hosted-product-analytics"
       },
       {
         "title": "9 best open source web analytics tools",
@@ -476,6 +537,18 @@
       {
         "name": "PostHog",
         "url": "/compare/posthog-alternative"
+      },
+      {
+        "name": "Heap",
+        "url": "/compare/heap-alternative"
+      },
+      {
+        "name": "Plausible",
+        "url": "/compare/plausible-alternative"
+      },
+      {
+        "name": "Fullstory",
+        "url": "/compare/fullstory-alternative"
       }
     ]
   },

apps/public/content/compare/appsflyer-alternative.json

@@ -2,13 +2,13 @@
   "slug": "appsflyer-alternative",
   "page_type": "alternative",
   "seo": {
-    "title": "AppsFlyer Alternative",
+    "title": "Best AppsFlyer Alternative 2026 - Open Source & Free",
-    "description": "Compare OpenPanel with AppsFlyer: pricing, features, and focus. OpenPanel provides product analytics; AppsFlyer specializes in mobile attribution.",
+    "description": "Looking for an AppsFlyer alternative? OpenPanel offers product analytics with mobile SDKs, transparent pricing, and full data ownership. Open source and free to self-host.",
     "noindex": false
   },
   "hero": {
-    "heading": "AppsFlyer alternative",
+    "heading": "Best AppsFlyer Alternative",
-    "subheading": "Need to understand user behavior, not just ad attribution? OpenPanel provides product analytics—funnels, retention, cohorts, and user profiles—at a fraction of AppsFlyer's cost, without complex enterprise contracts.",
+    "subheading": "Need to understand user behavior, not just ad attribution? OpenPanel provides product analytics\u2014funnels, retention, cohorts, and user profiles\u2014at a fraction of AppsFlyer's cost, without complex enterprise contracts.",
     "badges": [
       "Product analytics",
       "Self-hostable",
@@ -24,6 +24,15 @@
     "founded": 2011,
     "headquarters": "San Francisco, CA"
   },
+  "overview": {
+    "title": "Why consider OpenPanel over AppsFlyer?",
+    "paragraphs": [
+      "AppsFlyer is the leading Mobile Measurement Partner (MMP), used by major brands to attribute app installs to advertising campaigns. With integrations to over 5,000 ad networks and sophisticated fraud protection, it's the gold standard for mobile attribution. But AppsFlyer's focus is narrowly on ad attribution \u2014 it tells you which campaign drove an install, not what users actually do inside your product.",
+      "OpenPanel serves a fundamentally different purpose: product analytics. While AppsFlyer tracks the marketing funnel (which ad, which campaign, which network), OpenPanel tracks the product funnel (which features users adopt, where they get stuck, and whether they retain). For teams that need to understand user behavior rather than ad performance, OpenPanel provides funnels, retention analysis, cohort breakdowns, and user profiles.",
+      "The pricing models couldn't be more different. AppsFlyer charges per conversion with enterprise contracts that typically run $3,000 to $100,000 or more annually. OpenPanel starts at $2.50 per month, or is completely free when self-hosted. For startups and growing companies, that difference in cost is significant \u2014 especially when you need analytics from day one but can't justify enterprise contracts.",
+      "Many teams use both tools for different purposes: AppsFlyer for marketing attribution and OpenPanel for in-product analytics. But if you're primarily interested in understanding what users do after they arrive \u2014 not which ad brought them \u2014 OpenPanel gives you those insights at a fraction of the cost."
+    ]
+  },
   "summary_comparison": {
     "title": "OpenPanel vs AppsFlyer: Which is right for you?",
     "intro": "These tools serve different primary purposes. AppsFlyer focuses on mobile attribution (which ad drove an install); OpenPanel focuses on product analytics (what users do in your app).",
@@ -76,7 +85,7 @@
   },
   "feature_comparison": {
     "title": "Feature comparison",
-    "intro": "OpenPanel and AppsFlyer serve different primary needs—product analytics vs mobile attribution.",
+    "intro": "OpenPanel and AppsFlyer serve different primary needs\u2014product analytics vs mobile attribution.",
     "groups": [
       {
         "group": "Product analytics",
@@ -336,7 +345,7 @@
       },
       {
         "title": "Configure product analytics",
-        "description": "Set up funnels, retention charts, and dashboards in OpenPanel—features not available in AppsFlyer."
+        "description": "Set up funnels, retention charts, and dashboards in OpenPanel\u2014features not available in AppsFlyer."
       }
     ],
     "sdk_compatibility": {
@@ -354,7 +363,7 @@
     "items": [
       {
         "title": "Product teams needing behavior analytics",
-        "description": "AppsFlyer tells you which ad brought a user. OpenPanel tells you what that user does in your product—funnels, feature usage, retention patterns.",
+        "description": "AppsFlyer tells you which ad brought a user. OpenPanel tells you what that user does in your product\u2014funnels, feature usage, retention patterns.",
         "icon": "chart"
       },
       {
@@ -397,7 +406,7 @@
       },
       {
         "question": "Does OpenPanel have fraud protection like AppsFlyer?",
-        "answer": "No. Fraud protection is specific to mobile attribution—detecting fake installs and click fraud. Since OpenPanel focuses on product analytics rather than attribution, fraud protection isn't applicable."
+        "answer": "No. Fraud protection is specific to mobile attribution\u2014detecting fake installs and click fraud. Since OpenPanel focuses on product analytics rather than attribution, fraud protection isn't applicable."
       },
       {
         "question": "Can OpenPanel do deep linking like AppsFlyer?",
@@ -414,6 +423,20 @@
     ]
   },
   "related_links": {
+    "guides": [
+      {
+        "title": "React Native analytics setup",
+        "url": "/guides/react-native-analytics"
+      },
+      {
+        "title": "Swift/iOS analytics setup",
+        "url": "/guides/swift-analytics"
+      },
+      {
+        "title": "Kotlin/Android analytics setup",
+        "url": "/guides/kotlin-analytics"
+      }
+    ],
     "articles": [
       {
         "title": "Find an alternative to Mixpanel",

apps/public/content/compare/cabin-analytics-alternative.json

@@ -2,13 +2,13 @@
   "slug": "cabin-analytics-alternative",
   "page_type": "alternative",
   "seo": {
-    "title": "Cabin Analytics Alternative: Why Teams Choose OpenPanel",
+    "title": "Best Cabin Analytics Alternative 2026 - Open Source & Free",
-    "description": "Compare OpenPanel vs Cabin Analytics. Discover why teams choose OpenPanel as their Cabin alternative for deeper product analytics, self-hosting, and mobile SDKs while maintaining environmental responsibility.",
+    "description": "Looking for a Cabin Analytics alternative? OpenPanel provides deeper product analytics, self-hosting, mobile SDKs, and user identification while staying privacy-first. Free to get started.",
     "noindex": false
   },
   "hero": {
-    "heading": "Cabin Analytics alternative",
+    "heading": "Best Cabin Analytics Alternative",
-    "subheading": "Love Cabin's carbon-conscious approach and privacy focus? OpenPanel adds deeper product analytics—self-hosting, mobile SDKs, user identification, funnels, and retention analysis—while staying open source and lightweight.",
+    "subheading": "Love Cabin's carbon-conscious approach and privacy focus? OpenPanel adds deeper product analytics\u2014self-hosting, mobile SDKs, user identification, funnels, and retention analysis\u2014while staying open source and lightweight.",
     "badges": [
       "Open-source",
       "Self-hostable",
@@ -24,6 +24,15 @@
     "founded": 2020,
     "headquarters": "London, UK"
   },
+  "overview": {
+    "title": "Why consider OpenPanel over Cabin Analytics?",
+    "paragraphs": [
+      "Cabin Analytics stands out with its unique carbon-conscious approach to web analytics \u2014 measuring not just your traffic, but the environmental impact of your website. Combined with privacy-first tracking and an ultra-lightweight script, it's an appealing choice for environmentally conscious teams. But Cabin is a web-only, cloud-only platform with no self-hosting option, no user identification, and no product analytics capabilities.",
+      "OpenPanel provides the same lightweight, privacy-first foundation while adding the depth that growing products need. User identification lets you connect anonymous visits to real accounts, funnels help you optimize conversion flows, and retention analysis shows whether your product keeps users coming back. These features transform analytics from simple traffic counting into actionable product insights.",
+      "Self-hosting is a major differentiator. Cabin Analytics is cloud-only, which means your data lives on their servers with no alternative. OpenPanel gives you the choice \u2014 use the managed cloud with a free tier, or deploy on your own infrastructure via Docker for complete data ownership. And with native SDKs for iOS, Android, and React Native, OpenPanel works for mobile apps too, not just websites.",
+      "If you love Cabin's lightweight and privacy-first approach but need analytics that go deeper than pageviews \u2014 especially for SaaS products, mobile apps, or any product where understanding user behavior matters \u2014 OpenPanel provides that depth without compromising on simplicity."
+    ]
+  },
   "summary_comparison": {
     "title": "OpenPanel vs Cabin: Which is right for you?",
     "intro": "Both platforms prioritize privacy and lightweight tracking. The key differences are depth of analytics, self-hosting capabilities, and platform support.",
@@ -352,7 +361,7 @@
   },
   "pricing": {
     "title": "Pricing comparison",
-    "intro": "Both offer generous free tiers with different pricing models—event-based vs flat monthly.",
+    "intro": "Both offer generous free tiers with different pricing models\u2014event-based vs flat monthly.",
     "openpanel": {
       "model": "Event-based, transparent",
       "description": "Start at $2.50/month for 5,000 events. Self-host for free with unlimited events. No limits on users, dashboards, or features at any tier."
@@ -384,7 +393,7 @@
       },
       {
         "title": "Set up funnels and retention",
-        "description": "Create funnels and retention reports in OpenPanel—features not available in Cabin."
+        "description": "Create funnels and retention reports in OpenPanel\u2014features not available in Cabin."
       },
       {
         "title": "Remove Cabin script",
@@ -466,6 +475,20 @@
     ]
   },
   "related_links": {
+    "guides": [
+      {
+        "title": "Website analytics setup",
+        "url": "/guides/website-analytics-setup"
+      },
+      {
+        "title": "Migrate from Google Analytics",
+        "url": "/guides/migrate-from-google-analytics"
+      },
+      {
+        "title": "Track custom events",
+        "url": "/guides/track-custom-events"
+      }
+    ],
     "articles": [
       {
         "title": "9 best open source web analytics tools",

apps/public/content/compare/countly-alternative.json

@@ -2,12 +2,12 @@
   "slug": "countly-alternative",
   "page_type": "alternative",
   "seo": {
-    "title": "Countly Alternative: Why Teams Choose OpenPanel",
+    "title": "Best Countly Alternative 2026 - Open Source & Free",
-    "description": "Compare OpenPanel vs Countly. Discover why teams choose OpenPanel as their Countly alternative for simpler pricing, lighter weight, and modern product analytics while maintaining privacy and self-hosting options.",
+    "description": "Looking for a Countly alternative? OpenPanel offers simpler pricing, a modern UI, and lightweight product analytics with self-hosting and privacy built in. Open source and free to start.",
     "noindex": false
   },
   "hero": {
-    "heading": "Countly Alternative",
+    "heading": "Best Countly Alternative",
     "subheading": "Want Countly's product analytics without the complexity? OpenPanel offers a simpler, more affordable approach to user analytics with self-hosting, mobile SDKs, and modern product analytics - all with transparent pricing.",
     "badges": [
       "Open-source",
@@ -24,6 +24,15 @@
     "founded": 2013,
     "headquarters": "London, UK"
   },
+  "overview": {
+    "title": "Why consider OpenPanel over Countly?",
+    "paragraphs": [
+      "Countly positions itself as an all-in-one product analytics platform with built-in push notifications, crash reporting, remote configuration, and surveys. It's a feature-rich platform that appeals to teams wanting everything under one roof. But that breadth comes with significant costs \u2014 MAU-based pricing that can reach $132,000 or more per year, a complex self-hosted setup requiring MongoDB, Node.js, and Nginx, and a restrictive AGPL license for the free tier that limits commercial use.",
+      "OpenPanel takes a focused approach to analytics with simpler pricing and deployment. Instead of bundling push notifications and crash reporting (which most teams already have through dedicated tools), OpenPanel focuses on what matters most: understanding user behavior through events, funnels, retention analysis, and cohort breakdowns. All features are included at every tier, with no premium add-ons or feature gating.",
+      "The licensing and pricing differences are substantial. Countly's free Lite tier uses AGPL licensing that prohibits commercial use, and paid plans start at $80 per month for just 2,000 MAUs. OpenPanel uses the permissive MIT license for unlimited commercial use, and its event-based pricing starts at $2.50 per month \u2014 or is completely free when self-hosted with no restrictions.",
+      "For teams that want straightforward product analytics without the complexity and cost of an all-in-one platform, OpenPanel delivers the analytics essentials with a dramatically simpler setup, lower cost, and more permissive licensing."
+    ]
+  },
   "summary_comparison": {
     "title": "OpenPanel vs Countly: Which is right for you?",
     "intro": "Both offer product analytics with self-hosting. Countly is an all-in-one platform with many features. OpenPanel focuses on analytics with simpler pricing.",
@@ -506,6 +515,20 @@
     ]
   },
   "related_links": {
+    "guides": [
+      {
+        "title": "React Native analytics setup",
+        "url": "/guides/react-native-analytics"
+      },
+      {
+        "title": "Track custom events",
+        "url": "/guides/track-custom-events"
+      },
+      {
+        "title": "Swift/iOS analytics setup",
+        "url": "/guides/swift-analytics"
+      }
+    ],
     "articles": [
       {
         "title": "9 best open source web analytics tools",

apps/public/content/compare/crazy-egg-alternative.json

@@ -2,13 +2,13 @@
   "slug": "crazy-egg-alternative",
   "page_type": "alternative",
   "seo": {
-    "title": "Crazy Egg Alternative",
+    "title": "Best Crazy Egg Alternative 2026 - Open Source & Free",
-    "description": "Compare OpenPanel with Crazy Egg: pricing, features, and focus. OpenPanel offers product analytics with mobile SDKs; Crazy Egg excels at heatmaps and A/B testing.",
+    "description": "Looking for a Crazy Egg alternative? OpenPanel goes beyond heatmaps with full product analytics, funnels, retention, and mobile SDKs. Open source, self-hostable, and free to start.",
     "noindex": false
   },
   "hero": {
-    "heading": "Crazy Egg alternative",
+    "heading": "Best Crazy Egg Alternative",
-    "subheading": "Get full product analytics capabilities beyond heatmaps. OpenPanel delivers funnel analysis, retention tracking, mobile SDKs, and user identification—fully open source and self-hostable.",
+    "subheading": "Get full product analytics capabilities beyond heatmaps. OpenPanel delivers funnel analysis, retention tracking, mobile SDKs, and user identification\u2014fully open source and self-hostable.",
     "badges": [
       "Open-source",
       "Self-hostable",
@@ -24,6 +24,15 @@
     "founded": 2005,
     "headquarters": "La Mirada, CA"
   },
+  "overview": {
+    "title": "Why consider OpenPanel over Crazy Egg?",
+    "paragraphs": [
+      "Crazy Egg, founded by Neil Patel and Hiten Shah in 2005, pioneered website heatmaps and has since expanded into A/B testing, session recordings, and surveys. It's a well-known tool for visual website optimization \u2014 understanding where visitors click, how far they scroll, and which page elements drive engagement. But Crazy Egg is web-only, proprietary, and focused on visual optimization rather than product analytics.",
+      "OpenPanel serves a different but complementary need. Where Crazy Egg helps you optimize individual pages through visual feedback, OpenPanel helps you understand the entire user journey through event-based product analytics. Funnels show you where users drop off in multi-step flows, retention analysis reveals whether they come back, and user profiles let you track individual behavior across sessions.",
+      "The technical differences are significant for growing teams. Crazy Egg is cloud-only with no self-hosting option and charges based on pageviews. OpenPanel is open source under the MIT license, offers full self-hosting via Docker, and supports mobile apps through native SDKs for iOS, Android, and React Native \u2014 capabilities Crazy Egg doesn't provide.",
+      "If you need to go beyond heatmaps and understand how users actually flow through your product, especially across both web and mobile platforms, OpenPanel provides the event-based analytics foundation that visual optimization tools like Crazy Egg can't match."
+    ]
+  },
   "summary_comparison": {
     "title": "OpenPanel vs Crazy Egg: Which is right for you?",
     "intro": "Crazy Egg focuses on visual website optimization with heatmaps and A/B testing. OpenPanel focuses on product analytics with mobile support.",
@@ -298,7 +307,7 @@
   },
   "pricing": {
     "title": "Pricing comparison",
-    "intro": "Both offer generous free tiers with different pricing models—event-based vs pageview-based.",
+    "intro": "Both offer generous free tiers with different pricing models\u2014event-based vs pageview-based.",
     "openpanel": {
       "model": "Event-based, transparent",
       "description": "Start at $2.50/month for 5,000 events. Self-host for free with unlimited events. All features included at every tier."
@@ -383,7 +392,7 @@
     "items": [
       {
         "question": "What will I lose switching from Crazy Egg to OpenPanel?",
-        "answer": "Crazy Egg's core features are heatmaps, A/B testing, on-site surveys, and popup CTAs. OpenPanel does not offer these features—it focuses on product analytics instead."
+        "answer": "Crazy Egg's core features are heatmaps, A/B testing, on-site surveys, and popup CTAs. OpenPanel does not offer these features\u2014it focuses on product analytics instead."
       },
       {
         "question": "Does OpenPanel have heatmaps like Crazy Egg?",
@@ -408,6 +417,20 @@
     ]
   },
   "related_links": {
+    "guides": [
+      {
+        "title": "Website analytics setup",
+        "url": "/guides/website-analytics-setup"
+      },
+      {
+        "title": "Track custom events",
+        "url": "/guides/track-custom-events"
+      },
+      {
+        "title": "Ecommerce event tracking",
+        "url": "/guides/ecommerce-tracking"
+      }
+    ],
     "articles": [
       {
         "title": "9 best open source web analytics tools",

apps/public/content/compare/fathom-alternative.json

@@ -2,12 +2,12 @@
   "slug": "fathom-alternative",
   "page_type": "alternative",
   "seo": {
-    "title": "Fathom Alternative: Why Teams Choose OpenPanel",
+    "title": "Best Fathom Alternative 2026 - Open Source & Free",
-    "description": "Compare OpenPanel vs Fathom Analytics. Discover why teams choose OpenPanel as their Fathom alternative for product analytics, user identification, and self-hosting while maintaining privacy-first principles.",
+    "description": "Looking for a Fathom alternative? OpenPanel adds product analytics, user identification, and free self-hosting to privacy-first web analytics. Open source with no data limits.",
     "noindex": false
   },
   "hero": {
-    "heading": "Fathom Alternative",
+    "heading": "Best Fathom Alternative",
     "subheading": "Love Fathom's simplicity and privacy focus? OpenPanel adds product analytics capabilities - funnels, cohorts, retention, and user identification - plus self-hosting options and a free tier.",
     "badges": [
       "Open-source",
@@ -24,6 +24,15 @@
     "founded": 2018,
     "headquarters": "Canada"
   },
+  "overview": {
+    "title": "Why consider OpenPanel over Fathom Analytics?",
+    "paragraphs": [
+      "Fathom Analytics is a well-respected privacy-first analytics tool known for its clean interface and cookie-free tracking. It's a solid choice for websites that need simple traffic metrics without the complexity of Google Analytics. But Fathom is intentionally limited to web analytics \u2014 there's no user identification, no funnels, no retention analysis, and no self-hosting option.",
+      "OpenPanel shares Fathom's commitment to privacy and simplicity but extends far beyond basic web metrics. You get full product analytics capabilities including funnel analysis, retention tracking, cohort breakdowns, and individual user profiles. This means you can track not just how many visitors you get, but how they convert, where they drop off, and whether they come back.",
+      "Pricing is another significant difference. Fathom has no free tier \u2014 plans start at $15 per month with no way to try the product beyond a brief trial. OpenPanel offers 10,000 free events per month on its cloud tier, and unlimited events when self-hosted. Self-hosting is available as a simple Docker deployment, giving teams full data ownership that Fathom's cloud-only model can't provide.",
+      "If you love Fathom's privacy-first approach but need deeper analytics to understand user behavior and grow your product, OpenPanel gives you that depth while keeping things simple and affordable."
+    ]
+  },
   "summary_comparison": {
     "title": "OpenPanel vs Fathom: Which is right for you?",
     "intro": "Both are privacy-focused analytics platforms. Fathom focuses on simple web traffic metrics. OpenPanel adds product analytics with user identification and self-hosting.",
@@ -459,6 +468,20 @@
     ]
   },
   "related_links": {
+    "guides": [
+      {
+        "title": "Website analytics setup",
+        "url": "/guides/website-analytics-setup"
+      },
+      {
+        "title": "Migrate from Google Analytics",
+        "url": "/guides/migrate-from-google-analytics"
+      },
+      {
+        "title": "Astro analytics setup",
+        "url": "/guides/astro-analytics"
+      }
+    ],
     "articles": [
       {
         "title": "9 best open source web analytics tools",

apps/public/content/compare/fullstory-alternative.json

@@ -2,13 +2,13 @@
   "slug": "fullstory-alternative",
   "page_type": "alternative",
   "seo": {
-    "title": "FullStory Alternative",
+    "title": "Best FullStory Alternative 2026 - Open Source & Free",
-    "description": "Compare OpenPanel with FullStory: pricing, privacy, self-hosting, and features. OpenPanel offers product analytics with transparent pricing and self-hosting.",
+    "description": "Looking for a FullStory alternative? OpenPanel offers product analytics with transparent pricing, self-hosting, and privacy-first tracking \u2014 no expensive session replay costs. Free to start.",
     "noindex": false
   },
   "hero": {
-    "heading": "FullStory alternative",
+    "heading": "Best FullStory Alternative",
-    "subheading": "Get powerful product analytics without FullStory's enterprise pricing. OpenPanel delivers funnel analysis, retention tracking, and user identification—fully open source and self-hostable with transparent pricing.",
+    "subheading": "Get powerful product analytics without FullStory's enterprise pricing. OpenPanel delivers funnel analysis, retention tracking, and user identification\u2014fully open source and self-hostable with transparent pricing.",
     "badges": [
       "Open-source",
       "Self-hostable",
@@ -24,6 +24,15 @@
     "founded": 2014,
     "headquarters": "Atlanta, GA"
   },
+  "overview": {
+    "title": "Why consider OpenPanel over FullStory?",
+    "paragraphs": [
+      "FullStory is a premium Digital Experience Intelligence platform known for its pixel-perfect session replay and frustration signal detection. It's a powerful tool for UX teams debugging user issues and optimizing conversion flows. But with enterprise pricing reportedly starting at $12,000 to $50,000 or more per year and no public pricing page, FullStory is out of reach for most teams.",
+      "OpenPanel focuses on product analytics rather than session replay, giving you event tracking, funnels, retention analysis, cohort breakdowns, and user profiles at a fraction of the cost. Starting at $2.50 per month \u2014 or completely free when self-hosted \u2014 OpenPanel makes product analytics accessible to teams of any size, with pricing that's transparent and predictable.",
+      "The open-source advantage is significant here. FullStory is entirely proprietary and cloud-only, which means you have no visibility into how your data is processed and no option to run it on your own infrastructure. OpenPanel is MIT-licensed with full self-hosting support, giving you complete data sovereignty and the ability to audit every line of code.",
+      "If session replay is your primary need, FullStory remains strong in that niche. But if you need product analytics \u2014 understanding how users flow through funnels, measuring retention, and tracking user behavior \u2014 OpenPanel delivers those capabilities without requiring an enterprise budget or sales conversation."
+    ]
+  },
   "summary_comparison": {
     "title": "OpenPanel vs FullStory: Which is right for you?",
     "intro": "Both platforms provide analytics and session replay, but FullStory focuses on visual debugging while OpenPanel emphasizes product analytics.",
@@ -377,7 +386,7 @@
       },
       {
         "title": "Product analytics focus",
-        "description": "If your primary need is product analytics—funnels, retention, cohorts—rather than visual debugging, OpenPanel provides these at a fraction of the cost.",
+        "description": "If your primary need is product analytics\u2014funnels, retention, cohorts\u2014rather than visual debugging, OpenPanel provides these at a fraction of the cost.",
         "icon": "chart"
       },
       {
@@ -418,6 +427,20 @@
     ]
   },
   "related_links": {
+    "guides": [
+      {
+        "title": "Track custom events",
+        "url": "/guides/track-custom-events"
+      },
+      {
+        "title": "React analytics setup",
+        "url": "/guides/react-analytics"
+      },
+      {
+        "title": "Website analytics setup",
+        "url": "/guides/website-analytics-setup"
+      }
+    ],
     "articles": [
       {
         "title": "9 best open source web analytics tools",

apps/public/content/compare/funnelio-alternative.json

@@ -2,12 +2,12 @@
   "slug": "funnelio-alternative",
   "page_type": "alternative",
   "seo": {
-    "title": "Funnel.io Alternative: Why Teams Choose OpenPanel for Product Analytics",
+    "title": "Best Funnel.io Alternative 2026 - Open Source & Free",
-    "description": "Compare OpenPanel vs Funnel.io. Understand the key differences between product analytics and marketing data integration, and discover why teams choose OpenPanel for tracking user behavior.",
+    "description": "Looking for a Funnel.io alternative? OpenPanel provides product analytics with event tracking, funnels, and user behavior insights. Open source, self-hostable, and free to get started.",
     "noindex": false
   },
   "hero": {
-    "heading": "Funnel.io Alternative",
+    "heading": "Best Funnel.io Alternative",
     "subheading": "Funnel.io aggregates marketing data from ad platforms. OpenPanel tracks user behavior in your product. Different tools for different needs - discover which is right for you.",
     "badges": [
       "Open-source",
@@ -24,6 +24,15 @@
     "founded": 2014,
     "headquarters": "Stockholm, Sweden"
   },
+  "overview": {
+    "title": "Why consider OpenPanel over Funnel.io?",
+    "paragraphs": [
+      "Funnel.io is a marketing data integration platform designed to aggregate data from over 500 advertising platforms and marketing tools into unified reports. It's used by marketing teams at large organizations to bring together campaign performance data from Google Ads, Facebook, LinkedIn, and hundreds of other sources. But Funnel.io doesn't track user behavior at all \u2014 it aggregates data that already exists in external platforms.",
+      "OpenPanel and Funnel.io serve fundamentally different purposes. Funnel.io answers the question 'how are my marketing campaigns performing across platforms?' while OpenPanel answers 'what are users doing inside my product?' If you need to track events, build funnels, analyze retention, and understand user behavior, that's product analytics \u2014 and that's what OpenPanel does.",
+      "The cost difference reflects these different markets. Funnel.io starts at $399 per month with no free tier, targeting enterprise marketing teams with large budgets. OpenPanel starts at $2.50 per month with a free tier of 10,000 events, or can be self-hosted for free. For product teams and startups, OpenPanel delivers actionable analytics without the enterprise price tag.",
+      "If you're evaluating analytics tools and Funnel.io appeared in your search, you likely need product analytics rather than marketing data aggregation. OpenPanel gives you the user behavior insights, funnel analysis, and retention tracking that help you build better products \u2014 with open-source transparency and the option to self-host."
+    ]
+  },
   "summary_comparison": {
     "title": "OpenPanel vs Funnel.io: Which is right for you?",
     "intro": "Funnel.io and OpenPanel serve fundamentally different purposes. Funnel.io aggregates marketing spend and campaign data from external platforms (Google Ads, Facebook Ads, etc.). OpenPanel tracks user behavior within your product.",
@@ -464,6 +473,20 @@
     ]
   },
   "related_links": {
+    "guides": [
+      {
+        "title": "Track custom events",
+        "url": "/guides/track-custom-events"
+      },
+      {
+        "title": "Ecommerce event tracking",
+        "url": "/guides/ecommerce-tracking"
+      },
+      {
+        "title": "Next.js analytics setup",
+        "url": "/guides/nextjs-analytics"
+      }
+    ],
     "articles": [
       {
         "title": "9 best open source web analytics tools",

apps/public/content/compare/goatcounter-alternative.json

@@ -2,12 +2,12 @@
   "slug": "goatcounter-alternative",
   "page_type": "alternative",
   "seo": {
-    "title": "GoatCounter Alternative: Why Teams Choose OpenPanel",
+    "title": "Best GoatCounter Alternative 2026 - Open Source & Free",
-    "description": "Compare OpenPanel vs GoatCounter. Discover why teams choose OpenPanel as their GoatCounter alternative for deeper product analytics, user identification, and mobile SDKs while maintaining privacy and open source values.",
+    "description": "Looking for a GoatCounter alternative? OpenPanel adds product analytics, user identification, and mobile SDKs while staying open source and privacy-first. Free to self-host.",
     "noindex": false
   },
   "hero": {
-    "heading": "GoatCounter Alternative",
+    "heading": "Best GoatCounter Alternative",
     "subheading": "Love GoatCounter's simplicity and privacy focus? OpenPanel adds deeper product analytics - user identification, funnels, retention analysis, and mobile SDKs - while staying open source and cookie-free.",
     "badges": [
       "Open-source",
@@ -24,6 +24,15 @@
     "founded": 2019,
     "headquarters": "Netherlands"
   },
+  "overview": {
+    "title": "Why consider OpenPanel over GoatCounter?",
+    "paragraphs": [
+      "GoatCounter is a charming, minimalist web analytics tool created and maintained by solo developer Martin Tournoij. It's completely free for public sites, privacy-friendly, and refreshingly simple. For personal blogs and small projects that just need basic pageview counts, it's hard to beat. But its minimal feature set and solo-developer maintenance model mean it's not built for teams with growing analytics needs.",
+      "OpenPanel shares GoatCounter's open-source spirit and privacy focus but adds the product analytics capabilities that growing teams require. User identification lets you track logged-in users across sessions, funnels help you understand conversion flows, and retention analysis shows whether users come back. These are features GoatCounter intentionally doesn't offer as part of its minimalist philosophy.",
+      "The technical architecture also differs significantly. GoatCounter stores data in SQLite or PostgreSQL, which works for small sites but isn't optimized for analytical queries at scale. OpenPanel uses ClickHouse \u2014 a column-oriented database purpose-built for analytics workloads \u2014 which means fast queries even as your data grows to millions of events.",
+      "If you've outgrown GoatCounter's simple pageview counting and need mobile app analytics via native SDKs, funnel analysis, or user-level insights, OpenPanel provides that depth while remaining open source and privacy-friendly."
+    ]
+  },
   "summary_comparison": {
     "title": "OpenPanel vs GoatCounter: Which is right for you?",
     "intro": "Both are privacy-focused open source analytics tools. GoatCounter is ultra-minimal for simple web stats. OpenPanel adds product analytics for user behavior tracking.",
@@ -534,6 +543,20 @@
     ]
   },
   "related_links": {
+    "guides": [
+      {
+        "title": "Website analytics setup",
+        "url": "/guides/website-analytics-setup"
+      },
+      {
+        "title": "Migrate from Google Analytics",
+        "url": "/guides/migrate-from-google-analytics"
+      },
+      {
+        "title": "Track custom events",
+        "url": "/guides/track-custom-events"
+      }
+    ],
     "articles": [
       {
         "title": "9 best open source web analytics tools",

apps/public/content/compare/google-analytics-alternative.json

@@ -2,79 +2,106 @@
   "slug": "google-analytics-alternative",
   "page_type": "alternative",
   "seo": {
-    "title": "Google Analytics alternative",
+    "title": "Best Open Source Google Analytics Alternative 2026 - Free & Private",
-    "description": "Compare OpenPanel with Google Analytics: privacy, simplicity, self-hosting, and features. OpenPanel offers cookie-free analytics with EU-only hosting and no data sent to Google.",
+    "description": "Switch from Google Analytics to OpenPanel \u2014 open-source, cookie-free, GDPR-compliant analytics with EU hosting. No consent banners needed. Self-host for free or start from $2.50/mo.",
     "noindex": false
   },
   "hero": {
-    "heading": "Google Analytics alternative",
+    "heading": "The Open Source Google Analytics Alternative",
-    "subheading": "OpenPanel is an open-source, privacy-first alternative to Google Analytics. Get both web analytics and product analytics in one tool, without cookies, consent banners, or sending your data to Google.",
+    "subheading": "OpenPanel is an open-source, privacy-first alternative to Google Analytics that combines web analytics with product analytics in one tool. Cookie-free tracking, EU data hosting, and a 2.3 KB SDK that won't slow down your site.",
     "badges": [
-      "Open-source",
+      "Open source (AGPL-3.0)",
-      "Cookie-free",
+      "Cookie-free tracking",
-      "EU-only hosting",
+      "EU-only data hosting",
-      "Self-hostable"
+      "Self-host for free",
+      "2.3 KB SDK"
     ]
   },
   "competitor": {
     "name": "Google Analytics",
     "logo": "/logos/google-analytics.svg",
     "url": "https://analytics.google.com",
-    "short_description": "Free web analytics platform from Google that tracks website traffic, user behavior, and conversions with deep integration into the Google ecosystem.",
+    "short_description": "Free web analytics platform from Google that tracks website traffic, user behavior, and conversions with deep integration into the Google advertising ecosystem.",
     "founded": 2005,
     "headquarters": "Mountain View, CA"
   },
+  "overview": {
+    "title": "Why teams are switching from Google Analytics to OpenPanel",
+    "paragraphs": [
+      "Google Analytics has been the default analytics tool since 2005. But the forced migration to GA4 fundamentally changed the product \u2014 the new event-based model has a steep learning curve, the interface is confusing for most users, and data retention dropped to just 14 months on the free tier. Meanwhile, privacy regulations like GDPR and the ePrivacy Directive mean GA4 requires cookie consent banners that hurt conversion rates and annoy visitors.",
+      "OpenPanel is built for the post-GA4 world. It's fully open source under the AGPL-3.0 license, which means you can inspect, modify, and self-host the entire codebase. Unlike Google Analytics, OpenPanel tracks visitors without cookies \u2014 no consent banners needed, and full GDPR compliance out of the box. Your data stays on EU servers in Sweden, or you can self-host on your own infrastructure for complete data sovereignty.",
+      "Where GA4 splits functionality between free and enterprise tiers ($50,000+/year for GA4 360), OpenPanel gives you everything in one package: real-time dashboards, funnels, retention analysis, cohorts, user profiles, custom events, and revenue tracking. The SDK is just 2.3 KB gzipped \u2014 over 13x smaller than Google's gtag.js \u2014 which directly improves your Core Web Vitals and page load times.",
+      "OpenPanel also goes beyond what GA4 offers for free: built-in A/B testing, unlimited data retention (when self-hosted), no data sampling, and direct SQL access to your analytics data via ClickHouse. If you don't rely heavily on Google Ads attribution, OpenPanel gives you better analytics with better privacy at a fraction of the complexity."
+    ]
+  },
   "summary_comparison": {
     "title": "OpenPanel vs Google Analytics: Which is right for you?",
-    "intro": "Both platforms help you understand website traffic and user behavior. The key differences are privacy approach, data ownership, and simplicity vs ecosystem integration.",
+    "intro": "Google Analytics and OpenPanel take fundamentally different approaches. GA4 prioritizes Google Ads integration and marketing attribution. OpenPanel prioritizes privacy, simplicity, and data ownership.",
-    "one_liner": "OpenPanel is privacy-focused and independent; Google Analytics is free but sends your data to Google.",
+    "one_liner": "OpenPanel is open-source and privacy-first; Google Analytics is free but sends your data to Google and requires cookies.",
     "best_for_openpanel": [
       "Privacy-conscious teams who want analytics without cookies or consent banners",
-      "Businesses that need EU-only data storage for GDPR compliance",
+      "EU businesses that need GDPR-compliant analytics with European data hosting",
-      "Developers who want to self-host and own their data completely",
+      "Developers who want to self-host and own their analytics data completely",
-      "Teams looking for both web analytics and product analytics in one tool"
+      "Teams frustrated with GA4's complexity who want simpler, actionable insights",
+      "Sites that care about performance \u2014 2.3 KB SDK vs Google's 30+ KB",
+      "Teams who need both web analytics and product analytics in one tool"
     ],
     "best_for_competitor": [
-      "Teams heavily invested in the Google Ads ecosystem",
+      "Teams heavily invested in Google Ads who need native conversion tracking and attribution",
-      "Organizations needing advanced attribution modeling for marketing",
+      "Large enterprises with dedicated analytics teams running complex multi-touch attribution models",
-      "Large enterprises with dedicated analytics teams and complex reporting needs",
+      "Organizations using the full Google Marketing Platform (Search Console, Ads, Tag Manager)",
-      "Users who need the free tier and can accept the privacy tradeoffs"
+      "Teams with zero analytics budget who accept Google's privacy tradeoffs for a free product"
     ]
   },
   "highlights": {
     "title": "Key differences at a glance",
-    "intro": "Here's how OpenPanel and Google Analytics compare on the factors that matter most.",
+    "intro": "Here's how OpenPanel and Google Analytics compare on the factors that matter most when choosing an analytics platform.",
     "items": [
-      {
-        "label": "Price",
-        "openpanel": "From $2.50/month (or free self-hosted)",
-        "competitor": "Free (360 starts at $50k/year)"
-      },
-      {
-        "label": "Cookies required",
-        "openpanel": "No (cookie-free by default)",
-        "competitor": "Yes (first-party cookies)"
-      },
-      {
-        "label": "Consent banner needed",
-        "openpanel": "No",
-        "competitor": "Yes (for GDPR/ePrivacy)"
-      },
-      {
-        "label": "Data location",
-        "openpanel": "EU-only (or your own servers)",
-        "competitor": "US (Google servers)"
-      },
       {
         "label": "Open source",
-        "openpanel": "Yes (AGPL-3.0)",
+        "openpanel": "Yes \u2014 AGPL-3.0 license, full source code on GitHub",
-        "competitor": "No"
+        "competitor": "No \u2014 proprietary, closed-source Google product"
+      },
+      {
+        "label": "Price",
+        "openpanel": "From $2.50/month cloud, or free self-hosted with unlimited events",
+        "competitor": "Free tier with limits, GA4 360 starts at $50,000/year"
+      },
+      {
+        "label": "Cookies",
+        "openpanel": "Cookie-free by default \u2014 no consent banner needed",
+        "competitor": "Requires first-party cookies and a consent banner under GDPR"
+      },
+      {
+        "label": "Data hosting",
+        "openpanel": "EU-only servers (Sweden) or self-host anywhere",
+        "competitor": "Processed on Google's US servers"
+      },
+      {
+        "label": "SDK size",
+        "openpanel": "2.3 KB gzipped \u2014 minimal impact on page speed",
+        "competitor": "30+ KB gzipped \u2014 impacts Core Web Vitals"
+      },
+      {
+        "label": "Data retention",
+        "openpanel": "Unlimited (self-hosted) or plan-based (cloud)",
+        "competitor": "2\u201314 months free tier, up to 50 months on GA4 360"
+      },
+      {
+        "label": "Data sampling",
+        "openpanel": "Never \u2014 every event counted accurately",
+        "competitor": "Yes \u2014 free tier samples data at high traffic volumes"
+      },
+      {
+        "label": "Self-hosting",
+        "openpanel": "Yes \u2014 single Docker container, simple setup",
+        "competitor": "Not available"
       }
     ]
   },
   "feature_comparison": {
-    "title": "Feature comparison",
+    "title": "Feature-by-feature comparison",
-    "intro": "OpenPanel combines web analytics with product analytics. Google Analytics focuses on marketing and traffic analysis with deep Google integration.",
+    "intro": "OpenPanel combines web analytics with product analytics. Google Analytics focuses on marketing attribution and traffic analysis within the Google ecosystem.",
     "groups": [
       {
         "group": "Web analytics",
@@ -86,7 +113,7 @@
             "notes": null
           },
           {
-            "name": "Traffic sources",
+            "name": "Traffic sources & referrals",
             "openpanel": true,
             "competitor": true,
             "notes": null
@@ -98,13 +125,13 @@
             "notes": null
           },
           {
-            "name": "Device & browser stats",
+            "name": "Device & browser breakdown",
             "openpanel": true,
             "competitor": true,
             "notes": null
           },
           {
-            "name": "UTM tracking",
+            "name": "UTM campaign tracking",
             "openpanel": true,
             "competitor": true,
             "notes": null
@@ -113,7 +140,13 @@
             "name": "Real-time dashboard",
             "openpanel": true,
             "competitor": true,
-            "notes": null
+            "notes": "OpenPanel shows live events; GA4 real-time is limited to last 30 minutes"
+          },
+          {
+            "name": "Outgoing link tracking",
+            "openpanel": true,
+            "competitor": true,
+            "notes": "OpenPanel tracks automatically with trackOutgoingLinks option"
           }
         ]
       },
@@ -124,13 +157,13 @@
             "name": "Custom event tracking",
             "openpanel": true,
             "competitor": true,
-            "notes": null
+            "notes": "OpenPanel uses a simpler track() API vs GA4's gtag event model"
           },
           {
-            "name": "Funnels",
+            "name": "Funnel analysis",
             "openpanel": true,
             "competitor": true,
-            "notes": "GA4 funnels available via Explorations"
+            "notes": "GA4 funnels require Explorations; OpenPanel has built-in funnel builder"
           },
           {
             "name": "Retention analysis",
@@ -139,19 +172,25 @@
             "notes": null
           },
           {
-            "name": "User profiles",
+            "name": "User profiles & identification",
             "openpanel": true,
             "competitor": true,
-            "notes": "GA4 uses User Properties"
+            "notes": "OpenPanel has rich user profiles with session history; GA4 uses User Properties"
           },
           {
-            "name": "Cohorts",
+            "name": "Cohort analysis",
             "openpanel": true,
             "competitor": true,
             "notes": null
           },
           {
-            "name": "Revenue tracking",
+            "name": "Revenue & e-commerce tracking",
+            "openpanel": true,
+            "competitor": true,
+            "notes": null
+          },
+          {
+            "name": "Conversion tracking",
             "openpanel": true,
             "competitor": true,
             "notes": null
@@ -165,37 +204,37 @@
             "name": "A/B testing",
             "openpanel": true,
             "competitor": false,
-            "notes": "Google Optimize was shut down in 2023"
+            "notes": "Google Optimize was shut down September 2023 \u2014 no built-in replacement"
           },
           {
             "name": "Custom dashboards",
             "openpanel": true,
             "competitor": true,
-            "notes": "GA4 uses Explorations for custom reports"
+            "notes": "GA4 uses complex Explorations; OpenPanel has drag-and-drop dashboard builder"
           },
           {
             "name": "AI insights",
             "openpanel": true,
             "competitor": true,
-            "notes": "GA4 has machine learning predictions"
+            "notes": null
           },
           {
             "name": "Attribution modeling",
             "openpanel": false,
             "competitor": true,
-            "notes": "GA4 has data-driven attribution"
+            "notes": "GA4 has data-driven attribution \u2014 its strongest advantage for advertisers"
           },
           {
-            "name": "Enhanced autocapture",
+            "name": "Alerts & notifications",
-            "openpanel": false,
-            "competitor": true,
-            "notes": "GA4 auto-tracks scrolls, clicks, downloads"
-          },
-          {
-            "name": "Notifications/Alerts",
             "openpanel": true,
             "competitor": true,
-            "notes": "OpenPanel supports webhooks, Slack, Discord"
+            "notes": "OpenPanel supports webhooks, Slack, Discord, and email alerts"
+          },
+          {
+            "name": "SQL access to raw data",
+            "openpanel": true,
+            "competitor": false,
+            "notes": "OpenPanel gives direct ClickHouse SQL access; GA4 requires BigQuery export ($50k+ tier)"
           }
         ]
       },
@@ -206,31 +245,37 @@
             "name": "Cookie-free tracking",
             "openpanel": true,
             "competitor": false,
-            "notes": "GA4 requires first-party cookies"
+            "notes": "GA4 requires first-party cookies for session and user tracking"
           },
           {
             "name": "No consent banner needed",
             "openpanel": true,
             "competitor": false,
-            "notes": "GA4 requires consent under GDPR/ePrivacy"
+            "notes": "GA4 requires consent under GDPR and ePrivacy Directive"
           },
           {
             "name": "EU data residency",
             "openpanel": true,
             "competitor": false,
-            "notes": "GA4 processes data on US servers"
+            "notes": "OpenPanel hosted in Sweden; GA4 processes data on US servers"
           },
           {
             "name": "IP anonymization",
             "openpanel": true,
             "competitor": true,
-            "notes": "GA4 does this by default"
+            "notes": "Both anonymize IPs; OpenPanel uses daily rotating salts for extra privacy"
           },
           {
             "name": "Self-hosting option",
             "openpanel": true,
             "competitor": false,
-            "notes": null
+            "notes": "Complete data sovereignty when self-hosted on your infrastructure"
+          },
+          {
+            "name": "Open source code",
+            "openpanel": true,
+            "competitor": false,
+            "notes": "OpenPanel is AGPL-3.0; you can audit every line of code"
           },
           {
             "name": "DPA available",
@@ -241,7 +286,7 @@
         ]
       },
       {
-        "group": "Integrations",
+        "group": "Integrations & ecosystem",
         "features": [
           {
             "name": "REST API",
@@ -253,214 +298,264 @@
             "name": "Data export",
             "openpanel": true,
             "competitor": true,
-            "notes": "GA4 360 needed for full BigQuery export"
+            "notes": "GA4 requires 360 ($50k+) for full BigQuery export; OpenPanel exports freely"
           },
           {
             "name": "Google Ads integration",
             "openpanel": false,
             "competitor": true,
-            "notes": "Native GA4 integration"
+            "notes": "GA4's strongest feature \u2014 native Google Ads conversion tracking"
           },
           {
             "name": "Google Search Console",
             "openpanel": false,
             "competitor": true,
-            "notes": "Native GA4 integration"
+            "notes": "Native GA4 integration for search data"
+          },
+          {
+            "name": "Webhooks",
+            "openpanel": true,
+            "competitor": false,
+            "notes": "Send real-time event data to any endpoint"
+          },
+          {
+            "name": "WordPress plugin",
+            "openpanel": true,
+            "competitor": true,
+            "notes": "OpenPanel has an official WordPress plugin for easy setup"
           }
         ]
       }
     ]
   },
   "technical_comparison": {
-    "title": "Technical comparison",
+    "title": "Technical comparison for developers",
-    "intro": "For developers evaluating analytics tools, here's how the SDKs and technical implementations compare.",
+    "intro": "For developers evaluating analytics tools, the technical implementation differences between OpenPanel and Google Analytics are significant.",
     "items": [
       {
-        "label": "SDK size (JS)",
+        "label": "SDK size (JavaScript)",
         "openpanel": "~2.3 KB gzipped",
-        "competitor": "~30+ KB gzipped",
+        "competitor": "~30+ KB gzipped (gtag.js + analytics.js)",
-        "notes": "OpenPanel's SDK is significantly lighter for better page performance"
+        "notes": "OpenPanel's SDK is 13x smaller \u2014 a direct improvement to Core Web Vitals and page load speed"
       },
       {
-        "label": "Supported platforms",
+        "label": "Supported SDKs",
         "openpanel": [
-          "JavaScript",
+          "JavaScript/Script tag",
           "React",
           "Next.js",
           "Vue",
-          "Node.js",
-          "Python",
-          "Swift",
-          "Kotlin",
-          "React Native",
           "Astro",
           "Remix",
-          "Express"
+          "Node.js",
+          "Express",
+          "Python",
+          "Swift (iOS)",
+          "Kotlin (Android)",
+          "React Native"
         ],
         "competitor": [
-          "JavaScript",
+          "JavaScript (gtag.js)",
-          "iOS (via Firebase)",
+          "iOS (via Firebase SDK)",
-          "Android (via Firebase)",
+          "Android (via Firebase SDK)",
           "Flutter",
           "Unity",
-          "AMP"
+          "AMP",
+          "Google Tag Manager"
         ],
-        "notes": "GA4 mobile tracking requires Firebase SDK"
+        "notes": "OpenPanel has native SDKs for modern frameworks; GA4 mobile tracking requires the heavy Firebase SDK"
       },
       {
         "label": "Open source",
-        "openpanel": "Yes (AGPL-3.0)",
+        "openpanel": "Yes \u2014 AGPL-3.0, full source code on GitHub",
-        "competitor": "No",
+        "competitor": "No \u2014 proprietary Google product",
-        "notes": null
+        "notes": "OpenPanel can be audited, forked, and self-hosted"
       },
       {
         "label": "Self-hosted deployment",
-        "openpanel": "Docker, simple setup script",
+        "openpanel": "Single Docker container with setup script",
         "competitor": "Not available",
-        "notes": null
+        "notes": "OpenPanel self-hosting takes ~15 minutes with our setup script"
       },
       {
-        "label": "Database",
+        "label": "Database & data access",
-        "openpanel": "ClickHouse + PostgreSQL",
+        "openpanel": "ClickHouse (analytics) + PostgreSQL (config) \u2014 direct SQL access",
-        "competitor": "Proprietary Google infrastructure",
+        "competitor": "Proprietary Google infrastructure \u2014 no direct access",
-        "notes": "OpenPanel gives you direct SQL access to your data"
+        "notes": "OpenPanel gives you direct SQL access to your raw event data"
       },
       {
         "label": "Data retention",
-        "openpanel": "Unlimited (self-hosted) or plan-based",
+        "openpanel": "Unlimited when self-hosted, plan-based on cloud",
-        "competitor": "2-14 months (free), up to 50 months (360)",
+        "competitor": "2\u201314 months (free tier), up to 50 months (GA4 360 at $50k+/year)",
-        "notes": "GA4 has strict retention limits on the free tier"
+        "notes": "GA4's strict retention limits are a common reason teams switch"
+      },
+      {
+        "label": "Data sampling",
+        "openpanel": "Never \u2014 100% accurate data",
+        "competitor": "Yes \u2014 GA4 free tier samples at high traffic volumes",
+        "notes": "Data sampling means your reports may not reflect actual numbers"
       }
     ]
   },
   "pricing": {
     "title": "Pricing comparison",
-    "intro": "Google Analytics is free for most users, but comes with privacy tradeoffs and data limits. OpenPanel offers more control.",
+    "intro": "Google Analytics is 'free' in exchange for your visitors' data. OpenPanel offers transparent pricing with a free self-hosted option.",
     "openpanel": {
-      "model": "Event-based, transparent",
+      "model": "Event-based, transparent pricing",
-      "description": "Simple pricing starting at $2.50/month for 5,000 events. 100,000 events costs $20/month. Self-host for free with unlimited events. No limits on users, dashboards, or data retention."
+      "description": "Cloud hosting starts at $2.50/month for 5,000 events. 100,000 events costs $20/month. Self-host for free with unlimited events, no restrictions. No limits on users, dashboards, projects, or data retention on any plan."
     },
     "competitor": {
       "model": "Freemium with enterprise tier",
-      "description": "GA4 is free with limits: data sampling at high volumes, 14-month max data retention, limited explorations. GA4 360 (enterprise) starts at $50,000/year for higher limits and support.",
+      "description": "GA4 free tier has significant limitations: data sampling at high volumes, 14-month maximum data retention, limited Explorations, and no BigQuery export. GA4 360 (enterprise) starts at $50,000/year for higher limits, unsampled data, and support. The 'free' tier is subsidized by Google's advertising business \u2014 your visitors' data is the product.",
-      "free_tier": "Yes (with significant limits)",
+      "free_tier": "Yes (with major limitations and privacy tradeoffs)",
       "pricing_url": "https://marketingplatform.google.com/about/analytics/"
     }
   },
   "migration": {
-    "title": "Migrating from Google Analytics to OpenPanel",
+    "title": "How to migrate from Google Analytics to OpenPanel",
-    "intro": "Switching from Google Analytics to OpenPanel is straightforward. You can run both in parallel during transition.",
+    "intro": "Switching from Google Analytics to OpenPanel takes about 45 minutes for most websites. OpenPanel uses a similar event-based model to GA4, making the migration straightforward.",
     "difficulty": "easy",
-    "estimated_time": "1-2 hours",
+    "estimated_time": "30-60 minutes",
     "steps": [
       {
-        "title": "Install the OpenPanel script",
+        "title": "Add the OpenPanel script alongside GA4",
-        "description": "Add the lightweight OpenPanel script to your website. It's a single line of code, similar to the GA4 gtag but much smaller."
+        "description": "Install the lightweight 2.3 KB OpenPanel script on your site. Run it in parallel with GA4 so you can compare data. It's a single script tag or npm package."
       },
       {
-        "title": "Set up event tracking",
+        "title": "Map your GA4 events to OpenPanel",
-        "description": "Map your GA4 custom events to OpenPanel. The track() API is similar and most events translate directly."
+        "description": "OpenPanel's track() API closely mirrors GA4's event structure. Most events translate directly: gtag('event', 'purchase', {...}) becomes op.track('purchase', {...})."
       },
       {
-        "title": "Configure dashboards",
+        "title": "Set up user identification",
-        "description": "Set up your reports and dashboards in OpenPanel. The interface is simpler than GA4's Explorations."
+        "description": "Replace GA4's set user_properties with OpenPanel's identify() method for richer user profiles with session history and properties."
       },
       {
-        "title": "Run in parallel",
+        "title": "Configure dashboards and funnels",
-        "description": "Keep both tools running for a week or two to compare data and ensure everything is tracking correctly."
+        "description": "Set up your reports in OpenPanel's visual dashboard builder. It's simpler than GA4's Explorations \u2014 most teams get set up in minutes."
       },
       {
-        "title": "Remove Google Analytics",
+        "title": "Verify data and remove GA4",
-        "description": "Once verified, remove the GA4 script. You can also remove your cookie consent banner if it was only needed for analytics."
+        "description": "After 1-2 weeks of parallel tracking, compare the data. Once verified, remove the GA4 script. You can also remove your cookie consent banner if it was only needed for analytics."
       }
     ],
     "sdk_compatibility": {
       "similar_api": true,
-      "notes": "OpenPanel uses a simple track() API. GA4 events like gtag('event', 'purchase', {...}) translate to op.track('purchase', {...})."
+      "notes": "OpenPanel's track() API closely mirrors GA4's gtag event model. Custom events, e-commerce events, and page views all translate with minimal changes."
     },
     "historical_data": {
       "can_import": false,
-      "notes": "Google Analytics does not provide easy data export. Historical data stays in GA4. Start fresh with OpenPanel for cleaner, privacy-compliant data."
+      "notes": "Google Analytics doesn't provide easy data export. Historical data stays accessible in GA4 for your configured retention period. Most teams start fresh with OpenPanel for cleaner, privacy-compliant data going forward."
     }
   },
   "use_cases": {
-    "title": "Where OpenPanel is a better fit than Google Analytics",
+    "title": "When to choose OpenPanel over Google Analytics",
-    "intro": "OpenPanel shines for teams that prioritize privacy, simplicity, and data ownership over the Google ecosystem.",
+    "intro": "OpenPanel is the better choice for teams that prioritize privacy, simplicity, and data ownership over the Google advertising ecosystem.",
     "items": [
       {
-        "title": "GDPR-compliant websites",
+        "title": "GDPR-compliant analytics without consent banners",
-        "description": "No cookies, no consent banners, EU-only data storage. Meet privacy regulations without compromising on analytics.",
+        "description": "Cookie-free tracking and EU-only data hosting mean full GDPR and ePrivacy compliance without annoying consent banners that hurt your conversion rates.",
         "icon": "shield"
       },
       {
-        "title": "Marketing without Google",
+        "title": "Open source transparency and control",
-        "description": "If you don't rely on Google Ads, you don't need Google Analytics. Get cleaner, faster analytics without sending data to Google.",
+        "description": "Every line of OpenPanel's code is on GitHub under AGPL-3.0. Audit the tracking code, verify privacy claims, and contribute improvements. No black-box data processing.",
-        "icon": "chart"
+        "icon": "code"
       },
       {
-        "title": "Self-hosted requirements",
+        "title": "Self-hosted for complete data sovereignty",
-        "description": "Deploy OpenPanel on your own infrastructure for complete data ownership. Perfect for regulated industries or security-conscious teams.",
+        "description": "Deploy OpenPanel on your own servers with a single Docker container. Your analytics data never leaves your infrastructure \u2014 critical for healthcare, finance, and government.",
         "icon": "server"
       },
       {
-        "title": "Web + product analytics combined",
+        "title": "Faster websites with a tiny SDK",
-        "description": "Get Plausible-style web analytics and product analytics (funnels, retention, cohorts) in one tool instead of multiple subscriptions.",
+        "description": "At 2.3 KB, OpenPanel's SDK is 13x smaller than Google's gtag.js. Less JavaScript means faster page loads, better Core Web Vitals, and improved SEO rankings.",
+        "icon": "zap"
+      },
+      {
+        "title": "Web analytics + product analytics in one tool",
+        "description": "Get Plausible-style web analytics and Mixpanel-style product analytics (funnels, retention, cohorts, user profiles) in a single tool instead of paying for two.",
         "icon": "layers"
       },
       {
-        "title": "Faster websites",
+        "title": "Teams frustrated with GA4's complexity",
-        "description": "OpenPanel's 2.3 KB SDK vs GA4's 30+ KB means better Core Web Vitals, faster page loads, and improved SEO.",
+        "description": "If your team struggles with GA4's confusing interface, complex event model, and limited Explorations \u2014 OpenPanel gives you the insights you need without the steep learning curve.",
-        "icon": "zap"
+        "icon": "chart"
       }
     ]
   },
   "faqs": {
     "title": "Frequently asked questions",
-    "intro": "Common questions about switching from Google Analytics to OpenPanel.",
+    "intro": "Common questions about switching from Google Analytics to an open-source alternative.",
     "items": [
       {
-        "question": "Is Google Analytics free?",
+        "question": "Is Google Analytics open source?",
-        "answer": "Yes, GA4 is free but comes with significant tradeoffs: your data goes to Google, cookies require consent banners, data retention is limited to 14 months, and high-traffic sites experience data sampling. GA4 360 (enterprise) costs $50,000+/year."
+        "answer": "No. Google Analytics is a proprietary, closed-source product owned by Google. You cannot inspect the tracking code, verify how your data is processed, or self-host it. OpenPanel is fully open source under the AGPL-3.0 license \u2014 the complete source code is available on GitHub for anyone to audit, modify, or self-host."
       },
       {
-        "question": "Why switch from Google Analytics?",
+        "question": "Is Google Analytics really free?",
-        "answer": "Common reasons include: privacy concerns (data sent to Google), GDPR compliance (cookies require consent), complexity (GA4 has a steep learning curve), and data ownership (you can't self-host or fully export your data)."
+        "answer": "GA4 is free to use, but the cost is your visitors' privacy \u2014 data is processed on Google's US servers and used within Google's advertising ecosystem. There are also significant feature limitations: 14-month data retention, data sampling at high volumes, and no BigQuery export. GA4 360 removes these limits but costs $50,000+/year. OpenPanel offers a free self-hosted option with no limitations, or cloud hosting starting at $2.50/month."
+      },
+      {
+        "question": "Why are people switching away from Google Analytics?",
+        "answer": "The main reasons teams switch from GA4 are: 1) Privacy concerns \u2014 data sent to Google's US servers creates GDPR compliance issues, 2) Cookie consent banners \u2014 GA4 requires them, which hurts UX and conversion rates, 3) GA4 complexity \u2014 the new interface and event model have a steep learning curve, 4) Data limitations \u2014 sampling, short retention, and limited exports on the free tier, 5) Performance \u2014 the 30+ KB gtag.js script impacts page load speed."
       },
       {
         "question": "Do I need a cookie consent banner with OpenPanel?",
-        "answer": "No. OpenPanel is cookie-free by default and doesn't collect personal data, so no consent banner is required for analytics. This improves user experience and conversion rates."
+        "answer": "No. OpenPanel uses cookie-free tracking by default. It doesn't store cookies or collect personal data, so no consent banner is required under GDPR, ePrivacy Directive, or PECR. This improves user experience and can boost conversion rates by 2-5% compared to sites with consent banners."
       },
       {
         "question": "Is OpenPanel GDPR compliant?",
-        "answer": "Yes. OpenPanel is EU-based (Sweden), uses cookie-free tracking, hashes IP addresses with daily rotating salts, and stores data on EU servers. We also offer DPA agreements on request."
+        "answer": "Yes. OpenPanel is based in Sweden (EU), uses cookie-free tracking, hashes IP addresses with daily rotating salts, stores data exclusively on EU servers, and offers self-hosting for complete data sovereignty. We also provide DPA agreements on request."
       },
       {
-        "question": "Can I import my Google Analytics data?",
+        "question": "Can I self-host OpenPanel?",
-        "answer": "Google Analytics doesn't provide easy data export for migration. We recommend running OpenPanel in parallel with GA4 briefly, then starting fresh with OpenPanel for cleaner, privacy-compliant data."
+        "answer": "Yes. OpenPanel can be self-hosted using a single Docker container with our setup script. The entire process takes about 15 minutes. When self-hosted, you get unlimited events, unlimited data retention, and complete control over your data \u2014 no usage fees. The source code is available under the AGPL-3.0 license."
       },
       {
-        "question": "How does OpenPanel track users without cookies?",
+        "question": "Can I import my Google Analytics data into OpenPanel?",
-        "answer": "OpenPanel uses a privacy-friendly approach: IP addresses and user agents are hashed together with a daily rotating salt. This allows accurate visitor counting (within a 24-hour window) without storing any personal data."
+        "answer": "Google Analytics doesn't provide an easy data export mechanism, so direct migration of historical data isn't possible. Most teams run OpenPanel alongside GA4 for 1-2 weeks to verify data, then switch completely. Your historical GA4 data remains accessible in Google Analytics for your configured retention period."
+      },
+      {
+        "question": "How does OpenPanel compare to other GA alternatives like Plausible or Matomo?",
+        "answer": "OpenPanel is unique because it combines web analytics (like Plausible) with product analytics (like Mixpanel) in one open-source tool. Plausible is simpler but lacks funnels, cohorts, and user profiles. Matomo is feature-rich but requires cookies and has a heavier setup. OpenPanel gives you the best of both worlds with a tiny 2.3 KB SDK."
       },
       {
         "question": "Does OpenPanel integrate with Google Ads?",
-        "answer": "No, OpenPanel doesn't have native Google Ads integration. If you rely heavily on Google Ads conversion tracking and attribution, GA4 remains the better choice for that specific use case."
+        "answer": "No. If you rely heavily on Google Ads conversion tracking and multi-touch attribution, GA4 remains the better choice for that specific use case. OpenPanel focuses on privacy-first analytics for teams that don't need deep Google Ads integration."
       },
       {
-        "question": "How does the SDK size affect my website?",
+        "question": "How does the SDK size affect my website's performance?",
-        "answer": "OpenPanel's JavaScript SDK is ~2.3 KB gzipped compared to GA4's 30+ KB. This means faster page loads, better Core Web Vitals scores, and potentially improved SEO rankings."
+        "answer": "OpenPanel's JavaScript SDK is 2.3 KB gzipped, compared to Google Analytics' 30+ KB. That's a 13x difference that directly impacts your Core Web Vitals scores, page load times, and potentially your SEO rankings. For mobile users on slower connections, the difference is even more noticeable."
       }
     ]
   },
   "related_links": {
+    "guides": [
+      {
+        "title": "Migrate from Google Analytics",
+        "url": "/guides/migrate-from-google-analytics"
+      },
+      {
+        "title": "Website analytics setup",
+        "url": "/guides/website-analytics-setup"
+      },
+      {
+        "title": "Track custom events",
+        "url": "/guides/track-custom-events"
+      }
+    ],
     "articles": [
       {
-        "title": "9 best open source web analytics tools",
+        "title": "9 best open source web analytics tools in 2026",
         "url": "/articles/open-source-web-analytics"
       },
       {
-        "title": "Cookieless analytics",
+        "title": "Cookieless analytics: best tools and how they work",
         "url": "/articles/cookieless-analytics"
+      },
+      {
+        "title": "Self-hosted web analytics tools compared",
+        "url": "/articles/self-hosted-web-analytics"
       }
     ],
     "alternatives": [
@@ -471,16 +566,24 @@
       {
         "name": "Matomo",
         "url": "/compare/matomo-alternative"
+      },
+      {
+        "name": "Umami",
+        "url": "/compare/umami-alternative"
+      },
+      {
+        "name": "PostHog",
+        "url": "/compare/posthog-alternative"
       }
     ]
   },
   "ctas": {
     "primary": {
-      "label": "Start with OpenPanel",
+      "label": "Try OpenPanel Free",
       "href": "https://dashboard.openpanel.dev/onboarding"
     },
     "secondary": {
-      "label": "View on GitHub",
+      "label": "View Source on GitHub",
       "href": "https://github.com/Openpanel-dev/openpanel"
     }
   }

apps/public/content/compare/heap-alternative.json

@@ -2,13 +2,13 @@
   "slug": "heap-alternative",
   "page_type": "alternative",
   "seo": {
-    "title": "Heap Alternative: Why Teams Choose OpenPanel",
+    "title": "Best Heap Alternative 2026 - Open Source & Free",
-    "description": "Compare OpenPanel vs Heap. Discover why teams choose OpenPanel as their Heap alternative for transparent pricing, self-hosting, open source freedom, and lightweight analytics without autocapture complexity.",
+    "description": "Looking for a Heap alternative? OpenPanel offers transparent pricing, lightweight analytics, and self-hosting without autocapture complexity. Open source and free to get started.",
     "noindex": false
   },
   "hero": {
-    "heading": "Heap alternative",
+    "heading": "Best Heap Alternative",
-    "subheading": "Looking for Heap's product analytics without the black-box pricing and vendor lock-in? OpenPanel offers transparent event-based pricing, full self-hosting, and MIT-licensed open source code—giving you control over your analytics.",
+    "subheading": "Looking for Heap's product analytics without the black-box pricing and vendor lock-in? OpenPanel offers transparent event-based pricing, full self-hosting, and MIT-licensed open source code\u2014giving you control over your analytics.",
     "badges": [
       "Open-source",
       "Transparent pricing",
@@ -24,6 +24,15 @@
     "founded": 2013,
     "headquarters": "San Francisco, CA"
   },
+  "overview": {
+    "title": "Why consider OpenPanel over Heap?",
+    "paragraphs": [
+      "Heap made its name with autocapture \u2014 the ability to automatically record every user interaction and analyze it retroactively. It's a compelling feature for teams that want to ask questions about user behavior without planning instrumentation in advance. But Heap's acquisition by Contentsquare, opaque enterprise pricing, and cloud-only architecture have many teams looking for alternatives.",
+      "OpenPanel takes a different approach with explicit event tracking, giving you precise control over what you measure and how. While you lose Heap's retroactive analysis capability, you gain transparency \u2014 both in your data collection and your costs. OpenPanel's pricing is publicly listed and event-based, starting at just $2.50 per month, compared to Heap's sales-required pricing that reportedly starts at $3,600 per year.",
+      "For teams that value data sovereignty, OpenPanel offers full self-hosting via a simple Docker deployment \u2014 something Heap doesn't provide at all. Being open source under the MIT license means you can inspect every line of code, contribute improvements, and avoid the vendor lock-in risk that comes with Heap's proprietary, now-Contentsquare-owned platform.",
+      "If you prefer intentional, controlled analytics over autocapture-everything, want transparent pricing without sales calls, and need the option to self-host \u2014 OpenPanel gives you solid product analytics with full ownership of your data."
+    ]
+  },
   "summary_comparison": {
     "title": "OpenPanel vs Heap: Which is right for you?",
     "intro": "Both platforms provide product analytics, but with different philosophies. Heap's autocapture records everything automatically; OpenPanel uses explicit tracking for better control.",
@@ -418,6 +427,20 @@
     ]
   },
   "related_links": {
+    "guides": [
+      {
+        "title": "Track custom events",
+        "url": "/guides/track-custom-events"
+      },
+      {
+        "title": "React analytics setup",
+        "url": "/guides/react-analytics"
+      },
+      {
+        "title": "Next.js analytics setup",
+        "url": "/guides/nextjs-analytics"
+      }
+    ],
     "articles": [
       {
         "title": "Find an alternative to Mixpanel",

apps/public/content/compare/matomo-alternative.json

@@ -2,12 +2,12 @@
   "slug": "matomo-alternative",
   "page_type": "alternative",
   "seo": {
-    "title": "Matomo alternative",
+    "title": "Best Matomo Alternative 2026 - Open Source & Free",
-    "description": "Compare OpenPanel with Matomo: simpler setup, truly cookie-free tracking, and modern UI. Get web and product analytics without the complexity of self-hosting or premium plugin costs.",
+    "description": "Looking for a Matomo alternative? OpenPanel offers simpler setup, truly cookie-free tracking, and a modern UI \u2014 no premium plugin costs. Open source and free to self-host.",
     "noindex": false
   },
   "hero": {
-    "heading": "Matomo alternative",
+    "heading": "Best Matomo Alternative",
     "subheading": "OpenPanel is a modern, open-source alternative to Matomo. Get powerful web and product analytics with a cleaner interface, truly cookie-free tracking by default, and no premium plugins required for essential features.",
     "badges": [
       "Open-source",
@@ -24,6 +24,15 @@
     "founded": 2007,
     "headquarters": "Wellington, New Zealand"
   },
+  "overview": {
+    "title": "Why consider OpenPanel over Matomo?",
+    "paragraphs": [
+      "Matomo is one of the most established open-source analytics platforms, used by over 1.4 million websites worldwide. It offers both self-hosted and cloud options with a strong focus on privacy and data ownership. However, Matomo's age shows in its interface, and many essential features like funnels, A/B testing, and heatmaps are locked behind premium plugins that cost $229 per year each.",
+      "OpenPanel is a modern, open-source alternative that includes all features at every tier \u2014 no premium plugins, no upsells. Funnels, cohorts, retention analysis, A/B testing, and user profiles are all available whether you're on the free tier or self-hosting. The interface is clean and modern, designed for today's product teams rather than as a legacy dashboard.",
+      "A critical difference is cookie-free tracking. While Matomo can be configured for cookieless mode, it uses cookies by default and still requires a consent banner in most GDPR scenarios. OpenPanel is truly cookie-free from the start, with no configuration needed. Self-hosting is also dramatically simpler \u2014 a single Docker container versus Matomo's PHP, MySQL, and web server stack.",
+      "For teams who value Matomo's open-source philosophy but want a modern experience with all features included, lighter tracking (2.3 KB vs 20 KB), and simpler deployment \u2014 OpenPanel delivers what Matomo promises, without the hidden costs."
+    ]
+  },
   "summary_comparison": {
     "title": "OpenPanel vs Matomo: Which is right for you?",
     "intro": "Both platforms are open-source and privacy-focused. The key differences are modern UI, true cookie-free tracking, SDK size, and feature bundling vs premium plugins.",
@@ -467,6 +476,20 @@
     }
   },
   "related_links": {
+    "guides": [
+      {
+        "title": "Migrate from Google Analytics",
+        "url": "/guides/migrate-from-google-analytics"
+      },
+      {
+        "title": "Website analytics setup",
+        "url": "/guides/website-analytics-setup"
+      },
+      {
+        "title": "Track custom events",
+        "url": "/guides/track-custom-events"
+      }
+    ],
     "articles": [
       {
         "title": "9 best open source web analytics tools",

apps/public/content/compare/microsoft-clarity-alternative.json

@@ -2,12 +2,12 @@
   "slug": "microsoft-clarity-alternative",
   "page_type": "alternative",
   "seo": {
-    "title": "Microsoft Clarity Alternative: Why Teams Choose OpenPanel",
+    "title": "Best Microsoft Clarity Alternative 2026 - Open Source & Free",
-    "description": "Compare OpenPanel vs Microsoft Clarity. Discover why teams choose OpenPanel as their Clarity alternative for product analytics, user identification, retention analysis, and self-hosting capabilities.",
+    "description": "Looking for a Microsoft Clarity alternative? OpenPanel offers full product analytics with user identification, retention analysis, and self-hosting. Open source and free to start.",
     "noindex": false
   },
   "hero": {
-    "heading": "Microsoft Clarity Alternative",
+    "heading": "Best Microsoft Clarity Alternative",
     "subheading": "Love Clarity's free heatmaps and session recordings? OpenPanel adds what Clarity lacks - product analytics, user identification, retention analysis, cohorts, and self-hosting - while staying privacy-friendly and open source.",
     "badges": [
       "Open-source",
@@ -24,6 +24,15 @@
     "founded": 2020,
     "headquarters": "Redmond, Washington, USA"
   },
+  "overview": {
+    "title": "Why consider OpenPanel over Microsoft Clarity?",
+    "paragraphs": [
+      "Microsoft Clarity is a completely free behavioral analytics tool that offers unlimited session recordings, heatmaps, and insights powered by AI. The price \u2014 free forever with no limits \u2014 is hard to argue with, and it's become a popular complement to Google Analytics. But Clarity is designed for observing behavior, not measuring outcomes. There's no event tracking, no funnels, no retention analysis, and no cohort breakdowns.",
+      "OpenPanel fills the gap that Clarity leaves. While Clarity shows you recordings of individual sessions and aggregate heatmaps, OpenPanel gives you the structured analytics to understand patterns: which features drive retention, where users drop off in conversion flows, and how different cohorts of users behave over time. These are the insights that drive product decisions.",
+      "Self-hosting and data ownership are important distinctions. Clarity runs entirely on Microsoft's Azure cloud with no alternative, and your session recording data lives on their servers. OpenPanel can be self-hosted on your own infrastructure for complete data sovereignty, and its open-source MIT license means you can audit every line of code processing your users' data.",
+      "Many teams find that Clarity and OpenPanel work well together \u2014 Clarity for visual session recordings and OpenPanel for structured product analytics. But if you're choosing one tool to understand and improve your product, OpenPanel provides the actionable metrics that behavioral observation alone can't deliver."
+    ]
+  },
   "summary_comparison": {
     "title": "OpenPanel vs Microsoft Clarity: Which is right for you?",
     "intro": "Clarity focuses on behavioral analytics (session recordings, heatmaps). OpenPanel focuses on product analytics (events, retention, cohorts). Different tools for different needs.",
@@ -483,6 +492,20 @@
     ]
   },
   "related_links": {
+    "guides": [
+      {
+        "title": "Website analytics setup",
+        "url": "/guides/website-analytics-setup"
+      },
+      {
+        "title": "Migrate from Google Analytics",
+        "url": "/guides/migrate-from-google-analytics"
+      },
+      {
+        "title": "Track custom events",
+        "url": "/guides/track-custom-events"
+      }
+    ],
     "articles": [
       {
         "title": "9 best open source web analytics tools",

apps/public/content/compare/mixpanel-alternative.json

@@ -2,13 +2,13 @@
   "slug": "mixpanel-alternative",
   "page_type": "alternative",
   "seo": {
-    "title": "The best Mixpanel alternative",
+    "title": "Best Mixpanel Alternative 2026 - Open Source & Free",
-    "description": "Compare OpenPanel with Mixpanel: pricing, privacy, self-hosting, and features. OpenPanel offers similar product analytics at a fraction of the cost with EU-only hosting.",
+    "description": "Looking for a Mixpanel alternative? OpenPanel offers powerful product analytics at a fraction of the cost \u2014 with EU-only hosting, self-hosting, and full data ownership. Try free today.",
     "noindex": false
   },
   "hero": {
-    "heading": "Mixpanel alternative",
+    "heading": "Best Mixpanel Alternative",
-    "subheading": "OpenPanel is an open-source, privacy-first alternative to Mixpanel. Get powerful product analytics—events, funnels, retention, and user profiles—without event-based pricing that scales to thousands per month or sending your data to US servers.",
+    "subheading": "OpenPanel is an open-source, privacy-first alternative to Mixpanel. Get powerful product analytics\u2014events, funnels, retention, and user profiles\u2014without event-based pricing that scales to thousands per month or sending your data to US servers.",
     "badges": [
       "Open-source",
       "EU-only hosting",
@@ -24,6 +24,15 @@
     "founded": 2009,
     "headquarters": "San Francisco, CA"
   },
+  "overview": {
+    "title": "Why consider OpenPanel over Mixpanel?",
+    "paragraphs": [
+      "Mixpanel is one of the most established product analytics platforms, used by product teams worldwide to track user behavior, build funnels, and analyze retention. It's powerful, but that power comes with increasingly complex pricing, a cloud-only architecture, and cookie-based tracking that creates friction for privacy-conscious teams.",
+      "OpenPanel provides the core product analytics features most teams actually use \u2014 events, funnels, retention, cohorts, and user profiles \u2014 in a simpler package with transparent, predictable pricing. Starting at just $2.50 per month, or completely free when self-hosted, OpenPanel is dramatically more affordable than Mixpanel's pricing which can scale to thousands per month as your event volume grows.",
+      "Privacy is where the two platforms diverge most sharply. Mixpanel uses cookies by default and stores data on US servers, which means GDPR consent banners and data transfer concerns for European users. OpenPanel is cookie-free by default with EU-only hosting, making compliance straightforward. You can also self-host OpenPanel on your own infrastructure for complete data sovereignty \u2014 something Mixpanel simply doesn't offer.",
+      "For teams that want Mixpanel-style product analytics without the enterprise pricing, vendor lock-in, or privacy trade-offs, OpenPanel is a compelling open-source alternative that gives you full ownership of your analytics data."
+    ]
+  },
   "summary_comparison": {
     "title": "OpenPanel vs Mixpanel: Which is right for you?",
     "intro": "Both platforms help you understand how users interact with your product. The key differences are pricing structure, data privacy approach, and complexity level.",
@@ -375,7 +384,7 @@
       },
       {
         "title": "Install the OpenPanel SDK",
-        "description": "Replace the Mixpanel SDK with OpenPanel's lightweight tracker. The API is similar—track(), identify(), and setGlobalProperties() work the same way."
+        "description": "Replace the Mixpanel SDK with OpenPanel's lightweight tracker. The API is similar\u2014track(), identify(), and setGlobalProperties() work the same way."
       },
       {
         "title": "Update your event calls",
@@ -461,6 +470,20 @@
     ]
   },
   "related_links": {
+    "guides": [
+      {
+        "title": "Migrate from Mixpanel",
+        "url": "/guides/migrate-from-mixpanel"
+      },
+      {
+        "title": "Track custom events",
+        "url": "/guides/track-custom-events"
+      },
+      {
+        "title": "Ecommerce event tracking",
+        "url": "/guides/ecommerce-tracking"
+      }
+    ],
     "articles": [
       {
         "title": "Find an alternative to Mixpanel",

apps/public/content/compare/mouseflow-alternative.json

@@ -2,13 +2,13 @@
   "slug": "mouseflow-alternative",
   "page_type": "alternative",
   "seo": {
-    "title": "Mouseflow Alternative",
+    "title": "Best Mouseflow Alternative 2026 - Open Source & Free",
-    "description": "Compare OpenPanel with Mouseflow: pricing, features, and deployment. OpenPanel offers product analytics with mobile SDKs; Mouseflow excels at visual website optimization.",
+    "description": "Looking for a Mouseflow alternative? OpenPanel offers product analytics with funnels, mobile SDKs, and self-hosting \u2014 beyond just visual behavior tracking. Open source and free to start.",
     "noindex": false
   },
   "hero": {
-    "heading": "Mouseflow alternative",
+    "heading": "Best Mouseflow Alternative",
-    "subheading": "Need product analytics beyond heatmaps? OpenPanel provides event-based analytics, mobile SDKs, and self-hosting—fully open source with transparent pricing.",
+    "subheading": "Need product analytics beyond heatmaps? OpenPanel provides event-based analytics, mobile SDKs, and self-hosting\u2014fully open source with transparent pricing.",
     "badges": [
       "Open-source",
       "Self-hostable",
@@ -24,6 +24,15 @@
     "founded": 2009,
     "headquarters": "Copenhagen, Denmark"
   },
+  "overview": {
+    "title": "Why consider OpenPanel over Mouseflow?",
+    "paragraphs": [
+      "Mouseflow is a behavior analytics platform that excels at visual website optimization with seven types of heatmaps, session replay, friction detection, and form analytics. It's a solid tool for understanding how visitors interact with specific pages on your website. But Mouseflow is web-only, proprietary, cloud-only, and focused on session-based observation rather than event-based product analytics.",
+      "OpenPanel takes a fundamentally different approach with event-based analytics designed for product teams. Instead of watching session recordings to spot issues, you define the events and funnels that matter to your business and measure them quantitatively. Retention analysis shows whether users come back, cohort breakdowns reveal behavioral patterns, and user profiles connect the dots across multiple sessions.",
+      "The platform support gap is significant. Mouseflow works only on websites, while OpenPanel provides native SDKs for iOS, Android, React Native, and Flutter alongside its web SDKs. For teams building multi-platform products, this means a single analytics tool for all surfaces instead of piecing together separate solutions.",
+      "OpenPanel also offers what Mouseflow can't: full data ownership through self-hosting and open-source transparency under the MIT license. If you need to move beyond visual website optimization and measure product outcomes across web and mobile, OpenPanel provides the analytics foundation to do it."
+    ]
+  },
   "summary_comparison": {
     "title": "OpenPanel vs Mouseflow: Which is right for you?",
     "intro": "Mouseflow excels at visual website optimization with heatmaps and session replay. OpenPanel focuses on product analytics with mobile support.",
@@ -414,6 +423,20 @@
     ]
   },
   "related_links": {
+    "guides": [
+      {
+        "title": "Website analytics setup",
+        "url": "/guides/website-analytics-setup"
+      },
+      {
+        "title": "Track custom events",
+        "url": "/guides/track-custom-events"
+      },
+      {
+        "title": "Ecommerce event tracking",
+        "url": "/guides/ecommerce-tracking"
+      }
+    ],
     "articles": [
       {
         "title": "9 best open source web analytics tools",

apps/public/content/compare/pirsch-analytics-alternative.json

@@ -2,12 +2,12 @@
   "slug": "pirsch-analytics-alternative",
   "page_type": "alternative",
   "seo": {
-    "title": "Pirsch Analytics Alternative: Why Teams Choose OpenPanel",
+    "title": "Best Pirsch Analytics Alternative 2026 - Open Source & Free",
-    "description": "Compare OpenPanel vs Pirsch Analytics. Discover why teams choose OpenPanel as their Pirsch alternative for product analytics, user identification, and free self-hosting without enterprise pricing.",
+    "description": "Looking for a Pirsch alternative? OpenPanel adds product analytics, user identification, and free self-hosting to privacy-first web analytics. No enterprise pricing required.",
     "noindex": false
   },
   "hero": {
-    "heading": "Pirsch Alternative",
+    "heading": "Best Pirsch Analytics Alternative",
     "subheading": "Love Pirsch's German privacy focus and developer-friendly approach? OpenPanel adds product analytics capabilities - funnels, cohorts, retention, and user identification - plus free self-hosting without enterprise pricing.",
     "badges": [
       "Open-source",
@@ -24,6 +24,15 @@
     "founded": 2020,
     "headquarters": "Rheda-Wiedenbruck, Germany"
   },
+  "overview": {
+    "title": "Why consider OpenPanel over Pirsch Analytics?",
+    "paragraphs": [
+      "Pirsch Analytics is a privacy-focused web analytics tool built in Germany with strong server-side tracking, excellent white-label capabilities, and developer-friendly features. It's particularly popular with agencies and developers who need affordable, GDPR-compliant analytics with good backend integration. But Pirsch is primarily a web analytics tool \u2014 it tracks pageviews and basic funnels without deeper product analytics capabilities.",
+      "OpenPanel extends beyond web analytics into full product analytics territory. While Pirsch gives you traffic sources, pageviews, and simple conversion goals, OpenPanel adds user identification, multi-step funnels, retention analysis, cohort breakdowns, and detailed user profiles. These features let you understand not just how much traffic you get, but how users engage with your product over time.",
+      "Self-hosting is where OpenPanel offers a major advantage. Pirsch requires an enterprise license for self-hosting, making it inaccessible for most teams. OpenPanel provides free, unlimited self-hosting with a simple Docker deployment \u2014 no enterprise contract needed. The free cloud tier also includes 10,000 events per month with full data retention, while Pirsch has no free tier at all.",
+      "If you've been using Pirsch for privacy-friendly web analytics and now need to understand user behavior at a deeper level \u2014 especially for SaaS products or mobile apps \u2014 OpenPanel provides that upgrade path while keeping the same privacy-first principles."
+    ]
+  },
   "summary_comparison": {
     "title": "OpenPanel vs Pirsch: Which is right for you?",
     "intro": "Both are privacy-focused analytics tools. Pirsch focuses on affordable web analytics with agency features. OpenPanel adds product analytics with user identification.",
@@ -460,6 +469,20 @@
     ]
   },
   "related_links": {
+    "guides": [
+      {
+        "title": "Website analytics setup",
+        "url": "/guides/website-analytics-setup"
+      },
+      {
+        "title": "Migrate from Google Analytics",
+        "url": "/guides/migrate-from-google-analytics"
+      },
+      {
+        "title": "Next.js analytics setup",
+        "url": "/guides/nextjs-analytics"
+      }
+    ],
     "articles": [
       {
         "title": "9 best open source web analytics tools",

apps/public/content/compare/plausible-alternative.json

@@ -2,12 +2,12 @@
   "slug": "plausible-alternative",
   "page_type": "alternative",
   "seo": {
-    "title": "Plausible Alternative: Why Teams Choose OpenPanel",
+    "title": "Best Plausible Alternative 2026 - Open Source & Free",
-    "description": "Compare OpenPanel vs Plausible Analytics. Discover why teams choose OpenPanel as their Plausible alternative for product analytics, user identification, and deeper insights while maintaining privacy.",
+    "description": "Looking for a Plausible alternative? OpenPanel adds product analytics, user identification, and deeper insights to privacy-first web analytics. Open source and free to self-host.",
     "noindex": false
   },
   "hero": {
-    "heading": "Plausible Alternative",
+    "heading": "Best Plausible Alternative",
     "subheading": "Love Plausible's simplicity and privacy focus? OpenPanel adds product analytics capabilities - funnels, cohorts, retention, and user identification - while staying lightweight and cookie-free by default.",
     "badges": [
       "Open-source",
@@ -24,6 +24,15 @@
     "founded": 2018,
     "headquarters": "Tartu, Estonia"
   },
+  "overview": {
+    "title": "Why consider OpenPanel over Plausible?",
+    "paragraphs": [
+      "Plausible Analytics has earned a strong reputation as a lightweight, privacy-first alternative to Google Analytics. Its simple dashboard and cookie-free tracking make it a great choice for bloggers and content sites that need basic traffic metrics without the complexity. But as your product grows, you'll quickly hit the limits of what Plausible can offer.",
+      "OpenPanel shares Plausible's commitment to privacy \u2014 cookie-free tracking, no consent banners, and EU-based data processing \u2014 but goes significantly further with full product analytics capabilities. Where Plausible gives you pageviews, referrers, and country breakdowns, OpenPanel adds funnels, retention analysis, cohort breakdowns, user profiles, and A/B testing. It's the best of both worlds: Plausible-style simplicity for web analytics combined with Mixpanel-style depth for product analytics.",
+      "Self-hosting is another area where OpenPanel has a clear advantage. Plausible Community Edition requires you to set up and manage PostgreSQL and ClickHouse separately. OpenPanel runs in a single Docker container, making deployment and maintenance far simpler. And unlike Plausible, OpenPanel offers a permanent free cloud tier with 10,000 events per month \u2014 no credit card required.",
+      "If you've outgrown simple web analytics and need to understand how users actually interact with your product \u2014 without adding a second analytics tool \u2014 OpenPanel is a natural next step from Plausible."
+    ]
+  },
   "summary_comparison": {
     "title": "OpenPanel vs Plausible: Which is right for you?",
     "intro": "Both are privacy-focused analytics platforms. Plausible focuses on simple web traffic metrics. OpenPanel adds product analytics with user identification.",
@@ -461,6 +470,20 @@
     ]
   },
   "related_links": {
+    "guides": [
+      {
+        "title": "Migrate from Google Analytics",
+        "url": "/guides/migrate-from-google-analytics"
+      },
+      {
+        "title": "Website analytics setup",
+        "url": "/guides/website-analytics-setup"
+      },
+      {
+        "title": "Track custom events",
+        "url": "/guides/track-custom-events"
+      }
+    ],
     "articles": [
       {
         "title": "9 best open source web analytics tools",

apps/public/content/compare/posthog-alternative.json

@@ -2,12 +2,12 @@
   "slug": "posthog-alternative",
   "page_type": "alternative",
   "seo": {
-    "title": "PostHog Alternative: Why Teams Switch to OpenPanel",
+    "title": "Best PostHog Alternative 2026 - Open Source & Free",
-    "description": "Compare OpenPanel vs PostHog. Discover why teams choose OpenPanel as their PostHog alternative for simpler analytics with better privacy, lighter SDK, and no complex pricing tiers.",
+    "description": "Looking for a PostHog alternative? OpenPanel offers simpler analytics with better privacy, a lighter SDK, and transparent pricing \u2014 no complex tiers. Open source and free to self-host.",
     "noindex": false
   },
   "hero": {
-    "heading": "PostHog Alternative",
+    "heading": "Best PostHog Alternative",
     "subheading": "Get powerful product analytics without the complexity. OpenPanel delivers essential insights with a lighter footprint, true cookie-free tracking, and transparent pricing - no enterprise sales calls required.",
     "badges": [
       "Open-source",
@@ -24,6 +24,15 @@
     "founded": 2020,
     "headquarters": "San Francisco, California, USA"
   },
+  "overview": {
+    "title": "Why consider OpenPanel over PostHog?",
+    "paragraphs": [
+      "PostHog has built an impressive all-in-one platform with product analytics, feature flags, session replay, surveys, A/B testing, and more \u2014 over 10 products under one roof. It's a popular choice among developer-led teams who want everything in a single tool. But that breadth comes with trade-offs: a 52+ KB SDK, complex multi-product pricing, and a self-hosted setup that requires ClickHouse, Kafka, Redis, and PostgreSQL.",
+      "OpenPanel takes a focused approach. Instead of trying to be everything, it delivers excellent analytics \u2014 events, funnels, retention, cohorts, user profiles, and web analytics \u2014 with a dramatically smaller footprint. The SDK is just 2.3 KB (over 20x lighter than PostHog), which directly translates to faster page loads and better Core Web Vitals for your users.",
+      "Cookie-free tracking is another key difference. PostHog uses cookies by default and requires configuration to go cookieless, while OpenPanel is cookie-free out of the box \u2014 no consent banners needed. Self-hosting is also far simpler: OpenPanel runs in a single Docker container compared to PostHog's multi-service architecture.",
+      "If you need focused analytics without the feature bloat, want a lighter SDK that doesn't impact performance, and prefer simple event-based pricing over multi-product metering \u2014 OpenPanel gives you exactly what you need without the overhead."
+    ]
+  },
   "summary_comparison": {
     "title": "OpenPanel vs PostHog: Which is right for you?",
     "intro": "Both are open-source analytics platforms. PostHog is an all-in-one platform with many products. OpenPanel focuses on analytics with simplicity.",
@@ -446,6 +455,20 @@
     ]
   },
   "related_links": {
+    "guides": [
+      {
+        "title": "Track custom events",
+        "url": "/guides/track-custom-events"
+      },
+      {
+        "title": "Next.js analytics setup",
+        "url": "/guides/nextjs-analytics"
+      },
+      {
+        "title": "React analytics setup",
+        "url": "/guides/react-analytics"
+      }
+    ],
     "articles": [
       {
         "title": "9 best open source web analytics tools",

apps/public/content/compare/simple-analytics-alternative.json

@@ -2,12 +2,12 @@
   "slug": "simple-analytics-alternative",
   "page_type": "alternative",
   "seo": {
-    "title": "Simple Analytics Alternative: Why Teams Choose OpenPanel",
+    "title": "Best Simple Analytics Alternative 2026 - Open Source & Free",
-    "description": "Compare OpenPanel vs Simple Analytics. Discover why teams choose OpenPanel as their Simple Analytics alternative for product analytics, user identification, and self-hosting while maintaining privacy-first principles.",
+    "description": "Looking for a Simple Analytics alternative? OpenPanel adds product analytics, user identification, and self-hosting with longer data retention. Open source, privacy-first, and free to start.",
     "noindex": false
   },
   "hero": {
-    "heading": "Simple Analytics Alternative",
+    "heading": "Best Simple Analytics Alternative",
     "subheading": "Love Simple Analytics' privacy focus and clean dashboard? OpenPanel adds product analytics capabilities - funnels, cohorts, retention, and user identification - plus self-hosting options and longer data retention on the free tier.",
     "badges": [
       "Open-source",
@@ -24,6 +24,15 @@
     "founded": 2018,
     "headquarters": "Amsterdam, Netherlands"
   },
+  "overview": {
+    "title": "Why consider OpenPanel over Simple Analytics?",
+    "paragraphs": [
+      "Simple Analytics lives up to its name \u2014 it's a clean, privacy-focused web analytics tool based in the Netherlands with a thoughtful AI assistant feature. For teams that need basic traffic metrics with strong privacy guarantees, it does the job well. But its web-only focus and limited free tier (only 30 days of data retention) leave gaps for teams building products rather than content sites.",
+      "OpenPanel provides the same privacy-first foundation \u2014 cookie-free tracking, no consent banners, EU data processing \u2014 while adding the product analytics depth that Simple Analytics lacks. Funnels, retention analysis, cohort breakdowns, and individual user profiles let you understand not just traffic volume, but how users actually engage with your product over time.",
+      "Data retention on OpenPanel's free tier is particularly noteworthy. Where Simple Analytics limits free users to just 30 days of historical data, OpenPanel provides full data retention at every tier. Self-hosting is another differentiator \u2014 Simple Analytics is cloud-only, while OpenPanel can be deployed on your own infrastructure via Docker for complete data ownership.",
+      "If you've been happy with Simple Analytics' privacy approach but need deeper insights into user behavior, mobile app support through native SDKs, or longer data retention without upgrading to a paid plan, OpenPanel is a natural step up."
+    ]
+  },
   "summary_comparison": {
     "title": "OpenPanel vs Simple Analytics: Which is right for you?",
     "intro": "Both are privacy-focused analytics platforms. Simple Analytics focuses on simple web traffic metrics. OpenPanel adds product analytics with user identification and self-hosting.",
@@ -464,6 +473,20 @@
     ]
   },
   "related_links": {
+    "guides": [
+      {
+        "title": "Website analytics setup",
+        "url": "/guides/website-analytics-setup"
+      },
+      {
+        "title": "Migrate from Google Analytics",
+        "url": "/guides/migrate-from-google-analytics"
+      },
+      {
+        "title": "Next.js analytics setup",
+        "url": "/guides/nextjs-analytics"
+      }
+    ],
     "articles": [
       {
         "title": "9 best open source web analytics tools",

apps/public/content/compare/smartlook-alternative.json

@@ -2,13 +2,13 @@
   "slug": "smartlook-alternative",
   "page_type": "alternative",
   "seo": {
-    "title": "Smartlook Alternative",
+    "title": "Best Smartlook Alternative 2026 - Open Source & Free",
-    "description": "Compare OpenPanel with Smartlook: pricing, features, and deployment. OpenPanel offers product analytics with self-hosting; Smartlook combines analytics with session replay.",
+    "description": "Looking for a Smartlook alternative? OpenPanel offers product analytics with self-hosting, transparent pricing, and mobile SDKs \u2014 without session replay costs. Open source and free to start.",
     "noindex": false
   },
   "hero": {
-    "heading": "Smartlook alternative",
+    "heading": "Best Smartlook Alternative",
-    "subheading": "Need product analytics without requiring session replay? OpenPanel is an open-source alternative to Smartlook that focuses on event-based analytics, funnels, and retention—with self-hosting and transparent pricing.",
+    "subheading": "Need product analytics without requiring session replay? OpenPanel is an open-source alternative to Smartlook that focuses on event-based analytics, funnels, and retention\u2014with self-hosting and transparent pricing.",
     "badges": [
       "Open-source",
       "Self-hostable",
@@ -24,6 +24,15 @@
     "founded": 2016,
     "headquarters": "Brno, Czech Republic"
   },
+  "overview": {
+    "title": "Why consider OpenPanel over Smartlook?",
+    "paragraphs": [
+      "Smartlook combines product analytics with visual insights \u2014 session recordings, heatmaps, and event tracking in one platform. Since its acquisition by Cisco in 2023, it has positioned itself as an enterprise-ready analytics and observation tool. But enterprise ownership often means enterprise pricing, proprietary lock-in, and cloud-only infrastructure with no option for self-hosting.",
+      "OpenPanel focuses purely on product analytics without the session replay overhead, delivering event tracking, funnels, retention analysis, and cohort breakdowns with a cleaner, more focused experience. The result is a lighter tool that does analytics well rather than trying to be everything \u2014 and at a dramatically lower cost with transparent, event-based pricing starting at $2.50 per month.",
+      "Being open source under the MIT license gives OpenPanel advantages that Smartlook's proprietary, Cisco-owned platform can't match. You can self-host on your own infrastructure for complete data sovereignty, audit the source code for security compliance, and avoid the vendor lock-in risk that comes with acquisition-prone platforms. Self-hosting also means unlimited data retention, compared to Smartlook's plan-based limits.",
+      "If you need session replay specifically, Smartlook has the edge in that area. But for teams that want focused, cost-effective product analytics with open-source transparency and the freedom to self-host, OpenPanel delivers more value without the enterprise complexity."
+    ]
+  },
   "summary_comparison": {
     "title": "OpenPanel vs Smartlook: Which is right for you?",
     "intro": "Both platforms offer product analytics, but Smartlook adds visual behavior tools (session replay, heatmaps) while OpenPanel focuses on event-based analytics with self-hosting.",
@@ -398,6 +407,20 @@
     ]
   },
   "related_links": {
+    "guides": [
+      {
+        "title": "Track custom events",
+        "url": "/guides/track-custom-events"
+      },
+      {
+        "title": "React Native analytics setup",
+        "url": "/guides/react-native-analytics"
+      },
+      {
+        "title": "Swift/iOS analytics setup",
+        "url": "/guides/swift-analytics"
+      }
+    ],
     "articles": [
       {
         "title": "9 best open source web analytics tools",

apps/public/content/compare/umami-alternative.json

@@ -2,12 +2,12 @@
   "slug": "umami-alternative",
   "page_type": "alternative",
   "seo": {
-    "title": "Umami Alternative: Why Teams Choose OpenPanel",
+    "title": "Best Umami Alternative 2026 - Open Source & Free",
-    "description": "Compare OpenPanel vs Umami Analytics. Discover why teams choose OpenPanel as their Umami alternative for deeper product analytics, user identification, and mobile SDKs while maintaining privacy.",
+    "description": "Looking for an Umami alternative? OpenPanel offers deeper product analytics, user identification, and mobile SDKs while staying open source and privacy-first. Free to self-host.",
     "noindex": false
   },
   "hero": {
-    "heading": "Umami Alternative",
+    "heading": "Best Umami Alternative",
     "subheading": "Love Umami's simplicity and privacy focus? OpenPanel adds deeper product analytics - user identification, mobile SDKs, A/B testing, and detailed user profiles - while staying open source and cookie-free.",
     "badges": [
       "Open-source",
@@ -24,6 +24,15 @@
     "founded": 2020,
     "headquarters": "San Francisco Bay Area, USA"
   },
+  "overview": {
+    "title": "Why consider OpenPanel over Umami?",
+    "paragraphs": [
+      "Umami Analytics is a popular open-source web analytics tool known for its clean interface, lightweight script, and privacy-friendly design. It's a great option for developers who want simple, anonymous website metrics. But as your product grows beyond a simple website, Umami's anonymous-only model and lack of product analytics features become limiting.",
+      "OpenPanel builds on the same open-source, privacy-first foundation but adds the product analytics layer that Umami doesn't have. User identification lets you track logged-in users across sessions, while funnels, retention analysis, and cohort breakdowns help you understand how people actually use your product \u2014 not just that they visited your site.",
+      "Mobile app analytics is another area where OpenPanel pulls ahead. Umami is web-only with no native mobile SDKs, while OpenPanel offers first-party SDKs for iOS, Android, and React Native. OpenPanel also includes built-in A/B testing for experimentation, which Umami doesn't offer at all.",
+      "Both tools are MIT-licensed and support self-hosting, so you won't sacrifice the open-source values that made Umami appealing. If you need to go beyond anonymous pageview counting and actually understand your users, OpenPanel is the natural upgrade from Umami."
+    ]
+  },
   "summary_comparison": {
     "title": "OpenPanel vs Umami: Which is right for you?",
     "intro": "Both are open-source, privacy-focused analytics tools. Umami focuses on anonymous web analytics. OpenPanel adds user identification and product analytics.",
@@ -494,6 +503,20 @@
     ]
   },
   "related_links": {
+    "guides": [
+      {
+        "title": "Website analytics setup",
+        "url": "/guides/website-analytics-setup"
+      },
+      {
+        "title": "Node.js analytics setup",
+        "url": "/guides/nodejs-analytics"
+      },
+      {
+        "title": "Migrate from Google Analytics",
+        "url": "/guides/migrate-from-google-analytics"
+      }
+    ],
     "articles": [
       {
         "title": "9 best open source web analytics tools",

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

@@ -102,7 +102,7 @@ Client events are sent from:
 Client events:
 - Create sessions
 - Generate device IDs
-- Support full session tracking
+- Support full [session tracking](/features/session-tracking)
 
 ### Server Events
 

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

@@ -5,7 +5,7 @@ description: Learn how to easily track your revenue with OpenPanel and how to ge
 
 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.
+[Revenue tracking](/features/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.
 
@@ -33,7 +33,7 @@ This is the most common flow and most secure one. Your backend receives webhooks
 <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.
+When you create the checkout, you should first call `op.getDeviceId()`, which will return your visitor's current `deviceId`. Pass this to your checkout endpoint.
 
 ```javascript
 fetch('https://domain.com/api/checkout', {
@@ -42,7 +42,7 @@ fetch('https://domain.com/api/checkout', {
     'Content-Type': 'application/json',
   },
   body: JSON.stringify({
-    deviceId: await op.fetchDeviceId(), // ✅ since deviceId is here we can link the payment now
+    deviceId: op.getDeviceId(), // ✅ since deviceId is here we can link the payment now
     // ... other checkout data
   }),
 })
@@ -360,5 +360,5 @@ op.clearRevenue(): void
 ### Fetch your current users device id
 
 ```javascript
-op.fetchDeviceId(): Promise<string>
+op.getDeviceId(): string
 ```

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

@@ -54,7 +54,8 @@ import { OpenPanelComponent } from '@openpanel/astro';
 ##### Astro options
 
 - `profileId` - If you have a user id, you can pass it here to identify the user
-- `cdnUrl` - The url to the OpenPanel SDK (default: `https://openpanel.dev/op1.js`)
+- `cdnUrl` (deprecated) - The url to the OpenPanel SDK (default: `https://openpanel.dev/op1.js`)
+- `scriptUrl` - The url to the OpenPanel SDK (default: `https://openpanel.dev/op1.js`)
 - `filter` - This is a function that will be called before tracking an event. If it returns false the event will not be tracked. [Read more](#filter)
 - `globalProperties` - This is an object of properties that will be sent with every event.
 

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

@@ -61,7 +61,7 @@ val op = OpenPanel.create(
 Additional Kotlin-specific options:
 
 - `filter` - A function that will be called before tracking an event. If it returns false, the event will not be tracked
-- `disabled` - Set to `true` to disable all event tracking
+- `disabled` - Set to `true` to disable all [event tracking](/features/event-tracking)
 - `automaticTracking` - Set to `true` to automatically track app lifecycle events
 - `verbose` - Set to `true` to enable verbose logging
 

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

@@ -62,7 +62,8 @@ export default function RootLayout({ children }) {
 ##### NextJS options
 
 - `profileId` - If you have a user id, you can pass it here to identify the user
-- `cdnUrl` - The url to the OpenPanel SDK (default: `https://openpanel.dev/op1.js`)
+- `cdnUrl` (deprecated) - The url to the OpenPanel SDK (default: `https://openpanel.dev/op1.js`)
+- `scriptUrl` - The url to the OpenPanel SDK (default: `https://openpanel.dev/op1.js`)
 - `filter` - This is a function that will be called before tracking an event. If it returns false the event will not be tracked. [Read more](#filter)
 - `globalProperties` - This is an object of properties that will be sent with every event.
 
@@ -286,12 +287,12 @@ import { createRouteHandler } from '@openpanel/nextjs/server';
 export const { GET, POST } = createRouteHandler();
 ```
 
-Remember to change the `apiUrl` and `cdnUrl` in the `OpenPanelComponent` to your own server. 
+Remember to change the `apiUrl` and `scriptUrl` in the `OpenPanelComponent` to your own server. 
 
 ```tsx
 <OpenPanelComponent
   apiUrl="/api/op" // [!code highlight]
-  cdnUrl="/api/op/op1.js" // [!code highlight]
+  scriptUrl="/api/op/op1.js" // [!code highlight]
   clientId="your-client-id"
   trackScreenViews={true}
 />

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

@@ -41,7 +41,7 @@ op = OpenPanel(
 Additional Python-specific options:
 
 - `filter` - A function that will be called before tracking an event. If it returns false the event will not be tracked
-- `disabled` - Set to `True` to disable all event tracking
+- `disabled` - Set to `True` to disable all [event tracking](/features/event-tracking)
 - `global_properties` - Dictionary of properties that will be sent with every event
 
 #### Filter Function Example

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

@@ -55,7 +55,7 @@ tracker = OpenPanel::SDK::Tracker.new
 
 Additional Ruby-specific options:
 
-- `disabled` - Set to `true` to disable all event tracking
+- `disabled` - Set to `true` to disable all [event tracking](/features/event-tracking)
 - `env` - Environment name (e.g., `Rails.env.to_s`)
 
 ```ruby

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

@@ -69,7 +69,7 @@ OpenPanel.initialize(options: .init(
 Additional Swift-specific options:
 
 - `filter` - A closure that will be called before tracking an event. If it returns false, the event will not be tracked
-- `disabled` - Set to `true` to disable all event tracking
+- `disabled` - Set to `true` to disable all [event tracking](/features/event-tracking)
 - `automaticTracking` - Set to `true` to automatically track app lifecycle events
 
 #### Filter Example

apps/public/content/docs/api/authentication.mdx

@@ -7,11 +7,12 @@ description: Learn how to authenticate with the OpenPanel API using client crede
 
 To authenticate with the OpenPanel API, you need to use your `clientId` and `clientSecret`. Different API endpoints may require different access levels:
 
-- **Track API**: Default client works with `track` mode
+- **Track API**: Default client works with `write` mode
 - **Export API**: Requires `read` or `root` mode
 - **Insights API**: Requires `read` or `root` mode
+- **Manage API**: Requires `root` mode only
 
-The default client does not have access to the Export or Insights APIs.
+The default client (created with a project) has `write` mode and does not have access to the Export, Insights, or Manage APIs. You'll need to create additional clients with appropriate access levels.
 
 ## Headers
 
@@ -48,15 +49,29 @@ If authentication fails, you'll receive a `401 Unauthorized` response:
 
 Common authentication errors:
 - Invalid client ID or secret
-- Client doesn't have required permissions
+- Client doesn't have required permissions (e.g., trying to access Manage API with a non-root client)
-- Malformed client ID
+- Malformed client ID (must be a valid UUIDv4)
+- Client type mismatch (e.g., `write` client trying to access Export API)
+
+## Client Types
+
+OpenPanel supports three client types with different access levels:
+
+| Type | Description | Access |
+|------|-------------|--------|
+| `write` | Write access | Track API only |
+| `read` | Read-only access | Export API, Insights API |
+| `root` | Full access | All APIs including Manage API |
+
+**Note**: Root clients have organization-wide access and can manage all resources. Use root clients carefully and store their credentials securely.
 
 ## Rate Limiting
 
 The API implements rate limiting to prevent abuse. Rate limits vary by endpoint:
 
-- **Track API**: Higher limits for event tracking
+- **Track API**: Higher limits for [event tracking](/features/event-tracking)
-- **Export/Insights APIs**: Lower limits for data retrieval
+- **Export/Insights APIs**: 100 requests per 10 seconds
+- **Manage API**: 20 requests per 10 seconds
 
 If you exceed the rate limit, you'll receive a `429 Too Many Requests` response. Implement exponential backoff for retries.
 

apps/public/content/docs/api/manage/clients.mdx

@@ -0,0 +1,332 @@
+---
+title: Clients
+description: Manage API clients for your OpenPanel projects. Create, read, update, and delete clients with different access levels.
+---
+
+## Authentication
+
+To authenticate with the Clients API, you need to use your `clientId` and `clientSecret` from a root client. Root clients have organization-wide access.
+
+For detailed authentication information, see the [Authentication](/docs/api/authentication) guide.
+
+Include the following headers with your requests:
+- `openpanel-client-id`: Your OpenPanel root client ID
+- `openpanel-client-secret`: Your OpenPanel root client secret
+
+## Base URL
+
+All Clients API requests should be made to:
+
+```
+https://api.openpanel.dev/manage/clients
+```
+
+## Client Types
+
+OpenPanel supports three client types with different access levels:
+
+| Type | Description | Use Case |
+|------|-------------|----------|
+| `read` | Read-only access | Export data, view insights, read-only operations |
+| `write` | Write access | Track events, send data to OpenPanel |
+| `root` | Full access | Manage resources, access Manage API |
+
+**Note**: Only `root` clients can access the Manage API.
+
+## Endpoints
+
+### List Clients
+
+Retrieve all clients in your organization, optionally filtered by project.
+
+```
+GET /manage/clients
+```
+
+#### Query Parameters
+
+| Parameter | Type | Description |
+|-----------|------|-------------|
+| `projectId` | string | Optional. Filter clients by project ID |
+
+#### Example Request
+
+```bash
+# List all clients
+curl 'https://api.openpanel.dev/manage/clients' \
+  -H 'openpanel-client-id: YOUR_ROOT_CLIENT_ID' \
+  -H 'openpanel-client-secret: YOUR_ROOT_CLIENT_SECRET'
+
+# List clients for a specific project
+curl 'https://api.openpanel.dev/manage/clients?projectId=my-project' \
+  -H 'openpanel-client-id: YOUR_ROOT_CLIENT_ID' \
+  -H 'openpanel-client-secret: YOUR_ROOT_CLIENT_SECRET'
+```
+
+#### Response
+
+```json
+{
+  "data": [
+    {
+      "id": "fa0c2780-55f2-4d9e-bea0-da2e02c7b1a9",
+      "name": "First client",
+      "type": "write",
+      "projectId": "my-project",
+      "organizationId": "org_123",
+      "ignoreCorsAndSecret": false,
+      "createdAt": "2024-01-15T10:30:00.000Z",
+      "updatedAt": "2024-01-15T10:30:00.000Z"
+    },
+    {
+      "id": "b8904453-863d-4e04-8ebc-8abae30ffb1a",
+      "name": "Read-only Client",
+      "type": "read",
+      "projectId": "my-project",
+      "organizationId": "org_123",
+      "ignoreCorsAndSecret": false,
+      "createdAt": "2024-01-15T11:00:00.000Z",
+      "updatedAt": "2024-01-15T11:00:00.000Z"
+    }
+  ]
+}
+```
+
+**Note**: Client secrets are never returned in list or get responses for security reasons.
+
+### Get Client
+
+Retrieve a specific client by ID.
+
+```
+GET /manage/clients/{id}
+```
+
+#### Path Parameters
+
+| Parameter | Type | Description |
+|-----------|------|-------------|
+| `id` | string | The ID of the client (UUID) |
+
+#### Example Request
+
+```bash
+curl 'https://api.openpanel.dev/manage/clients/fa0c2780-55f2-4d9e-bea0-da2e02c7b1a9' \
+  -H 'openpanel-client-id: YOUR_ROOT_CLIENT_ID' \
+  -H 'openpanel-client-secret: YOUR_ROOT_CLIENT_SECRET'
+```
+
+#### Response
+
+```json
+{
+  "data": {
+    "id": "fa0c2780-55f2-4d9e-bea0-da2e02c7b1a9",
+    "name": "First client",
+    "type": "write",
+    "projectId": "my-project",
+    "organizationId": "org_123",
+    "ignoreCorsAndSecret": false,
+    "createdAt": "2024-01-15T10:30:00.000Z",
+    "updatedAt": "2024-01-15T10:30:00.000Z"
+  }
+}
+```
+
+### Create Client
+
+Create a new API client. A secure secret is automatically generated and returned once.
+
+```
+POST /manage/clients
+```
+
+#### Request Body
+
+| Parameter | Type | Required | Description |
+|-----------|------|----------|-------------|
+| `name` | string | Yes | Client name (minimum 1 character) |
+| `projectId` | string | No | Associate client with a specific project |
+| `type` | string | No | Client type: `read`, `write`, or `root` (default: `write`) |
+
+#### Example Request
+
+```bash
+curl -X POST 'https://api.openpanel.dev/manage/clients' \
+  -H 'openpanel-client-id: YOUR_ROOT_CLIENT_ID' \
+  -H 'openpanel-client-secret: YOUR_ROOT_CLIENT_SECRET' \
+  -H 'Content-Type: application/json' \
+  -d '{
+    "name": "My API Client",
+    "projectId": "my-project",
+    "type": "read"
+  }'
+```
+
+#### Response
+
+```json
+{
+  "data": {
+    "id": "b8904453-863d-4e04-8ebc-8abae30ffb1a",
+    "name": "My API Client",
+    "type": "read",
+    "projectId": "my-project",
+    "organizationId": "org_123",
+    "ignoreCorsAndSecret": false,
+    "createdAt": "2024-01-15T11:00:00.000Z",
+    "updatedAt": "2024-01-15T11:00:00.000Z",
+    "secret": "sec_b2521ca283bf903b46b3"
+  }
+}
+```
+
+**Important**: The `secret` field is only returned once when the client is created. Store it securely immediately. You cannot retrieve the secret later - if lost, you'll need to delete and recreate the client.
+
+### Update Client
+
+Update an existing client's name.
+
+```
+PATCH /manage/clients/{id}
+```
+
+#### Path Parameters
+
+| Parameter | Type | Description |
+|-----------|------|-------------|
+| `id` | string | The ID of the client (UUID) |
+
+#### Request Body
+
+| Parameter | Type | Required | Description |
+|-----------|------|----------|-------------|
+| `name` | string | No | New client name (minimum 1 character) |
+
+**Note**: Currently, only the `name` field can be updated. To change the client type or project association, delete and recreate the client.
+
+#### Example Request
+
+```bash
+curl -X PATCH 'https://api.openpanel.dev/manage/clients/b8904453-863d-4e04-8ebc-8abae30ffb1a' \
+  -H 'openpanel-client-id: YOUR_ROOT_CLIENT_ID' \
+  -H 'openpanel-client-secret: YOUR_ROOT_CLIENT_SECRET' \
+  -H 'Content-Type: application/json' \
+  -d '{
+    "name": "Updated Client Name"
+  }'
+```
+
+#### Response
+
+```json
+{
+  "data": {
+    "id": "b8904453-863d-4e04-8ebc-8abae30ffb1a",
+    "name": "Updated Client Name",
+    "type": "read",
+    "projectId": "my-project",
+    "organizationId": "org_123",
+    "ignoreCorsAndSecret": false,
+    "createdAt": "2024-01-15T11:00:00.000Z",
+    "updatedAt": "2024-01-15T11:30:00.000Z"
+  }
+}
+```
+
+### Delete Client
+
+Permanently delete a client. This action cannot be undone.
+
+```
+DELETE /manage/clients/{id}
+```
+
+#### Path Parameters
+
+| Parameter | Type | Description |
+|-----------|------|-------------|
+| `id` | string | The ID of the client (UUID) |
+
+#### Example Request
+
+```bash
+curl -X DELETE 'https://api.openpanel.dev/manage/clients/b8904453-863d-4e04-8ebc-8abae30ffb1a' \
+  -H 'openpanel-client-id: YOUR_ROOT_CLIENT_ID' \
+  -H 'openpanel-client-secret: YOUR_ROOT_CLIENT_SECRET'
+```
+
+#### Response
+
+```json
+{
+  "success": true
+}
+```
+
+**Warning**: Deleting a client is permanent. Any applications using this client will immediately lose access. Make sure to update your applications before deleting a client.
+
+## Error Handling
+
+The API uses standard HTTP response codes. Common error responses:
+
+### 400 Bad Request
+
+```json
+{
+  "error": "Bad Request",
+  "message": "Invalid request body",
+  "details": [
+    {
+      "path": ["name"],
+      "message": "String must contain at least 1 character(s)"
+    }
+  ]
+}
+```
+
+### 401 Unauthorized
+
+```json
+{
+  "error": "Unauthorized",
+  "message": "Manage: Only root clients are allowed to manage resources"
+}
+```
+
+### 404 Not Found
+
+```json
+{
+  "error": "Not Found",
+  "message": "Client not found"
+}
+```
+
+### 429 Too Many Requests
+
+Rate limiting response includes headers indicating your rate limit status.
+
+## Rate Limiting
+
+The Clients API implements rate limiting:
+- **20 requests per 10 seconds** per client
+- Rate limit headers included in responses
+- Implement exponential backoff for retries
+
+## Security Best Practices
+
+1. **Store Secrets Securely**: Client secrets are only shown once on creation. Store them in secure credential management systems
+2. **Use Appropriate Client Types**: Use the minimum required access level for each use case
+3. **Rotate Secrets Regularly**: Delete old clients and create new ones to rotate secrets
+4. **Never Expose Secrets**: Never commit client secrets to version control or expose them in client-side code
+5. **Monitor Client Usage**: Regularly review and remove unused clients
+
+## Notes
+
+- Client IDs are UUIDs (Universally Unique Identifiers)
+- Client secrets are automatically generated with the format `sec_` followed by random hex characters
+- Secrets are hashed using argon2 before storage
+- Clients can be associated with a project or exist at the organization level
+- Clients are scoped to your organization - you can only manage clients in your organization
+- The `ignoreCorsAndSecret` field is an advanced setting that bypasses CORS and secret validation (use with caution)

apps/public/content/docs/api/manage/index.mdx

@@ -0,0 +1,140 @@
+---
+title: Manage API Overview
+description: Programmatically manage projects, clients, and references in your OpenPanel organization using the Manage API.
+---
+
+## Overview
+
+The Manage API provides programmatic access to manage your OpenPanel resources including projects, clients, and references. This API is designed for automation, infrastructure-as-code, and administrative tasks.
+
+## Authentication
+
+The Manage API requires a **root client** for authentication. Root clients have organization-wide access and can manage all resources within their organization.
+
+To authenticate with the Manage API, you need:
+- A client with `type: 'root'`
+- Your `clientId` and `clientSecret`
+
+For detailed authentication information, see the [Authentication](/docs/api/authentication) guide.
+
+Include the following headers with your requests:
+- `openpanel-client-id`: Your OpenPanel root client ID
+- `openpanel-client-secret`: Your OpenPanel root client secret
+
+## Base URL
+
+All Manage API requests should be made to:
+
+```
+https://api.openpanel.dev/manage
+```
+
+## Available Resources
+
+The Manage API provides CRUD operations for three resource types:
+
+### Projects
+
+Manage your analytics projects programmatically:
+- **[Projects Documentation](/docs/api/manage/projects)** - Create, read, update, and delete projects
+- Automatically creates a default write client when creating a project
+- Supports project configuration including domains, CORS settings, and project types
+
+### Clients
+
+Manage API clients for your projects:
+- **[Clients Documentation](/docs/api/manage/clients)** - Create, read, update, and delete clients
+- Supports different client types: `read`, `write`, and `root`
+- Auto-generates secure secrets on creation (returned once)
+
+### References
+
+Manage reference points for your analytics:
+- **[References Documentation](/docs/api/manage/references)** - Create, read, update, and delete references
+- Useful for marking important dates or events in your analytics timeline
+- Can be filtered by project
+
+## Common Features
+
+All endpoints share these common characteristics:
+
+### Organization Scope
+
+All operations are scoped to your organization. You can only manage resources that belong to your organization.
+
+### Response Format
+
+Successful responses follow this structure:
+
+```json
+{
+  "data": {
+    // Resource data
+  }
+}
+```
+
+For list endpoints:
+
+```json
+{
+  "data": [
+    // Array of resources
+  ]
+}
+```
+
+### Error Handling
+
+The API uses standard HTTP response codes:
+
+- `200 OK` - Request successful
+- `400 Bad Request` - Invalid request parameters
+- `401 Unauthorized` - Authentication failed
+- `404 Not Found` - Resource not found
+- `429 Too Many Requests` - Rate limit exceeded
+
+## Rate Limiting
+
+The Manage API implements rate limiting:
+- **20 requests per 10 seconds** per client
+- Rate limit headers included in responses
+- Implement exponential backoff for retries
+
+## Use Cases
+
+The Manage API is ideal for:
+
+- **Infrastructure as Code**: Manage OpenPanel resources alongside your application infrastructure
+- **Automation**: Automatically create projects and clients for new deployments
+- **Bulk Operations**: Programmatically manage multiple resources
+- **CI/CD Integration**: Set up projects and clients as part of your deployment pipeline
+- **Administrative Tools**: Build custom admin interfaces
+
+## Security Best Practices
+
+1. **Root Clients Only**: Only root clients can access the Manage API
+2. **Store Credentials Securely**: Never expose root client credentials in client-side code
+3. **Use HTTPS**: Always use HTTPS for API requests
+4. **Rotate Credentials**: Regularly rotate your root client credentials
+5. **Limit Access**: Restrict root client creation to trusted administrators
+
+## Getting Started
+
+1. **Create a Root Client**: Use the dashboard to create a root client in your organization
+2. **Store Credentials**: Securely store your root client ID and secret
+3. **Make Your First Request**: Start with listing projects to verify authentication
+
+Example:
+
+```bash
+curl 'https://api.openpanel.dev/manage/projects' \
+  -H 'openpanel-client-id: YOUR_ROOT_CLIENT_ID' \
+  -H 'openpanel-client-secret: YOUR_ROOT_CLIENT_SECRET'
+```
+
+## Next Steps
+
+- Read the [Projects documentation](/docs/api/manage/projects) to manage projects
+- Read the [Clients documentation](/docs/api/manage/clients) to manage API clients
+- Read the [References documentation](/docs/api/manage/references) to manage reference points

apps/public/content/docs/api/manage/meta.json

@@ -0,0 +1,5 @@
+{
+  "title": "Manage",
+  "pages": ["projects", "clients", "references"],
+  "defaultOpen": false
+}

apps/public/content/docs/api/manage/projects.mdx

@@ -0,0 +1,327 @@
+---
+title: Projects
+description: Manage your OpenPanel projects programmatically. Create, read, update, and delete projects using the Manage API.
+---
+
+## Authentication
+
+To authenticate with the Projects API, you need to use your `clientId` and `clientSecret` from a root client. Root clients have organization-wide access.
+
+For detailed authentication information, see the [Authentication](/docs/api/authentication) guide.
+
+Include the following headers with your requests:
+- `openpanel-client-id`: Your OpenPanel root client ID
+- `openpanel-client-secret`: Your OpenPanel root client secret
+
+## Base URL
+
+All Projects API requests should be made to:
+
+```
+https://api.openpanel.dev/manage/projects
+```
+
+## Endpoints
+
+### List Projects
+
+Retrieve all projects in your organization.
+
+```
+GET /manage/projects
+```
+
+#### Example Request
+
+```bash
+curl 'https://api.openpanel.dev/manage/projects' \
+  -H 'openpanel-client-id: YOUR_ROOT_CLIENT_ID' \
+  -H 'openpanel-client-secret: YOUR_ROOT_CLIENT_SECRET'
+```
+
+#### Response
+
+```json
+{
+  "data": [
+    {
+      "id": "my-project",
+      "name": "My Project",
+      "organizationId": "org_123",
+      "domain": "https://example.com",
+      "cors": ["https://example.com", "https://www.example.com"],
+      "crossDomain": false,
+      "allowUnsafeRevenueTracking": false,
+      "filters": [],
+      "types": ["website"],
+      "eventsCount": 0,
+      "createdAt": "2024-01-15T10:30:00.000Z",
+      "updatedAt": "2024-01-15T10:30:00.000Z",
+      "deleteAt": null
+    }
+  ]
+}
+```
+
+### Get Project
+
+Retrieve a specific project by ID.
+
+```
+GET /manage/projects/{id}
+```
+
+#### Path Parameters
+
+| Parameter | Type | Description |
+|-----------|------|-------------|
+| `id` | string | The ID of the project |
+
+#### Example Request
+
+```bash
+curl 'https://api.openpanel.dev/manage/projects/my-project' \
+  -H 'openpanel-client-id: YOUR_ROOT_CLIENT_ID' \
+  -H 'openpanel-client-secret: YOUR_ROOT_CLIENT_SECRET'
+```
+
+#### Response
+
+```json
+{
+  "data": {
+    "id": "my-project",
+    "name": "My Project",
+    "organizationId": "org_123",
+    "domain": "https://example.com",
+    "cors": ["https://example.com"],
+    "crossDomain": false,
+    "allowUnsafeRevenueTracking": false,
+    "filters": [],
+    "types": ["website"],
+    "eventsCount": 0,
+    "createdAt": "2024-01-15T10:30:00.000Z",
+    "updatedAt": "2024-01-15T10:30:00.000Z",
+    "deleteAt": null
+  }
+}
+```
+
+### Create Project
+
+Create a new project in your organization. A default write client is automatically created with the project.
+
+```
+POST /manage/projects
+```
+
+#### Request Body
+
+| Parameter | Type | Required | Description |
+|-----------|------|----------|-------------|
+| `name` | string | Yes | Project name (minimum 1 character) |
+| `domain` | string \| null | No | Primary domain for the project (URL format or empty string) |
+| `cors` | string[] | No | Array of allowed CORS origins (default: `[]`) |
+| `crossDomain` | boolean | No | Enable cross-domain tracking (default: `false`) |
+| `types` | string[] | No | Project types: `website`, `app`, `backend` (default: `[]`) |
+
+#### Project Types
+
+- `website`: Web-based project
+- `app`: Mobile application
+- `backend`: Backend/server-side project
+
+#### Example Request
+
+```bash
+curl -X POST 'https://api.openpanel.dev/manage/projects' \
+  -H 'openpanel-client-id: YOUR_ROOT_CLIENT_ID' \
+  -H 'openpanel-client-secret: YOUR_ROOT_CLIENT_SECRET' \
+  -H 'Content-Type: application/json' \
+  -d '{
+    "name": "My New Project",
+    "domain": "https://example.com",
+    "cors": ["https://example.com", "https://www.example.com"],
+    "crossDomain": false,
+    "types": ["website"]
+  }'
+```
+
+#### Response
+
+```json
+{
+  "data": {
+    "id": "my-new-project",
+    "name": "My New Project",
+    "organizationId": "org_123",
+    "domain": "https://example.com",
+    "cors": ["https://example.com", "https://www.example.com"],
+    "crossDomain": false,
+    "allowUnsafeRevenueTracking": false,
+    "filters": [],
+    "types": ["website"],
+    "eventsCount": 0,
+    "createdAt": "2024-01-15T10:30:00.000Z",
+    "updatedAt": "2024-01-15T10:30:00.000Z",
+    "deleteAt": null,
+    "client": {
+      "id": "fa0c2780-55f2-4d9e-bea0-da2e02c7b1a9",
+      "secret": "sec_6c8ae85a092d6c66b242"
+    }
+  }
+}
+```
+
+**Important**: The `client.secret` is only returned once when the project is created. Store it securely immediately.
+
+### Update Project
+
+Update an existing project's configuration.
+
+```
+PATCH /manage/projects/{id}
+```
+
+#### Path Parameters
+
+| Parameter | Type | Description |
+|-----------|------|-------------|
+| `id` | string | The ID of the project |
+
+#### Request Body
+
+All fields are optional. Only include fields you want to update.
+
+| Parameter | Type | Description |
+|-----------|------|-------------|
+| `name` | string | Project name (minimum 1 character) |
+| `domain` | string \| null | Primary domain (URL format, empty string, or null) |
+| `cors` | string[] | Array of allowed CORS origins |
+| `crossDomain` | boolean | Enable cross-domain tracking |
+| `allowUnsafeRevenueTracking` | boolean | Allow revenue tracking without client secret |
+
+#### Example Request
+
+```bash
+curl -X PATCH 'https://api.openpanel.dev/manage/projects/my-project' \
+  -H 'openpanel-client-id: YOUR_ROOT_CLIENT_ID' \
+  -H 'openpanel-client-secret: YOUR_ROOT_CLIENT_SECRET' \
+  -H 'Content-Type: application/json' \
+  -d '{
+    "name": "Updated Project Name",
+    "crossDomain": true,
+    "allowUnsafeRevenueTracking": false
+  }'
+```
+
+#### Response
+
+```json
+{
+  "data": {
+    "id": "my-project",
+    "name": "Updated Project Name",
+    "organizationId": "org_123",
+    "domain": "https://example.com",
+    "cors": ["https://example.com"],
+    "crossDomain": true,
+    "allowUnsafeRevenueTracking": false,
+    "filters": [],
+    "types": ["website"],
+    "eventsCount": 0,
+    "createdAt": "2024-01-15T10:30:00.000Z",
+    "updatedAt": "2024-01-15T11:00:00.000Z",
+    "deleteAt": null
+  }
+}
+```
+
+### Delete Project
+
+Soft delete a project. The project will be scheduled for deletion after 24 hours.
+
+```
+DELETE /manage/projects/{id}
+```
+
+#### Path Parameters
+
+| Parameter | Type | Description |
+|-----------|------|-------------|
+| `id` | string | The ID of the project |
+
+#### Example Request
+
+```bash
+curl -X DELETE 'https://api.openpanel.dev/manage/projects/my-project' \
+  -H 'openpanel-client-id: YOUR_ROOT_CLIENT_ID' \
+  -H 'openpanel-client-secret: YOUR_ROOT_CLIENT_SECRET'
+```
+
+#### Response
+
+```json
+{
+  "success": true
+}
+```
+
+**Note**: Projects are soft-deleted. The `deleteAt` field is set to 24 hours in the future. You can cancel deletion by updating the project before the deletion time.
+
+## Error Handling
+
+The API uses standard HTTP response codes. Common error responses:
+
+### 400 Bad Request
+
+```json
+{
+  "error": "Bad Request",
+  "message": "Invalid request body",
+  "details": [
+    {
+      "path": ["name"],
+      "message": "String must contain at least 1 character(s)"
+    }
+  ]
+}
+```
+
+### 401 Unauthorized
+
+```json
+{
+  "error": "Unauthorized",
+  "message": "Manage: Only root clients are allowed to manage resources"
+}
+```
+
+### 404 Not Found
+
+```json
+{
+  "error": "Not Found",
+  "message": "Project not found"
+}
+```
+
+### 429 Too Many Requests
+
+Rate limiting response includes headers indicating your rate limit status.
+
+## Rate Limiting
+
+The Projects API implements rate limiting:
+- **20 requests per 10 seconds** per client
+- Rate limit headers included in responses
+- Implement exponential backoff for retries
+
+## Notes
+
+- Project IDs are automatically generated from the project name using a slug format
+- If a project ID already exists, a numeric suffix is added
+- CORS domains are automatically normalized (trailing slashes removed)
+- The default client created with a project has `type: 'write'`
+- Projects are scoped to your organization - you can only manage projects in your organization
+- Soft-deleted projects are excluded from list endpoints

apps/public/content/docs/api/manage/references.mdx

@@ -0,0 +1,344 @@
+---
+title: References
+description: Manage reference points for your OpenPanel projects. References are useful for marking important dates or events in your analytics timeline.
+---
+
+## Authentication
+
+To authenticate with the References API, you need to use your `clientId` and `clientSecret` from a root client. Root clients have organization-wide access.
+
+For detailed authentication information, see the [Authentication](/docs/api/authentication) guide.
+
+Include the following headers with your requests:
+- `openpanel-client-id`: Your OpenPanel root client ID
+- `openpanel-client-secret`: Your OpenPanel root client secret
+
+## Base URL
+
+All References API requests should be made to:
+
+```
+https://api.openpanel.dev/manage/references
+```
+
+## What are References?
+
+References are markers you can add to your analytics timeline to track important events such as:
+- Product launches
+- Marketing campaign start dates
+- Feature releases
+- Website redesigns
+- Major announcements
+
+References appear in your analytics charts and help you correlate changes in metrics with specific events.
+
+## Endpoints
+
+### List References
+
+Retrieve all references in your organization, optionally filtered by project.
+
+```
+GET /manage/references
+```
+
+#### Query Parameters
+
+| Parameter | Type | Description |
+|-----------|------|-------------|
+| `projectId` | string | Optional. Filter references by project ID |
+
+#### Example Request
+
+```bash
+# List all references
+curl 'https://api.openpanel.dev/manage/references' \
+  -H 'openpanel-client-id: YOUR_ROOT_CLIENT_ID' \
+  -H 'openpanel-client-secret: YOUR_ROOT_CLIENT_SECRET'
+
+# List references for a specific project
+curl 'https://api.openpanel.dev/manage/references?projectId=my-project' \
+  -H 'openpanel-client-id: YOUR_ROOT_CLIENT_ID' \
+  -H 'openpanel-client-secret: YOUR_ROOT_CLIENT_SECRET'
+```
+
+#### Response
+
+```json
+{
+  "data": [
+    {
+      "id": "1af09627-2dd7-4b37-9e5c-6ffa7e450e85",
+      "title": "Product Launch",
+      "description": "Version 2.0 released",
+      "date": "2024-01-15T10:00:00.000Z",
+      "projectId": "my-project",
+      "createdAt": "2024-01-10T08:00:00.000Z",
+      "updatedAt": "2024-01-10T08:00:00.000Z"
+    },
+    {
+      "id": "2bf19738-3ee8-4c48-af6d-7ggb8f561f96",
+      "title": "Marketing Campaign Start",
+      "description": "Q1 2024 campaign launched",
+      "date": "2024-01-20T09:00:00.000Z",
+      "projectId": "my-project",
+      "createdAt": "2024-01-18T10:00:00.000Z",
+      "updatedAt": "2024-01-18T10:00:00.000Z"
+    }
+  ]
+}
+```
+
+### Get Reference
+
+Retrieve a specific reference by ID.
+
+```
+GET /manage/references/{id}
+```
+
+#### Path Parameters
+
+| Parameter | Type | Description |
+|-----------|------|-------------|
+| `id` | string | The ID of the reference (UUID) |
+
+#### Example Request
+
+```bash
+curl 'https://api.openpanel.dev/manage/references/1af09627-2dd7-4b37-9e5c-6ffa7e450e85' \
+  -H 'openpanel-client-id: YOUR_ROOT_CLIENT_ID' \
+  -H 'openpanel-client-secret: YOUR_ROOT_CLIENT_SECRET'
+```
+
+#### Response
+
+```json
+{
+  "data": {
+    "id": "1af09627-2dd7-4b37-9e5c-6ffa7e450e85",
+    "title": "Product Launch",
+    "description": "Version 2.0 released",
+    "date": "2024-01-15T10:00:00.000Z",
+    "projectId": "my-project",
+    "createdAt": "2024-01-10T08:00:00.000Z",
+    "updatedAt": "2024-01-10T08:00:00.000Z"
+  }
+}
+```
+
+### Create Reference
+
+Create a new reference point for a project.
+
+```
+POST /manage/references
+```
+
+#### Request Body
+
+| Parameter | Type | Required | Description |
+|-----------|------|----------|-------------|
+| `projectId` | string | Yes | The ID of the project this reference belongs to |
+| `title` | string | Yes | Reference title (minimum 1 character) |
+| `description` | string | No | Optional description or notes |
+| `datetime` | string | Yes | Date and time for the reference (ISO 8601 format) |
+
+#### Example Request
+
+```bash
+curl -X POST 'https://api.openpanel.dev/manage/references' \
+  -H 'openpanel-client-id: YOUR_ROOT_CLIENT_ID' \
+  -H 'openpanel-client-secret: YOUR_ROOT_CLIENT_SECRET' \
+  -H 'Content-Type: application/json' \
+  -d '{
+    "projectId": "my-project",
+    "title": "Product Launch",
+    "description": "Version 2.0 released with new features",
+    "datetime": "2024-01-15T10:00:00.000Z"
+  }'
+```
+
+#### Response
+
+```json
+{
+  "data": {
+    "id": "1af09627-2dd7-4b37-9e5c-6ffa7e450e85",
+    "title": "Product Launch",
+    "description": "Version 2.0 released with new features",
+    "date": "2024-01-15T10:00:00.000Z",
+    "projectId": "my-project",
+    "createdAt": "2024-01-10T08:00:00.000Z",
+    "updatedAt": "2024-01-10T08:00:00.000Z"
+  }
+}
+```
+
+**Note**: The `date` field in the response is parsed from the `datetime` string you provided.
+
+### Update Reference
+
+Update an existing reference.
+
+```
+PATCH /manage/references/{id}
+```
+
+#### Path Parameters
+
+| Parameter | Type | Description |
+|-----------|------|-------------|
+| `id` | string | The ID of the reference (UUID) |
+
+#### Request Body
+
+All fields are optional. Only include fields you want to update.
+
+| Parameter | Type | Description |
+|-----------|------|-------------|
+| `title` | string | Reference title (minimum 1 character) |
+| `description` | string \| null | Description or notes (set to `null` to clear) |
+| `datetime` | string | Date and time for the reference (ISO 8601 format) |
+
+#### Example Request
+
+```bash
+curl -X PATCH 'https://api.openpanel.dev/manage/references/1af09627-2dd7-4b37-9e5c-6ffa7e450e85' \
+  -H 'openpanel-client-id: YOUR_ROOT_CLIENT_ID' \
+  -H 'openpanel-client-secret: YOUR_ROOT_CLIENT_SECRET' \
+  -H 'Content-Type: application/json' \
+  -d '{
+    "title": "Product Launch v2.1",
+    "description": "Updated: Version 2.1 released with bug fixes",
+    "datetime": "2024-01-15T10:00:00.000Z"
+  }'
+```
+
+#### Response
+
+```json
+{
+  "data": {
+    "id": "1af09627-2dd7-4b37-9e5c-6ffa7e450e85",
+    "title": "Product Launch v2.1",
+    "description": "Updated: Version 2.1 released with bug fixes",
+    "date": "2024-01-15T10:00:00.000Z",
+    "projectId": "my-project",
+    "createdAt": "2024-01-10T08:00:00.000Z",
+    "updatedAt": "2024-01-10T09:30:00.000Z"
+  }
+}
+```
+
+### Delete Reference
+
+Permanently delete a reference. This action cannot be undone.
+
+```
+DELETE /manage/references/{id}
+```
+
+#### Path Parameters
+
+| Parameter | Type | Description |
+|-----------|------|-------------|
+| `id` | string | The ID of the reference (UUID) |
+
+#### Example Request
+
+```bash
+curl -X DELETE 'https://api.openpanel.dev/manage/references/1af09627-2dd7-4b37-9e5c-6ffa7e450e85' \
+  -H 'openpanel-client-id: YOUR_ROOT_CLIENT_ID' \
+  -H 'openpanel-client-secret: YOUR_ROOT_CLIENT_SECRET'
+```
+
+#### Response
+
+```json
+{
+  "success": true
+}
+```
+
+## Error Handling
+
+The API uses standard HTTP response codes. Common error responses:
+
+### 400 Bad Request
+
+```json
+{
+  "error": "Bad Request",
+  "message": "Invalid request body",
+  "details": [
+    {
+      "path": ["title"],
+      "message": "String must contain at least 1 character(s)"
+    }
+  ]
+}
+```
+
+### 401 Unauthorized
+
+```json
+{
+  "error": "Unauthorized",
+  "message": "Manage: Only root clients are allowed to manage resources"
+}
+```
+
+### 404 Not Found
+
+```json
+{
+  "error": "Not Found",
+  "message": "Reference not found"
+}
+```
+
+This error can occur if:
+- The reference ID doesn't exist
+- The reference belongs to a different organization
+
+### 429 Too Many Requests
+
+Rate limiting response includes headers indicating your rate limit status.
+
+## Rate Limiting
+
+The References API implements rate limiting:
+- **20 requests per 10 seconds** per client
+- Rate limit headers included in responses
+- Implement exponential backoff for retries
+
+## Date Format
+
+References use ISO 8601 date format. Examples:
+
+- `2024-01-15T10:00:00.000Z` - UTC timezone
+- `2024-01-15T10:00:00-05:00` - Eastern Time (UTC-5)
+- `2024-01-15` - Date only (time defaults to 00:00:00)
+
+The `datetime` field in requests is converted to a `date` field in responses, stored as a timestamp.
+
+## Use Cases
+
+References are useful for:
+
+- **Product Launches**: Mark when new versions or features are released
+- **Marketing Campaigns**: Track campaign start and end dates
+- **Website Changes**: Note when major redesigns or updates occur
+- **Business Events**: Record important business milestones
+- **A/B Testing**: Mark when experiments start or end
+- **Seasonal Events**: Track holidays, sales periods, or seasonal changes
+
+## Notes
+
+- Reference IDs are UUIDs (Universally Unique Identifiers)
+- References are scoped to projects - each reference belongs to a specific project
+- References are scoped to your organization - you can only manage references for projects in your organization
+- The `description` field is optional and can be set to `null` to clear it
+- References appear in analytics charts to help correlate metrics with events
+- When filtering by `projectId`, the project must exist and belong to your organization

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

@@ -1,4 +1,4 @@
 {
   "title": "API",
-  "pages": ["track", "export", "insights"]
+  "pages": ["track", "export", "insights", "manage"]
 }

apps/public/content/docs/index.mdx

@@ -7,7 +7,7 @@ import { UserIcon,HardDriveIcon } from 'lucide-react'
 
 ## ✨ Key Features
 
-- **🔍 Advanced Analytics**: Funnels, cohorts, user profiles, and session history
+- **🔍 Advanced Analytics**: [Funnels](/features/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
@@ -15,7 +15,7 @@ import { UserIcon,HardDriveIcon } from 'lucide-react'
 - **🚀 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
+- **🛠️ Custom Dashboards**: Flexible chart creation and [data visualization](/features/data-visualization)
 - **📱 Multi-Platform**: Web, mobile (iOS/Android), and server-side tracking
 
 ## 📊 Analytics Platform Comparison

apps/public/content/docs/migration/migrate-v1-to-v2.mdx

@@ -6,7 +6,7 @@ description: Finally we feel ready to release v2 for all self-hostings. This is
 ## What's New in v2
 
 - **Redesigned dashboard** - New UI built with Tanstack
-- **Revenue tracking** - Track revenue alongside your analytics
+- **[Revenue tracking](/features/revenue-tracking)** - Track revenue alongside your analytics
 - **Sessions** - View individual user sessions
 - **Real-time view** - Live event stream
 - **Customizable dashboards** - Grafana-style widget layouts

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

@@ -175,6 +175,48 @@ COOKIE_SECRET=your-random-secret-here
 Never use the default value in production! Always generate a unique secret.
 </Callout>
 
+### COOKIE_TLDS
+
+**Type**: `string` (comma-separated)  
+**Required**: No  
+**Default**: None
+
+Custom multi-part TLDs for cookie domain handling. Use this when deploying on domains with public suffixes that aren't recognized by default (e.g., `.my.id`, `.web.id`, `.co.id`).
+
+**Example**:
+```bash
+# For domains like abc.my.id
+COOKIE_TLDS=my.id
+
+# Multiple TLDs
+COOKIE_TLDS=my.id,web.id,co.id
+```
+
+<Callout>
+This is required when using domain suffixes that are public suffixes (like `.co.uk`). Without this, the browser will reject authentication cookies. Common examples include Indonesian domains (`.my.id`, `.web.id`, `.co.id`).
+</Callout>
+
+### CUSTOM_COOKIE_DOMAIN
+
+**Type**: `string`  
+**Required**: No  
+**Default**: None
+
+Override the automatic cookie domain detection and set a specific domain for authentication cookies. Useful when proxying the API through your main domain or when you need precise control over cookie scope.
+
+**Example**:
+```bash
+# Set cookies only on the main domain
+CUSTOM_COOKIE_DOMAIN=.example.com
+
+# Set cookies on a specific subdomain
+CUSTOM_COOKIE_DOMAIN=.app.example.com
+```
+
+<Callout>
+When set, this completely bypasses the automatic domain parsing logic. The cookie will always be set as secure. Include a leading dot (`.`) to allow the cookie to be shared across subdomains.
+</Callout>
+
 ### DEMO_USER_ID
 
 **Type**: `string`  
@@ -702,6 +744,27 @@ Port for the API service to listen on.
 API_PORT=3000
 ```
 
+### API_HOST
+
+**Type**: `string`  
+**Required**: No  
+**Default**: `0.0.0.0` (production) / `localhost` (development)
+
+Host address for the API service to bind to. Set to `::` to enable IPv6 support (useful for platforms like Railway that use IPv6 for internal networking).
+
+**Example**:
+```bash
+# Default IPv4 only
+API_HOST=0.0.0.0
+
+# IPv6 (dual-stack, accepts both IPv4 and IPv6)
+API_HOST=::
+```
+
+<Callout>
+Use `API_HOST=::` when deploying on platforms like Railway where private networking requires IPv6. The `::` address enables dual-stack mode, accepting both IPv4 and IPv6 connections on most systems.
+</Callout>
+
 ## Logging
 
 ### LOG_LEVEL

apps/public/content/features/conversion.json

@@ -0,0 +1,167 @@
+{
+  "slug": "conversion",
+  "short_name": "Conversion",
+  "seo": {
+    "title": "Conversion Tracking - Trends Over Time",
+    "description": "Track conversion rates over time, spot trends, and break down by segments. Like funnels but built for monitoring how conversion evolves-perfect for A/B testing and growth.",
+    "keywords": [
+      "conversion tracking",
+      "conversion rate trends",
+      "a/b testing analytics",
+      "conversion breakdown",
+      "conversion over time"
+    ]
+  },
+  "hero": {
+    "heading": "Is conversion going up or down?",
+    "subheading": "See how your conversion rates change over days, weeks, and months. Break down by any property to compare variants or campaigns - and catch regressions before they cost you.",
+    "badges": [
+      "Conversion over time",
+      "Breakdown by any property",
+      "A/B test comparison",
+      "AI-powered insights"
+    ]
+  },
+  "definition": {
+    "title": "What is conversion tracking?",
+    "text": "Conversion tracking measures the rate at which users complete a desired action-like going from `session_start` to `save_recipe`, or from `signup` to `purchase`. You define a **flow** (a start event and an end event), and OpenPanel calculates the conversion rate for every time period you choose.\n\nIf you're familiar with [funnels](/features/funnels), conversions will feel similar. Both measure whether users complete a sequence. The difference is **perspective**:\n\n- **Funnels** are great for understanding *where* users drop off in a multi-step flow. They answer: \"which step loses the most users?\"\n- **Conversions** are great for understanding *trends*. They answer: \"is our conversion getting better or worse over time?\"\n\nWith conversion tracking, you get:\n\n- **Conversion rate over time** - see how your rate trends week over week or day by day. Spot improvements from product changes or regressions from bugs\n- **Average, best, and worst rates** - instantly see your overall average and the specific time periods where conversion peaked or dipped\n- **Breakdowns** - split conversion by any property (device, country, variant, campaign) to compare segments side by side. This is especially powerful for **A/B testing**: break down by experiment variant and see which one converts better, with per-period granularity\n- **Total conversions** - not just rates but absolute numbers, so you understand volume alongside percentage\n\nConversion reports in OpenPanel are built on the same events you already track. Define a flow once, and you get a live, updating chart that shows whether your product is converting more or fewer users over time.\n\nNo sampling, no delayed processing. Every event counts, and results update in real time."
+  },
+  "capabilities_section": {
+    "title": "What you can do with conversions",
+    "intro": "Monitor, compare, and optimize your most important flows."
+  },
+  "capabilities": [
+    {
+      "title": "Conversion trends over time",
+      "description": "See your conversion rate plotted over days, weeks, or months. Identify trends, seasonal patterns, and the impact of product changes at a glance."
+    },
+    {
+      "title": "Breakdowns for A/B testing",
+      "description": "Split conversion by any property-experiment variant, device, country, or traffic source. Compare lines on the same chart to see which segment converts best."
+    },
+    {
+      "title": "Smart insights",
+      "description": "OpenPanel highlights your best and worst performing periods and breakdowns automatically. See which variant had the highest average rate and when the lowest dip occurred."
+    },
+    {
+      "title": "Flexible flow definition",
+      "description": "Define a conversion as any two events: a start (e.g. session_start) and a goal (e.g. purchase). Change events or time windows without re-instrumenting."
+    },
+    {
+      "title": "Per-period detail table",
+      "description": "Below the chart, a table shows conversion rate for every period (week, day, month) for each segment. Sort and search to find exactly the data point you need."
+    },
+    {
+      "title": "Save and share reports",
+      "description": "Save conversion reports with their configuration and add them to dashboards. Share with your team so everyone monitors the same metrics."
+    }
+  ],
+  "screenshots": [
+    {
+      "src": "/features/feature-conversion.webp",
+      "alt": "Conversion report showing rate over time with average, best, and worst metrics",
+      "caption": "Track conversion trends over time. See average rate, total conversions, and identify your best and worst performing periods."
+    },
+    {
+      "src": "/features/feature-conversion-breakdown.webp",
+      "alt": "Conversion report with breakdown by platform showing Android vs iOS",
+      "caption": "Break down conversion by any property. Compare segments side by side-perfect for A/B tests, platform comparisons, and campaign analysis."
+    }
+  ],
+  "how_it_works": {
+    "title": "How conversion tracking works",
+    "intro": "Set up a conversion report in seconds using events you already track.",
+    "steps": [
+      {
+        "title": "Pick your events",
+        "description": "Choose a start event (e.g. session_start) and a goal event (e.g. save_recipe, purchase). These are events you already send-no extra instrumentation."
+      },
+      {
+        "title": "Choose your time range and granularity",
+        "description": "Select a date range and whether to view conversion by day, week, or month. OpenPanel calculates the rate for each period."
+      },
+      {
+        "title": "Add breakdowns (optional)",
+        "description": "Break down by device, country, experiment variant, or any event property. Each breakdown value gets its own line on the chart and row in the table."
+      },
+      {
+        "title": "Monitor trends and act",
+        "description": "Watch your conversion rate over time. Spot regressions early, validate that product changes improve conversion, and compare A/B test variants with real data."
+      }
+    ]
+  },
+  "use_cases": {
+    "title": "Who uses conversion tracking",
+    "intro": "Teams that need to monitor and improve conversion over time.",
+    "items": [
+      {
+        "title": "Growth and product teams",
+        "description": "Monitor signup-to-activation or trial-to-paid conversion week over week. Validate that product changes actually move the needle-not just in aggregate, but period by period."
+      },
+      {
+        "title": "A/B testing and experimentation",
+        "description": "Break down conversion by experiment variant to see which version wins. Unlike simple A/B tools, you get per-period granularity so you can spot if a variant's advantage changes over time."
+      },
+      {
+        "title": "Marketing and campaigns",
+        "description": "Compare conversion rates across traffic sources, campaigns, or landing pages. Find out which channels convert best and whether performance is improving or declining."
+      },
+      {
+        "title": "Mobile and cross-platform teams",
+        "description": "Break down by platform (iOS vs Android), app version, or device type. Catch platform-specific regressions and prioritize fixes where conversion is lowest."
+      }
+    ]
+  },
+  "related_features": [
+    {
+      "slug": "funnels",
+      "title": "Funnels",
+      "description": "See where users drop off step by step. Funnels show you which step loses users-conversions show you how rates trend over time."
+    },
+    {
+      "slug": "event-tracking",
+      "title": "Event tracking",
+      "description": "Conversions are built on the events you track. Send events once and use them for conversions, funnels, retention, and more."
+    },
+    {
+      "slug": "retention",
+      "title": "Retention",
+      "description": "Conversion measures if users complete an action. Retention measures if they keep coming back."
+    },
+    {
+      "slug": "data-visualization",
+      "title": "Data visualization",
+      "description": "Conversion charts are one of many ways to visualize your data in OpenPanel."
+    }
+  ],
+  "faqs": {
+    "title": "Frequently asked questions",
+    "intro": "Common questions about conversion tracking in OpenPanel.",
+    "items": [
+      {
+        "question": "How is this different from funnels?",
+        "answer": "Funnels show you a multi-step sequence and where users drop off at each step. Conversions focus on a single flow (start → goal) and show you how the conversion rate changes over time. Use funnels to diagnose where users get stuck; use conversions to monitor whether things are getting better or worse."
+      },
+      {
+        "question": "Can I use conversions for A/B testing?",
+        "answer": "Yes. Add a breakdown by your experiment variant property, and you'll see each variant's conversion rate plotted over time with per-period detail. This gives you richer insight than a single aggregate number-you can see if one variant's advantage holds consistently or fluctuates."
+      },
+      {
+        "question": "What events can I use?",
+        "answer": "Any events you already track. A conversion is defined by two events: a start event and a goal event. Common examples include session_start → signup, signup → purchase, or page_view → add_to_cart."
+      },
+      {
+        "question": "Is the data sampled?",
+        "answer": "No. OpenPanel processes every event with no sampling. Your conversion rates are calculated from complete data, so you can trust the numbers even for small segments."
+      },
+      {
+        "question": "Can I see absolute numbers alongside rates?",
+        "answer": "Yes. Every conversion report shows both the conversion rate and the total number of conversions. The detail table below the chart includes totals and per-period counts for each segment."
+      }
+    ]
+  },
+  "cta": {
+    "label": "Track your first conversion",
+    "href": "https://dashboard.openpanel.dev/onboarding"
+  }
+}

apps/public/content/features/data-visualization.json

@@ -0,0 +1,175 @@
+{
+  "slug": "data-visualization",
+  "short_name": "Data visualization",
+  "seo": {
+    "title": "Dashboards & Data Visualization",
+    "description": "Turn raw product events into actionable charts. Funnels, retention, time series, Sankey diagrams, histograms, maps, and more-all in real time.",
+    "keywords": [
+      "analytics dashboards",
+      "product analytics charts",
+      "visualize event data",
+      "funnel chart",
+      "retention chart",
+      "conversion chart",
+      "sankey diagram analytics",
+      "time series analytics",
+      "histogram analytics",
+      "data visualization tool"
+    ]
+  },
+  "hero": {
+    "heading": "From events to charts - in real time",
+    "subheading": "Build dashboards with funnels, retention curves, time series, Sankey diagrams, and maps. No SQL, no data team required.",
+    "badges": [
+      "7+ chart types",
+      "Real-time dashboards",
+      "No SQL required",
+      "Export & share"
+    ]
+  },
+  "definition": {
+    "title": "Why data visualization matters",
+    "text": "Tracking events is step one. **Turning those events into charts and dashboards** is where decisions happen.\n\nProduct analytics dashboards let you see trends, spot problems, and measure experiments at a glance. Without visualization, you're staring at raw event logs. With it, you can answer questions like:\n\n- **Is signup conversion improving this month?** → Check the **funnel** chart\n- **Are users coming back after week one?** → Check the **retention** curve\n- **Where do users go after the pricing page?** → Check the **Sankey** diagram\n- **How are page load times distributed?** → Check the **histogram**\n- **Where are my users located?** → Check the **map** chart\n- **How does daily active usage trend?** → Check the **time series** chart\n\nOpenPanel gives you all of these chart types out of the box. Every chart is powered by the same events you already track-no extra instrumentation, no data pipelines, no SQL.\n\n### Chart types in OpenPanel\n\n- **Funnels** - Visualize step-by-step conversion. See exactly where users drop off in signup, onboarding, or purchase flows.\n- **Retention** - Measure how many users come back after day 1, week 1, month 1. Understand whether your product is sticky.\n- **Conversion** - Track goal completion rates over time. Compare conversion across segments, campaigns, or product changes.\n- **Sankey diagrams** - Map user journeys visually. See every path users take through your product and where they branch or exit.\n- **Maps** - See where your users are, geographically. Understand regional adoption and plan localization.\n- **Time series** - Plot any metric over time. Track daily active users, event volume, revenue, or any custom metric with flexible date ranges.\n- **Histograms** - Understand distributions. How long do sessions last? How many actions do users take? See the full shape of your data.\n\nYou can combine these charts into **dashboards** that update in real time. Pin the reports that matter, share them with your team, and check them daily-no waiting for a weekly report email."
+  },
+  "capabilities_section": {
+    "title": "Charts and dashboards built for product teams",
+    "intro": "Every chart type is designed to answer a specific product question. Pick the right one and get answers in seconds."
+  },
+  "capabilities": [
+    {
+      "title": "Funnels",
+      "description": "Visualize multi-step conversion flows. See drop-off at each step, compare segments, and find where users abandon signup, onboarding, or purchase."
+    },
+    {
+      "title": "Retention curves",
+      "description": "Measure user stickiness over days, weeks, or months. See cohort-level return rates and understand long-term engagement."
+    },
+    {
+      "title": "Conversion charts",
+      "description": "Track goal completion rates over time. Compare conversion across campaigns, plans, or product versions."
+    },
+    {
+      "title": "Sankey diagrams",
+      "description": "Map user journeys as flow diagrams. See every path through your product-where users go, where they branch, and where they exit."
+    },
+    {
+      "title": "Maps",
+      "description": "Visualize user geography on an interactive map. Understand where your users are and how behavior varies by region."
+    },
+    {
+      "title": "Time series",
+      "description": "Plot any event or metric over time with flexible intervals. Track trends, spot anomalies, and compare date ranges."
+    },
+    {
+      "title": "Histograms",
+      "description": "See distributions of session length, event counts, load times, or any numeric property. Understand the shape of your data, not just the average."
+    },
+    {
+      "title": "Real-time dashboards",
+      "description": "Combine any chart types into dashboards that update as events arrive. Pin the reports your team checks daily."
+    }
+  ],
+  "screenshots": [
+    {
+      "src": "/features/feature-data-vis-line.webp",
+      "alt": "Analytics report with time series chart in OpenPanel",
+      "caption": "Build reports with time series, funnels, retention, and more-all from the same event data."
+    },
+    {
+      "src": "/features/feature-data-vis-dashboard.webp",
+      "alt": "Product analytics dashboard with multiple chart types",
+      "caption": "Pin charts to dashboards and monitor key metrics in real time."
+    },
+    {
+      "src": "/features/feature-data-vis-bar.webp",
+      "alt": "Overview dashboard showing event trends and key metrics",
+      "caption": "Get a high-level view of product health: active users, event volume, and conversion at a glance."
+    }
+  ],
+  "how_it_works": {
+    "title": "How data visualization works",
+    "intro": "From raw events to shareable dashboards in three steps.",
+    "steps": [
+      {
+        "title": "Track events from your product",
+        "description": "Send events with our SDK or API. Page views, signups, purchases, feature usage-every event becomes a data point you can chart."
+      },
+      {
+        "title": "Pick a chart type and build a report",
+        "description": "Choose funnels, retention, time series, Sankey, maps, histograms, or conversion charts. Select your events, add filters, and see results instantly."
+      },
+      {
+        "title": "Pin to dashboards and share",
+        "description": "Save reports to dashboards your team can access. Charts update in real time as new events arrive-no manual refresh or export needed."
+      }
+    ]
+  },
+  "use_cases": {
+    "title": "Who uses analytics dashboards",
+    "intro": "Anyone who needs to turn product data into action.",
+    "items": [
+      {
+        "title": "Product managers",
+        "description": "Build dashboards with funnels, retention, and conversion charts to track feature launches and measure whether product changes move the needle."
+      },
+      {
+        "title": "Growth teams",
+        "description": "Use Sankey diagrams to map user journeys, funnels to optimize conversion, and time series to measure campaign impact over time."
+      },
+      {
+        "title": "Founders and operators",
+        "description": "Get a single dashboard with the metrics that matter: active users, conversion, retention, and revenue trends. Check it once a day instead of running ad-hoc queries."
+      },
+      {
+        "title": "Engineers",
+        "description": "Use histograms and time series to monitor event volume, track performance distributions, and spot anomalies without setting up a separate observability stack."
+      }
+    ]
+  },
+  "related_features": [
+    {
+      "slug": "event-tracking",
+      "title": "Event tracking",
+      "description": "Events are the data behind every chart. Track user actions to power your dashboards."
+    },
+    {
+      "slug": "funnels",
+      "title": "Funnels",
+      "description": "Dive deeper into conversion analysis with step-by-step funnel reports."
+    }
+  ],
+  "faqs": {
+    "title": "Frequently asked questions",
+    "intro": "Common questions about data visualization and analytics dashboards in OpenPanel.",
+    "items": [
+      {
+        "question": "What chart types does OpenPanel support?",
+        "answer": "OpenPanel supports funnels, retention curves, conversion charts, Sankey diagrams, geographic maps, time series, and histograms. All chart types are available on every plan."
+      },
+      {
+        "question": "Do I need to write SQL to build charts?",
+        "answer": "No. You build reports by selecting events, filters, and chart type from the UI. No SQL, no data pipelines-just pick your events and see results."
+      },
+      {
+        "question": "Can I share dashboards with my team?",
+        "answer": "Yes. Dashboards are accessible to your team members. Pin charts, arrange them however you like, and everyone sees the same real-time data."
+      },
+      {
+        "question": "How often do charts update?",
+        "answer": "Charts update in real time as new events arrive. There's no overnight processing or batch delay-data appears within seconds of being tracked."
+      },
+      {
+        "question": "What is a Sankey diagram?",
+        "answer": "A Sankey diagram is a flow visualization that shows how users move through your product. Each path is drawn as a flow between steps, so you can see common journeys, unexpected branches, and exit points at a glance."
+      },
+      {
+        "question": "Can I use retention and funnel charts together?",
+        "answer": "Yes. You can build funnels to find where users drop off and retention charts to see if the users who do convert come back. Combining both gives you a complete picture of activation and engagement."
+      }
+    ]
+  },
+  "cta": {
+    "label": "Start visualizing your data",
+    "href": "https://dashboard.openpanel.dev/onboarding"
+  }
+}

apps/public/content/features/event-tracking.json

@@ -0,0 +1,139 @@
+{
+  "slug": "event-tracking",
+  "short_name": "Event tracking",
+  "seo": {
+    "title": "Event Tracking - The Foundation of Product Analytics",
+    "description": "Track product events without Google Analytics. Simple, privacy-first event tracking that powers funnels, retention, and user profiles. Get started in minutes.",
+    "keywords": [
+      "event tracking software",
+      "product event tracking",
+      "custom event tracking"
+    ]
+  },
+  "hero": {
+    "heading": "Simple events tracking",
+    "subheading": "Track clicks, views, and conversions with a simple API. No cookies, no bloat - just the events you need to understand how users behave.",
+    "badges": [
+      "Track any user action",
+      "Custom properties",
+      "Real-time ingestion",
+      "One API for all reports"
+    ]
+  },
+  "definition": {
+    "title": "What is event tracking?",
+    "text": "Event tracking is the **foundation of product analytics**. Instead of relying on page-view counts or session timers, you capture discrete actions-clicks, page views, signups, purchases-as structured events with properties.\n\nEvery meaningful interaction becomes a data point you can query, filter, and visualize. This is how modern product teams answer questions like:\n\n- **How many users completed onboarding this week?**\n- **Which features do paying customers use most?**\n- **Where in the signup flow do users drop off?**\n\nTraditional analytics tools (like Google Analytics) are built around sessions and page views. That works for marketing, but it falls short when you need to understand **product behavior**: what users do *inside* your app, how they progress through flows, and what correlates with retention.\n\nOpenPanel takes a different approach. You send events from your app or website using a lightweight SDK or API. Each event has a name (e.g. `signup_completed`, `feature_used`) and optional properties (e.g. `plan: pro`, `source: google`). OpenPanel stores these events and lets you build **funnels**, **retention charts**, and **user profiles** on top of them-without the complexity of enterprise analytics tools.\n\nBecause OpenPanel is **privacy-first**, you can run it without cookies and without sending personal data to third parties. Self-host it or use our cloud-your data stays yours."
+  },
+  "capabilities_section": {
+    "title": "What you can track",
+    "intro": "From basic page views to custom conversion events, you get full visibility into user actions."
+  },
+  "capabilities": [
+    {
+      "title": "Page views and screen views",
+      "description": "Track which pages or screens users visit, with automatic properties like URL, referrer, and device."
+    },
+    {
+      "title": "Clicks and interactions",
+      "description": "Capture button clicks, form submissions, and any custom interactions with a single line of code."
+    },
+    {
+      "title": "Custom events and conversions",
+      "description": "Define your own events (e.g. signup, purchase, feature_used) and attach properties for filtering and analysis."
+    },
+    {
+      "title": "User and session context",
+      "description": "Events are tied to anonymous or identified users and sessions, so you can analyze behavior over time."
+    },
+    {
+      "title": "Real-time ingestion",
+      "description": "Events appear in your dashboard within seconds. No batching delays or overnight processing."
+    },
+    {
+      "title": "Funnels, retention, and profiles",
+      "description": "Use the same events to build conversion funnels, retention cohorts, and per-user activity timelines."
+    }
+  ],
+  "screenshots": [
+    {
+      "src": "/features/feature-events-list.webp",
+      "alt": "Event list showing tracked user actions in OpenPanel",
+      "caption": "Browse every event your product sends. Filter by name, user, or properties."
+    },
+    {
+      "src": "/features/feature-events-stats.webp",
+      "alt": "Event statistics and trends over time",
+      "caption": "See event volume and trends at a glance. Spot anomalies before they become problems."
+    },
+    {
+      "src": "/features/feature-events-details.webp",
+      "alt": "Detailed view of a single event with properties",
+      "caption": "Drill into any event to see its full context: user, session, properties, and timestamp."
+    }
+  ],
+  "how_it_works": {
+    "title": "How event tracking works",
+    "intro": "Three steps to go from zero to full product visibility.",
+    "steps": [
+      {
+        "title": "Install the SDK or use the API",
+        "description": "Add our lightweight script to your site or use our SDK for React, Next.js, or other frameworks. Self-hosted or cloud-your choice."
+      },
+      {
+        "title": "Send events from your product",
+        "description": "Track page views automatically and call our API for custom events (signup, purchase, feature_used) with optional properties."
+      },
+      {
+        "title": "Analyze in dashboards, funnels, and retention",
+        "description": "Events flow into funnels, retention charts, and user profiles. No extra setup-one tracking layer powers everything."
+      }
+    ]
+  },
+  "use_cases": {
+    "title": "Who uses event tracking",
+    "intro": "Product and growth teams use events to answer concrete questions.",
+    "items": [
+      {
+        "title": "Product managers",
+        "description": "Understand which features are used, where users drop off, and how behavior differs between segments."
+      },
+      {
+        "title": "Growth and marketing",
+        "description": "Measure conversion from signup to activation and from visit to purchase. Optimize campaigns based on real events."
+      },
+      {
+        "title": "Support and success",
+        "description": "View a user's event timeline before a call or ticket. No need to ask \"what did you click?\"-you can see it."
+      }
+    ]
+  },
+  "related_features": [
+    {
+      "slug": "funnels",
+      "title": "Funnels",
+      "description": "See where users drop off in signup, activation, and conversion flows."
+    }
+  ],
+  "faqs": {
+    "title": "Frequently asked questions",
+    "intro": "Common questions about event tracking with OpenPanel.",
+    "items": [
+      {
+        "question": "Do I need cookies for event tracking?",
+        "answer": "No. OpenPanel can run without cookies. We use a first-party cookie only if you enable it for better session continuity. Many teams run fully cookie-less and still get accurate funnels and retention."
+      },
+      {
+        "question": "How is this different from Google Analytics?",
+        "answer": "Google Analytics is built for marketing and traffic analysis, with a complex data model. OpenPanel is built for product and conversion: simple events that map directly to user actions. You get funnels, retention, and user profiles without the GA learning curve."
+      },
+      {
+        "question": "Can I track custom events?",
+        "answer": "Yes. You can send any event name and attach optional properties (e.g. plan, value, feature_name). Custom events work in funnels, retention, and user profiles the same way as built-in events."
+      }
+    ]
+  },
+  "cta": {
+    "label": "Track events in minutes",
+    "href": "https://dashboard.openpanel.dev/onboarding"
+  }
+}

apps/public/content/features/funnels.json

@@ -0,0 +1,139 @@
+{
+  "slug": "funnels",
+  "short_name": "Funnels",
+  "seo": {
+    "title": "Funnel Analysis - See Where Users Drop Off",
+    "description": "See where users drop off in signup, activation, and conversion funnels. Build funnel reports from your events in minutes-no complex setup.",
+    "keywords": [
+      "funnel analysis",
+      "conversion funnels",
+      "signup funnel analytics"
+    ]
+  },
+  "hero": {
+    "heading": "Funnels: Where do users drop off?",
+    "subheading": "Build funnels from your events and see conversion and drop-off at every step. No complex setup - just pick the events and go.",
+    "badges": [
+      "Find drop-off points",
+      "No sampling",
+      "Segment by any property",
+      "Real-time conversion rates"
+    ]
+  },
+  "definition": {
+    "title": "What is funnel analysis?",
+    "text": "A funnel is a **sequence of steps** you expect users to complete-for example: *visited homepage → signed up → verified email → created first project*. Funnel analysis shows you how many users complete each step and, critically, **where they leave**.\n\nThis matters because most products lose the majority of their users somewhere in the journey. Without funnel analysis, you're guessing where. With it, you can see:\n\n- **Step-by-step conversion rates** - what percentage of users move from one step to the next\n- **Biggest drop-off points** - where the most users abandon the flow\n- **Time between steps** - how long users take, and where they get stuck\n- **Segment differences** - whether users from organic search convert differently than paid traffic\n\nUnlike traditional analytics tools that require complex configuration, OpenPanel funnels are built **directly on your events**. If you're already tracking `signup_started`, `signup_completed`, and `first_action`, you can create a funnel from those events in seconds-no extra instrumentation needed.\n\nFunnels in OpenPanel use **every event** (no sampling) and update in real time. You can add filters, compare segments, and save funnels to dashboards alongside retention charts and other reports.\n\nThe result: you stop guessing and start **fixing the steps that actually lose users**."
+  },
+  "capabilities_section": {
+    "title": "What you can do with funnels",
+    "intro": "From signup to revenue, funnels help you find and fix friction."
+  },
+  "capabilities": [
+    {
+      "title": "Signup and onboarding funnels",
+      "description": "Track visit → signup → email verified → first action. See where prospects drop and optimize the path."
+    },
+    {
+      "title": "Activation funnels",
+      "description": "Define activation as a sequence of events (e.g. created project → invited teammate → first export). Measure time to activate."
+    },
+    {
+      "title": "Conversion and revenue funnels",
+      "description": "From trial started to paid conversion, or from add to cart to purchase. Tie steps to revenue events."
+    },
+    {
+      "title": "Flexible step definition",
+      "description": "Each step can be a single event or a group of events. Filter by properties (e.g. plan, source) to compare segments."
+    },
+    {
+      "title": "Conversion and drop-off rates",
+      "description": "See percentage completing each step and overall conversion. No sampling-every event counts."
+    },
+    {
+      "title": "Time between steps",
+      "description": "Understand how long users take between steps. Identify slow or stuck segments."
+    }
+  ],
+  "screenshots": [
+    {
+      "src": "/features/feature-funnel-report.webp",
+      "alt": "Funnel report showing conversion and drop-off at each step",
+      "caption": "See exactly where users drop off. Each step shows conversion rate and volume."
+    },
+    {
+      "src": "/features/feature-funnel-pick-events.webp",
+      "alt": "Selecting events to define funnel steps",
+      "caption": "Build funnels by picking the events that represent each step. No code changes needed."
+    },
+    {
+      "src": "/features/feature-funnel-completed.webp",
+      "alt": "Completed funnel analysis with conversion metrics",
+      "caption": "A finished funnel report with step-by-step conversion, drop-off, and time between steps."
+    }
+  ],
+  "how_it_works": {
+    "title": "How funnel analysis works",
+    "intro": "Funnels in OpenPanel are defined by the events you already track.",
+    "steps": [
+      {
+        "title": "Track the right events",
+        "description": "Ensure the events that represent each step (e.g. signup_completed, project_created) are sent from your product. No funnel-specific tracking needed."
+      },
+      {
+        "title": "Create a funnel report",
+        "description": "In OpenPanel, create a funnel and add steps: each step is one or more events. Optionally add filters (e.g. by plan or campaign)."
+      },
+      {
+        "title": "Read conversion and drop-off",
+        "description": "See how many users completed each step, the conversion rate between steps, and where the biggest drop-off happens. Use this to prioritize fixes."
+      }
+    ]
+  },
+  "use_cases": {
+    "title": "Who uses funnel analysis",
+    "intro": "Teams use funnels to make decisions about product and growth.",
+    "items": [
+      {
+        "title": "Product and growth teams",
+        "description": "Find the biggest drop-off in signup or activation and run experiments to improve conversion. Measure impact with the same funnel."
+      },
+      {
+        "title": "Marketing",
+        "description": "Compare funnel conversion by traffic source or campaign. Double down on channels that convert and fix landing pages that don't."
+      },
+      {
+        "title": "Founders and operators",
+        "description": "Get a single view of the journey from visitor to paying customer. No spreadsheets-just events and funnel reports."
+      }
+    ]
+  },
+  "related_features": [
+    {
+      "slug": "event-tracking",
+      "title": "Event tracking",
+      "description": "Events are the foundation. Track the steps that feed your funnels."
+    }
+  ],
+  "faqs": {
+    "title": "Frequently asked questions",
+    "intro": "Common questions about funnel analysis with OpenPanel.",
+    "items": [
+      {
+        "question": "Do I need to set up funnels separately from events?",
+        "answer": "No. You track events once (page views, signups, purchases, etc.). Funnels are just a way to arrange those events into steps. Create or change a funnel anytime without changing your tracking code."
+      },
+      {
+        "question": "Can I filter funnels by user property or segment?",
+        "answer": "Yes. You can add filters to funnel steps (e.g. only users from a specific campaign or on a specific plan). This lets you compare conversion across segments."
+      },
+      {
+        "question": "How is funnel data calculated?",
+        "answer": "We count unique users who completed each step in order within your selected time window. There's no sampling-every event is included. Results update as new events arrive."
+      }
+    ]
+  },
+  "cta": {
+    "label": "Build your first funnel",
+    "href": "https://dashboard.openpanel.dev/onboarding"
+  }
+}

apps/public/content/features/identify-users.json

@@ -0,0 +1,158 @@
+{
+  "slug": "identify-users",
+  "short_name": "Identify users",
+  "seo": {
+    "title": "User Profiles & Identification",
+    "description": "Track individual users across sessions with privacy-first user profiles. See first seen, last seen, activity timelines, and custom properties-without invasive tracking.",
+    "keywords": [
+      "user profiles analytics",
+      "track individual users",
+      "user activity timeline",
+      "identify users analytics",
+      "user tracking software"
+    ]
+  },
+  "hero": {
+    "heading": "User tracking",
+    "subheading": "See who they are, when they first appeared, and what they did - with full respect for privacy. No fingerprinting, no surveillance.",
+    "badges": [
+      "First seen / last seen",
+      "Activity timeline per user",
+      "Custom user properties",
+      "Privacy-first identification"
+    ]
+  },
+  "definition": {
+    "title": "What is user identification?",
+    "text": "User identification connects anonymous activity to a **known user profile**. Instead of treating every visit as a nameless session, you link events, page views, and sessions to a real person-someone you can look up, follow over time, and understand in context.\n\nWith OpenPanel, identification works like this:\n\n1. A visitor arrives and generates anonymous events\n2. When they sign up or log in, you call `identify()` with an ID and optional properties\n3. OpenPanel merges their anonymous history with the identified profile\n\nFrom that point on, you have a **complete picture**: when they first appeared, when they were last active, every event they triggered, and any properties you attached (plan, company, role, etc.).\n\nThis is how modern product teams answer questions like:\n\n- **When did this user first show up, and what led them to sign up?**\n- **What did they do in the last 7 days?**\n- **Which features does this account actually use?**\n- **Is this user at risk of churning?**\n\nUnlike traditional analytics that reduce users to anonymous metrics, OpenPanel gives you **individual-level visibility** without compromising privacy. You control what data you send. No third-party cookies, no fingerprinting, no data sold to advertisers. You get user profiles that help your support, sales, and product teams-without the surveillance."
+  },
+  "capabilities_section": {
+    "title": "What you get with user profiles",
+    "intro": "From basic identity to full activity history, user profiles give you the context your team needs."
+  },
+  "capabilities": [
+    {
+      "title": "First seen and last seen",
+      "description": "Know exactly when each user first appeared and when they were last active. Spot dormant accounts before they churn."
+    },
+    {
+      "title": "Full activity timeline",
+      "description": "See every event a user triggered in chronological order-page views, clicks, conversions, custom events-all on one screen."
+    },
+    {
+      "title": "Custom user properties",
+      "description": "Attach properties like plan, company, role, or lifetime value. Filter and segment users by any property you set."
+    },
+    {
+      "title": "Anonymous-to-identified merge",
+      "description": "Pre-signup activity is automatically merged with the identified profile, so you never lose the full journey."
+    },
+    {
+      "title": "Session history",
+      "description": "See how many sessions a user has had, how long they lasted, and what happened in each one."
+    },
+    {
+      "title": "Privacy-first by design",
+      "description": "You choose what to send. No fingerprinting, no third-party cookies, no hidden data collection. Self-host for full control."
+    }
+  ],
+  "screenshots": [
+    {
+      "src": "/features/feature-profiles-details.webp",
+      "alt": "User profile showing activity timeline and properties in OpenPanel",
+      "caption": "See a user's full history: first seen, last seen, events, sessions, and custom properties."
+    },
+    {
+      "src": "/features/feature-profiles-events.webp",
+      "alt": "Event stream for an identified user",
+      "caption": "Drill into any user's event stream to understand exactly what they did and when."
+    }
+  ],
+  "how_it_works": {
+    "title": "How user identification works",
+    "intro": "Three steps to go from anonymous visitors to rich user profiles.",
+    "steps": [
+      {
+        "title": "Track events as usual",
+        "description": "Install the SDK and send events. Before identification, all activity is stored under an anonymous profile."
+      },
+      {
+        "title": "Call identify() on login or signup",
+        "description": "Pass a user ID and optional properties (email, plan, company). OpenPanel merges the anonymous history with the new profile."
+      },
+      {
+        "title": "Browse profiles and timelines",
+        "description": "Open any user profile to see their full journey: first seen, last seen, every event, session history, and attached properties."
+      }
+    ]
+  },
+  "use_cases": {
+    "title": "Who uses user profiles",
+    "intro": "User identification powers workflows across support, sales, and product teams.",
+    "items": [
+      {
+        "title": "Support teams",
+        "description": "Pull up a user's activity timeline before responding to a ticket. See what they clicked, where they got stuck, and whether the issue is reproducible-without asking them to describe every step."
+      },
+      {
+        "title": "Sales teams",
+        "description": "See which features a prospect has explored, how often they return, and when they were last active. Reach out with context instead of cold guesses."
+      },
+      {
+        "title": "Product managers",
+        "description": "Identify power users and understand what makes them different. Compare activity patterns between retained and churned users to prioritize the right features."
+      },
+      {
+        "title": "Customer success",
+        "description": "Monitor user engagement over time. Spot accounts going quiet before they cancel and intervene with the right message at the right time."
+      }
+    ]
+  },
+  "related_features": [
+    {
+      "slug": "event-tracking",
+      "title": "Event tracking",
+      "description": "Track the actions that make up each user's activity timeline."
+    },
+    {
+      "slug": "session-tracking",
+      "title": "Session tracking",
+      "description": "See how users move through your product session by session."
+    },
+    {
+      "slug": "funnels",
+      "title": "Funnels",
+      "description": "Analyze where identified users drop off in conversion flows."
+    }
+  ],
+  "faqs": {
+    "title": "Frequently asked questions",
+    "intro": "Common questions about user identification in OpenPanel.",
+    "items": [
+      {
+        "question": "What happens before a user is identified?",
+        "answer": "Events are stored under an anonymous profile. When you call identify(), the anonymous history is merged with the identified profile, so you get the complete journey from first visit to current session."
+      },
+      {
+        "question": "Is this GDPR-compliant?",
+        "answer": "Yes. You control exactly what data you send. OpenPanel doesn't add tracking pixels, fingerprinting, or third-party cookies. If you self-host, no data ever leaves your infrastructure. You can also delete a user's data at any time to comply with erasure requests."
+      },
+      {
+        "question": "How is this different from Google Analytics user tracking?",
+        "answer": "Google Analytics relies on anonymous client IDs and has limited support for individual-level profiles. OpenPanel gives you a dedicated profile page per user with a full event timeline, session history, and custom properties-without sending data to Google."
+      },
+      {
+        "question": "Can I attach custom properties to users?",
+        "answer": "Yes. Pass any key-value pairs when you call identify()-plan, company, role, revenue, or anything else. These properties are searchable and can be used to filter and segment users across all reports."
+      },
+      {
+        "question": "Do I need to identify every user?",
+        "answer": "No. Identification is optional. Anonymous users still generate events and sessions. You identify users when you want to link their activity to a known person-typically after login or signup."
+      }
+    ]
+  },
+  "cta": {
+    "label": "Start identifying users today",
+    "href": "https://dashboard.openpanel.dev/onboarding"
+  }
+}

apps/public/content/features/integrations.json

@@ -0,0 +1,168 @@
+{
+  "slug": "integrations",
+  "short_name": "Integrations",
+  "seo": {
+    "title": "Integrations - Slack, Webhooks & More",
+    "description": "Connect OpenPanel to Slack, Discord, webhooks, and more. Trigger actions based on user behavior-send alerts, sync to Zapier, or export events to S3 and BigQuery.",
+    "keywords": [
+      "analytics integrations",
+      "webhook analytics",
+      "slack notifications analytics",
+      "zapier analytics integration",
+      "event-driven webhooks",
+      "export events to s3",
+      "analytics to bigquery"
+    ]
+  },
+  "hero": {
+    "heading": "Integrations: Connect to any webhook",
+    "subheading": "Push data out of OpenPanel and into Slack, Discord, or any webhook. Trigger on the events that matter - no polling, no glue code.",
+    "badges": [
+      "Slack, Discord & webhooks",
+      "Trigger on any event",
+      "Custom payloads with JavaScript",
+      "S3 & GCS export coming soon"
+    ]
+  },
+  "definition": {
+    "title": "What are integrations?",
+    "text": "Integrations are the bridge between OpenPanel and everything else. They let you **get data out** of OpenPanel and into the tools and workflows your team already relies on.\n\nThe idea is simple: you create an **integration** (a connection to an external service), then attach it to a **[notification rule](/features/notifications)** that fires whenever the conditions you define are met. That's it - OpenPanel handles the rest.\n\nHere's an example: you want to be notified in Slack whenever a new user signs up from a specific country. You create a Slack integration, set up a notification rule that triggers on `signup` events, and use a template like *\"New user from {{country}}\"*. Every time someone signs up, the message lands in your Slack channel - no polling, no cron jobs, no glue code.\n\nBut it goes further than alerts. With **webhooks**, you can push event data to any URL - including **Zapier**, **Make**, or your own backend. That means you can trigger custom workflows based on real user behavior: send a welcome email when someone completes onboarding, notify sales when a user hits a usage milestone, or log high-value events to an external system.\n\nYou can even trigger integrations when a user completes a **funnel** - combining OpenPanel's funnel analysis with real-time action.\n\nToday, OpenPanel supports:\n\n- **Slack** - post messages to any channel when events fire\n- **Discord** - same as Slack, but for Discord servers\n- **Webhooks** - send event payloads to any URL with custom headers and a JavaScript transform for full control over the payload shape\n\nComing soon:\n\n- **S3-compatible storage** - automatically export events to Amazon S3, MinIO, Cloudflare R2, or any S3-compatible store\n- **Google Cloud Storage** - export to GCS for easy import into **BigQuery**, **Redshift**, or your data warehouse\n\nThese storage integrations will make importing your OpenPanel events into your data warehouse straightforward and easy - no custom ETL pipelines needed."
+  },
+  "capabilities_section": {
+    "title": "What you can do with integrations",
+    "intro": "From real-time Slack alerts to warehouse exports - integrations connect OpenPanel to your stack."
+  },
+  "capabilities": [
+    {
+      "title": "Slack & Discord notifications",
+      "description": "Connect your Slack workspace or Discord server and receive messages whenever notification rules fire. Great for staying on top of signups, errors, or milestone events without leaving your chat tool."
+    },
+    {
+      "title": "Webhooks to any URL",
+      "description": "Send event data to any HTTP endpoint - your own API, Zapier, Make, or any automation platform. Define custom headers and use a JavaScript transform to shape the payload exactly how the receiving service expects it."
+    },
+    {
+      "title": "JavaScript payload transforms",
+      "description": "Webhook integrations include a built-in JavaScript editor. Write a transform function that receives the raw payload and returns whatever shape you need - rename fields, filter data, or enrich the payload before it's sent."
+    },
+    {
+      "title": "Pair with notification rules",
+      "description": "Integrations don't fire on their own - you attach them to notification rules. A single rule can trigger multiple integrations at once, and a single integration can be used by many rules."
+    },
+    {
+      "title": "Trigger on funnels and events",
+      "description": "Notification rules can fire on specific events with property filters, or when a user completes an entire funnel. That means you can trigger a webhook when someone finishes onboarding, not just when they view a single page."
+    },
+    {
+      "title": "S3 & GCS export (coming soon)",
+      "description": "Automatically export your events to S3-compatible storage or Google Cloud Storage. From there, import into BigQuery, Redshift, or any data warehouse - no custom ETL required."
+    }
+  ],
+  "screenshots": [
+    {
+      "src": "/features/feature-integrations.webp",
+      "alt": "Available integrations showing Slack, Discord, and Webhook options",
+      "caption": "Browse available integrations. Connect Slack, Discord, or set up a custom webhook in seconds."
+    },
+    {
+      "src": "/features/feature-integrations-create.webp",
+      "alt": "Creating a webhook integration with URL, headers, and JavaScript transform",
+      "caption": "Create a webhook integration with a custom URL, headers, and a JavaScript transform to shape the payload exactly how you need it."
+    }
+  ],
+  "how_it_works": {
+    "title": "How integrations work",
+    "intro": "Set up an integration in minutes, then let notification rules handle the rest.",
+    "steps": [
+      {
+        "title": "Pick an integration type",
+        "description": "Choose from Slack, Discord, or Webhook. Each type has its own setup - OAuth for Slack and Discord, URL + headers for webhooks."
+      },
+      {
+        "title": "Configure the connection",
+        "description": "For Slack/Discord, connect your workspace or server. For webhooks, enter the target URL, add any custom headers, and optionally write a JavaScript transform to control the payload shape."
+      },
+      {
+        "title": "Create a notification rule",
+        "description": "In the Notifications section, create a rule that defines when the integration should fire - e.g. when a screen_view event has a path starting with /onboarding. Attach one or more integrations to the rule."
+      },
+      {
+        "title": "Events trigger actions automatically",
+        "description": "When an event matches a rule, OpenPanel sends the data to every attached integration in real time. No polling, no delays."
+      }
+    ]
+  },
+  "use_cases": {
+    "title": "How teams use integrations",
+    "intro": "From team alerts to full automation pipelines - integrations turn analytics into action.",
+    "items": [
+      {
+        "title": "Real-time team alerts",
+        "description": "Post to Slack or Discord when a new user signs up, a high-value purchase happens, or a critical error fires. Keep the whole team aware without anyone needing to check a dashboard."
+      },
+      {
+        "title": "Zapier and automation workflows",
+        "description": "Send webhook payloads to Zapier or Make to trigger downstream actions - send a welcome email, update a CRM, add a row to a spreadsheet, or kick off an onboarding drip campaign. All driven by real user behavior."
+      },
+      {
+        "title": "Custom backend actions",
+        "description": "Point a webhook at your own API to run custom logic when specific events fire. Credit a referral, flag a suspicious session, or sync analytics data to an internal tool."
+      },
+      {
+        "title": "Data warehouse export",
+        "description": "With the upcoming S3 and GCS integrations, export events directly to your data warehouse. Load into BigQuery or Redshift for advanced SQL analysis, cross-referencing with other datasets, or long-term storage."
+      }
+    ]
+  },
+  "related_features": [
+    {
+      "slug": "notifications",
+      "title": "Notifications",
+      "description": "Notification rules control when integrations fire. Define events, filters, and templates - then attach integrations to act on them."
+    },
+    {
+      "slug": "event-tracking",
+      "title": "Event tracking",
+      "description": "Integrations are powered by the events you track. The richer your event data, the more precise your triggers can be."
+    },
+    {
+      "slug": "funnels",
+      "title": "Funnels",
+      "description": "Trigger integrations when a user completes an entire funnel - not just a single event."
+    }
+  ],
+  "faqs": {
+    "title": "Frequently asked questions",
+    "intro": "Common questions about OpenPanel integrations.",
+    "items": [
+      {
+        "question": "How do integrations and notifications work together?",
+        "answer": "Integrations are the destinations (Slack channel, webhook URL, Discord server). Notification rules are the triggers (when event X happens with filter Y). You create both, then attach integrations to rules. When a rule fires, all attached integrations receive the data."
+      },
+      {
+        "question": "Can I use webhooks with Zapier?",
+        "answer": "Yes. Create a webhook integration pointing to your Zapier webhook URL. You can use the JavaScript transform to shape the payload into whatever format your Zap expects. This lets you trigger any Zapier workflow based on real user events in OpenPanel."
+      },
+      {
+        "question": "What does the JavaScript transform do?",
+        "answer": "The JavaScript transform is a function that receives the raw event payload and returns a modified version. You can rename fields, filter out properties, add computed values, or completely restructure the data. It runs before the payload is sent to the webhook URL."
+      },
+      {
+        "question": "When will S3 and GCS integrations be available?",
+        "answer": "S3-compatible storage and Google Cloud Storage integrations are on the near-term roadmap. These will let you automatically export events for import into BigQuery, Redshift, or any data warehouse without building custom ETL pipelines."
+      },
+      {
+        "question": "Can one integration be used by multiple notification rules?",
+        "answer": "Yes. An integration is just a connection to a service. You can attach it to as many notification rules as you want. For example, a single Slack integration can be triggered by rules for signups, purchases, and errors - each with its own template and filters."
+      },
+      {
+        "question": "Is there a limit to how many integrations I can create?",
+        "answer": "There's no hard limit. Create as many integrations and notification rules as you need to cover your workflows."
+      }
+    ]
+  },
+  "cta": {
+    "label": "Set up your first integration",
+    "href": "https://dashboard.openpanel.dev/onboarding"
+  }
+}

apps/public/content/features/notifications.json

@@ -0,0 +1,167 @@
+{
+  "slug": "notifications",
+  "short_name": "Notifications",
+  "seo": {
+    "title": "Notifications - Act When Events Happen",
+    "description": "Set up notification rules that trigger when specific events happen. Filter by event properties, use templates with variables, and route alerts to Slack, Discord, or any webhook.",
+    "keywords": [
+      "analytics notifications",
+      "event-based alerts",
+      "real-time user alerts",
+      "notification rules analytics",
+      "event filtering notifications",
+      "custom alert templates"
+    ]
+  },
+  "hero": {
+    "heading": "When it happens, act on it",
+    "subheading": "Define rules that watch for specific events and fire automatically. Filter by properties, use templates with variables, and route to Slack, Discord, or any webhook.",
+    "badges": [
+      "Event-based rules",
+      "Property filters",
+      "Template variables",
+      "Multi-integration routing"
+    ]
+  },
+  "definition": {
+    "title": "What are notification rules?",
+    "text": "Notification rules are the **trigger layer** in OpenPanel. They define *when* something should happen - and **[integrations](/features/integrations)** define *where* it goes.\n\nA notification rule has three parts:\n\n1. **Events** - which events to watch for (e.g. `screen_view`, `purchase`, `signup`)\n2. **Filters** - optional property conditions that narrow the match (e.g. path starts with `/onboarding` and ends with `/verify`)\n3. **Integrations** - which connected services should receive the notification when the rule fires\n\nYou can also write a **template** using variables like `{{country}}`, `{{browser}}`, or any event property. The template is rendered with real values when the notification fires, so your Slack message or webhook payload contains the exact context you need.\n\nHere's a concrete example: you want to know when new users visit your onboarding verification page. You create a rule that:\n\n- Watches for `screen_view` events\n- Filters where **path** starts with `/onboarding` and ends with `/verify`\n- Uses the template *\"New user with their first event from {{country}}\"*\n- Routes to your Slack workspace and a webhook integration\n\nNow every time someone hits that page, your team sees a message in Slack with the user's country, and your webhook fires for any downstream automation.\n\nThe notifications page in OpenPanel shows a feed of every notification that fired - searchable, sortable by date, and showing the integration, country, OS, browser, and profile for each one. You can see exactly what happened and when.\n\nNotification rules are the glue between **events you track** and **actions you take**. Combined with integrations, they turn OpenPanel from a passive analytics tool into an active part of your workflow."
+  },
+  "capabilities_section": {
+    "title": "What you can do with notifications",
+    "intro": "From simple alerts to complex event-driven workflows - rules give you full control."
+  },
+  "capabilities": [
+    {
+      "title": "Event-based triggers",
+      "description": "Choose which events a rule watches for - screen_view, purchase, signup, or any custom event. A single rule can watch for one event type and fire on every match."
+    },
+    {
+      "title": "Property filters",
+      "description": "Narrow rules with property conditions. Filter by path, country, device, or any event property using operators like 'starts with', 'ends with', 'equals', and more. Stack multiple filters to match exactly the events you care about."
+    },
+    {
+      "title": "Template variables",
+      "description": "Write notification templates with {{variable}} syntax. Use any event property - {{country}}, {{path}}, {{browser}}, {{os}}, or custom properties. Templates are rendered with real values when the notification fires."
+    },
+    {
+      "title": "Multi-integration routing",
+      "description": "Attach multiple integrations to a single rule. Fire a Slack message and a webhook at the same time. Mix and match integrations across rules however you want."
+    },
+    {
+      "title": "Notification feed",
+      "description": "Every fired notification is logged in a searchable feed. See the title, integration, country, OS, browser, and profile for each notification. Filter and sort to find exactly what you need."
+    },
+    {
+      "title": "Rules management",
+      "description": "Create, edit, and delete rules from a dedicated Rules tab. See at a glance which events each rule watches, what filters are applied, and which integrations are attached."
+    }
+  ],
+  "screenshots": [
+    {
+      "src": "/features/feature-notifications.webp",
+      "alt": "Notification feed showing fired notifications with country, OS, browser, and profile details",
+      "caption": "Every notification that fires is logged in a searchable feed. See the country, OS, browser, and profile for each event - sortable and searchable."
+    },
+    {
+      "src": "/features/feature-notifications-rule.webp",
+      "alt": "Editing a notification rule with event type, property filters, template, and integrations",
+      "caption": "Create rules with event filters, template variables, and multi-integration routing. This rule fires on screen_view events where the path matches an onboarding verification flow."
+    }
+  ],
+  "how_it_works": {
+    "title": "How notification rules work",
+    "intro": "Rules are simple: define the trigger, write the message, pick the destinations.",
+    "steps": [
+      {
+        "title": "Choose the event type",
+        "description": "Select which event the rule should watch - screen_view, purchase, signup, or any custom event you track. The rule will evaluate every incoming event of that type."
+      },
+      {
+        "title": "Add property filters",
+        "description": "Optionally narrow the rule with property conditions. For example, filter where path starts with /onboarding and ends with /verify. Only events matching all filters will trigger the rule."
+      },
+      {
+        "title": "Write a template",
+        "description": "Write the notification message using {{variable}} placeholders. When the rule fires, variables are replaced with real values from the event - e.g. \"New user with their first event from {{country}}\" becomes \"New user with their first event from US\"."
+      },
+      {
+        "title": "Attach integrations",
+        "description": "Select one or more integrations to receive the notification - Slack, Discord, webhook, or any combination. Each integration will be triggered simultaneously when a matching event arrives."
+      }
+    ]
+  },
+  "use_cases": {
+    "title": "How teams use notifications",
+    "intro": "From simple team alerts to event-driven automation - notifications make analytics actionable.",
+    "items": [
+      {
+        "title": "New user alerts",
+        "description": "Get notified in Slack whenever a new user signs up. Include their country, source, or any property in the message. The whole team sees new signups in real time without checking a dashboard."
+      },
+      {
+        "title": "Onboarding monitoring",
+        "description": "Set up rules that fire when users hit key onboarding milestones - account creation, first feature use, verification. Know immediately when someone gets stuck or completes the flow."
+      },
+      {
+        "title": "Revenue and purchase alerts",
+        "description": "Fire a notification on every purchase event. Include the amount, plan, or product in the template. Route to Slack for celebration and to a webhook for CRM updates or fulfillment triggers."
+      },
+      {
+        "title": "Error and regression detection",
+        "description": "Watch for error events or unexpected patterns. Get alerted when error rates spike for a specific page or feature, so you can respond before users complain."
+      }
+    ]
+  },
+  "related_features": [
+    {
+      "slug": "integrations",
+      "title": "Integrations",
+      "description": "Integrations are the destinations for notifications. Connect Slack, Discord, or webhooks, then attach them to rules."
+    },
+    {
+      "slug": "event-tracking",
+      "title": "Event tracking",
+      "description": "Notification rules are built on the events you track. The more events you send, the more precise your rules can be."
+    },
+    {
+      "slug": "funnels",
+      "title": "Funnels",
+      "description": "Trigger notifications when users complete a funnel - combining step-by-step analysis with real-time action."
+    }
+  ],
+  "faqs": {
+    "title": "Frequently asked questions",
+    "intro": "Common questions about notification rules in OpenPanel.",
+    "items": [
+      {
+        "question": "What's the difference between notifications and integrations?",
+        "answer": "Integrations are connections to external services (Slack, Discord, webhooks). Notifications are rules that define when those integrations should fire. You create an integration once, then attach it to as many notification rules as you want."
+      },
+      {
+        "question": "What template variables can I use?",
+        "answer": "You can use any event property as a template variable with the {{property}} syntax. Common ones include {{country}}, {{city}}, {{browser}}, {{os}}, {{path}}, and any custom properties you send with your events."
+      },
+      {
+        "question": "Can I have multiple filters on a single rule?",
+        "answer": "Yes. You can stack multiple property filters on a rule. All filters must match for the rule to fire - they work as AND conditions. For example, path starts with /onboarding AND path ends with /verify."
+      },
+      {
+        "question": "Can I send to multiple integrations from one rule?",
+        "answer": "Yes. Attach as many integrations as you want to a single rule. When the rule fires, all attached integrations are triggered simultaneously. For example, send to both Slack and a webhook at the same time."
+      },
+      {
+        "question": "Is there a delay between the event and the notification?",
+        "answer": "No. Notifications fire in real time as events arrive. There's no batching or delay - when an event matches a rule, the attached integrations are triggered immediately."
+      },
+      {
+        "question": "Can I see past notifications?",
+        "answer": "Yes. The Notifications tab shows a feed of every notification that fired. You can search, sort by date, and see details like the integration used, country, OS, browser, and profile for each notification."
+      }
+    ]
+  },
+  "cta": {
+    "label": "Set up your first notification rule",
+    "href": "https://dashboard.openpanel.dev/onboarding"
+  }
+}

apps/public/content/features/retention.json

@@ -0,0 +1,138 @@
+{
+  "slug": "retention",
+  "short_name": "Retention",
+  "seo": {
+    "title": "Retention & Cohort Analysis",
+    "description": "User retention analytics and cohort analysis that show who comes back. See product stickiness at a glance-no sampling, no guesswork. Built on your events.",
+    "keywords": [
+      "user retention analytics",
+      "cohort analysis"
+    ]
+  },
+  "hero": {
+    "heading": "Retention: Who comes back?",
+    "subheading": "See who returns after signup, activation, or any key action. Cohort-based retention that shows real stickiness - not vanity metrics.",
+    "badges": [
+      "Cohort-based retention",
+      "Any start and return event",
+      "No sampling",
+      "Compare segments"
+    ]
+  },
+  "definition": {
+    "title": "What retention means",
+    "text": "**Retention** is the share of users who come back after doing something once. It answers: *Of the people who did X in a given week, how many did Y later?*\n\nThat’s it. No session thresholds, no arbitrary “active” definitions-just a clear picture of **who sticks** and who doesn’t.\n\nWhy does it matter? Because retention is **product truth**. Traffic and signups can look great while the product fails to stick. Retention cuts through that. It tells you:\n\n- **Whether your product is habit-forming** - Do users return after the first use?\n- **When churn happens** - Do they leave after day 1, week 1, or month 1?\n- **Which segments stick** - Do certain cohorts (e.g. by plan, source, or feature) retain better?\n\nIn OpenPanel, retention is built on your **events**. You choose an initial event (e.g. `signup_completed`, `first_purchase`) and a return event (e.g. `feature_used`, `session_started`). OpenPanel groups users into cohorts by when they did the initial event and shows what percentage did the return event in subsequent periods. No extra instrumentation-the same events that power funnels and user profiles power retention."
+  },
+  "capabilities_section": {
+    "title": "What you can do with retention",
+    "intro": "From weekly cohorts to segment comparison, retention gives you the stickiness signal."
+  },
+  "capabilities": [
+    {
+      "title": "Cohort-based retention",
+      "description": "Group users by when they did an initial event (e.g. signup week). See what percentage return in week 1, 2, 3, and beyond."
+    },
+    {
+      "title": "Any start and return event",
+      "description": "Define retention your way: signup → login, first purchase → repeat purchase, feature_used → feature_used again. No fixed definitions."
+    },
+    {
+      "title": "Read the grid at a glance",
+      "description": "Retention grids show cohorts in rows and time periods in columns. High numbers = stickiness; drop-off patterns show where to focus."
+    },
+    {
+      "title": "Compare segments",
+      "description": "Filter or segment by plan, source, or custom properties. See which cohorts retain better and why."
+    },
+    {
+      "title": "No sampling",
+      "description": "Retention is computed over every event. No sampling or estimates-you see real stickiness."
+    },
+    {
+      "title": "Dashboards and sharing",
+      "description": "Add retention charts to dashboards next to funnels and other reports. Share with PMs and founders."
+    }
+  ],
+  "screenshots": [
+    {
+      "src": "/features/feature-retention.webp",
+      "alt": "Retention cohort grid showing stickiness over time",
+      "caption": "Cohort retention at a glance. Rows = cohorts, columns = time periods. See who comes back."
+    },
+    {
+      "src": "/features/feature-retention.webp",
+      "alt": "Choosing initial and return events for retention",
+      "caption": "Pick the start and return events that define retention for your product."
+    }
+  ],
+  "how_it_works": {
+    "title": "How to read a retention chart",
+    "intro": "Retention charts are simple once you know what to look for.",
+    "steps": [
+      {
+        "title": "Pick your initial and return events",
+        "description": "The initial event defines the cohort (e.g. signup_completed). The return event defines “came back” (e.g. session_started or feature_used). Every user who did the initial event in a given period is one cohort."
+      },
+      {
+        "title": "Read the grid",
+        "description": "Rows are cohorts (e.g. “Week of Jan 6”). Columns are time periods after the initial event (e.g. Week 1, Week 2). Each cell is the percentage of that cohort that did the return event in that period. Higher = stickier."
+      },
+      {
+        "title": "Spot patterns",
+        "description": "Look for cohorts that retain well vs. those that drop off fast. Compare segments (e.g. by plan or source) to see which users stick and use that to prioritize product and growth work."
+      }
+    ]
+  },
+  "use_cases": {
+    "title": "How teams use retention",
+    "intro": "PMs and founders use retention to separate signal from noise.",
+    "items": [
+      {
+        "title": "Product managers",
+        "description": "See which features and flows lead to repeat use. Prioritize work that improves retention, not just signups. Compare cohorts to learn what separates sticky users from churned ones."
+      },
+      {
+        "title": "Founders",
+        "description": "Retention is the truth about product-market fit. One number-e.g. week-2 or week-4 retention-often tells you more than top-line growth. Use it in board updates and strategy."
+      },
+      {
+        "title": "Growth and analytics",
+        "description": "Measure impact of onboarding or activation changes on retention. Segment by acquisition source or plan to invest in the channels and segments that retain best."
+      }
+    ]
+  },
+  "related_features": [
+    {
+      "slug": "event-tracking",
+      "title": "Event tracking",
+      "description": "Retention is built on events. Track signups, sessions, and feature use first."
+    },
+    {
+      "slug": "funnels",
+      "title": "Funnels",
+      "description": "See where users drop off before they can retain. Funnels and retention go hand in hand."
+    }
+  ],
+  "faqs": {
+    "title": "Frequently asked questions",
+    "intro": "Common questions about retention analytics with OpenPanel.",
+    "items": [
+      {
+        "question": "What’s the difference between retention and funnel analysis?",
+        "answer": "Funnels answer “where do users drop off in a sequence?” Retention answers “of the users who did X, how many came back to do Y?” Both use the same events; retention focuses on repeat behavior over time, funnels on one-time flows."
+      },
+      {
+        "question": "Can I use any events for retention?",
+        "answer": "Yes. You choose an initial event (e.g. signup_completed, first_purchase) and a return event (e.g. session_started, feature_used). OpenPanel cohorts users by when they did the initial event and shows what percentage did the return event in later periods."
+      },
+      {
+        "question": "How do I know if my retention is good?",
+        "answer": "There’s no universal benchmark-it depends on your product and cohort. What matters is trend and segment comparison: improving over time and understanding which cohorts retain better. Retention gives you the numbers; you decide what “good” is for your product."
+      }
+    ]
+  },
+  "cta": {
+    "label": "See your retention in minutes",
+    "href": "https://dashboard.openpanel.dev/onboarding"
+  }
+}

apps/public/content/features/revenue-tracking.json

@@ -0,0 +1,157 @@
+{
+  "slug": "revenue-tracking",
+  "short_name": "Revenue tracking",
+  "seo": {
+    "title": "Revenue Tracking - Tie Every Dollar to Events",
+    "description": "Track revenue as events, not spreadsheets. Tie every dollar to a user, session, and conversion flow. Privacy-first product revenue analytics with OpenPanel.",
+    "keywords": [
+      "revenue analytics",
+      "track revenue events",
+      "product revenue tracking"
+    ]
+  },
+  "hero": {
+    "heading": "Revenue tracking",
+    "subheading": "Attach a dollar value to any action - purchase, upgrade, renewal - and see exactly how money flows through your product. No spreadsheets, no stitching.",
+    "badges": [
+      "Revenue as events",
+      "Tie revenue to users",
+      "Real-time metrics",
+      "No spreadsheets needed"
+    ]
+  },
+  "definition": {
+    "title": "What is event-based revenue tracking?",
+    "text": "Most teams track revenue in spreadsheets or payment dashboards that live completely separate from product analytics. You know *how much* you made, but not *why*.\n\nEvent-based revenue tracking flips this. Every revenue moment-a purchase, a plan upgrade, a subscription renewal-is captured as a **structured event** with a dollar amount, a user, and a session. That means you can answer questions like:\n\n- **Which signup source drives the most revenue?**\n- **How long after onboarding do users make their first purchase?**\n- **What features do high-LTV customers use that churning ones don't?**\n\nWith OpenPanel, you send a revenue event the same way you send any other event-just include an amount property. From there, revenue flows into **funnels**, **retention charts**, and **user profiles** alongside every other action.\n\nNo CSV exports. No stitching Stripe data to analytics data in a spreadsheet. Revenue becomes a first-class dimension of your product analytics, queryable and filterable like everything else.\n\nBecause OpenPanel is **privacy-first**, revenue data stays in your infrastructure (self-hosted) or in our cloud with no third-party sharing. You get the insights without the data-privacy trade-offs."
+  },
+  "capabilities_section": {
+    "title": "What you can measure",
+    "intro": "From single purchases to recurring subscriptions, every revenue signal becomes a queryable event."
+  },
+  "capabilities": [
+    {
+      "title": "Revenue events with custom amounts",
+      "description": "Attach a monetary value to any event. Track purchases, upgrades, add-ons, and refunds as structured data."
+    },
+    {
+      "title": "Revenue per user and session",
+      "description": "Every revenue event is linked to a user and session, so you can see lifetime value, average order value, and revenue per visit."
+    },
+    {
+      "title": "Revenue in funnels",
+      "description": "Add revenue events as funnel steps. See how much money flows through each stage-and how much you lose at every drop-off."
+    },
+    {
+      "title": "Revenue over time",
+      "description": "Chart daily, weekly, or monthly revenue trends. Break down by plan, source, country, or any event property."
+    },
+    {
+      "title": "Segment by properties",
+      "description": "Filter revenue by plan tier, payment method, campaign source, or any custom property you attach to your events."
+    },
+    {
+      "title": "Real-time ingestion",
+      "description": "Revenue events appear in dashboards within seconds-no overnight processing or batch imports."
+    }
+  ],
+  "screenshots": [
+    {
+      "src": "/features/feature-revenue-1.webp",
+      "alt": "OpenPanel dashboard overview with key metrics",
+      "caption": "See revenue alongside engagement metrics in a single dashboard."
+    },
+    {
+      "src": "/features/feature-revenue-2.webp",
+      "alt": "Funnel analysis showing conversion and revenue flow",
+      "caption": "Trace the path from first visit to purchase and measure revenue at every step."
+    },
+    {
+      "src": "/features/feature-revenue-2.webp",
+      "alt": "Retention chart for revenue cohorts",
+      "caption": "Understand how revenue retention changes across weekly cohorts."
+    }
+  ],
+  "how_it_works": {
+    "title": "How revenue events work",
+    "intro": "Three steps to go from payment callbacks to full revenue analytics.",
+    "steps": [
+      {
+        "title": "Send revenue events from your backend",
+        "description": "When a purchase, upgrade, or renewal happens, fire an event with the amount and any relevant properties (plan, currency, item)."
+      },
+      {
+        "title": "Revenue ties to the user and session",
+        "description": "OpenPanel links the revenue event to the user who triggered it and the session they were in. No manual joins-context is automatic."
+      },
+      {
+        "title": "Analyze in dashboards, funnels, and profiles",
+        "description": "Revenue shows up everywhere: aggregate charts, conversion funnels, user timelines. Filter and break down by any property."
+      }
+    ]
+  },
+  "use_cases": {
+    "title": "Who uses revenue tracking",
+    "intro": "Teams that want to connect product behavior to business outcomes.",
+    "items": [
+      {
+        "title": "SaaS product teams",
+        "description": "Tie MRR and expansion revenue back to feature usage. Understand which product changes move the revenue needle."
+      },
+      {
+        "title": "E-commerce and marketplaces",
+        "description": "Track order value per session, revenue by traffic source, and purchase funnels without a separate BI tool."
+      },
+      {
+        "title": "Growth and marketing",
+        "description": "Measure campaign ROI by linking ad spend to actual revenue events. See which channels produce paying users, not just signups."
+      }
+    ]
+  },
+  "related_features": [
+    {
+      "slug": "event-tracking",
+      "title": "Event tracking",
+      "description": "Revenue events are built on the same event model. Learn how events work in OpenPanel."
+    },
+    {
+      "slug": "funnels",
+      "title": "Funnels",
+      "description": "Add revenue steps to conversion funnels and see where money drops off."
+    },
+    {
+      "slug": "session-tracking",
+      "title": "Session tracking",
+      "description": "Link revenue to the session that produced it-see the full journey from landing page to purchase."
+    }
+  ],
+  "faqs": {
+    "title": "Frequently asked questions",
+    "intro": "Common questions about tracking revenue with OpenPanel.",
+    "items": [
+      {
+        "question": "How do I send a revenue event?",
+        "answer": "Send a regular event (e.g. 'purchase_completed') with a numeric property for the amount. You can include additional properties like currency, plan, or item name. The same SDK or API you use for any other event works for revenue."
+      },
+      {
+        "question": "Can I track recurring subscription revenue?",
+        "answer": "Yes. Fire a revenue event on each renewal or billing cycle. Over time you can chart MRR trends, retention by cohort, and expansion revenue-all from events."
+      },
+      {
+        "question": "Do I need to integrate my payment provider?",
+        "answer": "No direct integration is needed. You send revenue events from your backend whenever a payment is confirmed (e.g. in a Stripe webhook handler). OpenPanel doesn't talk to Stripe-it just receives the event you send."
+      },
+      {
+        "question": "Can I track refunds?",
+        "answer": "Yes. Send a refund event with a negative amount or a separate event name (e.g. 'refund_issued'). You can then subtract refunds from gross revenue in your dashboards."
+      },
+      {
+        "question": "Is revenue data shared with third parties?",
+        "answer": "No. OpenPanel is privacy-first. Self-host to keep revenue data entirely in your infrastructure, or use our cloud where data is never shared with third parties."
+      }
+    ]
+  },
+  "cta": {
+    "label": "Start tracking revenue",
+    "href": "https://dashboard.openpanel.dev/onboarding"
+  }
+}

apps/public/content/features/session-tracking.json

@@ -0,0 +1,147 @@
+{
+  "slug": "session-tracking",
+  "short_name": "Session tracking",
+  "seo": {
+    "title": "Session Tracking Without Replays - Privacy-First",
+    "description": "Understand user sessions from entry to exit-without recordings or privacy risk. See pages visited, events fired, and session duration with privacy-first analytics.",
+    "keywords": [
+      "session tracking analytics",
+      "user session tracking",
+      "session analysis without replay"
+    ]
+  },
+  "hero": {
+    "heading": "What happened in the session",
+    "subheading": "Pages visited, events fired, time spent. No recordings, no privacy risk. You still get the full picture.",
+    "badges": [
+      "No session recordings",
+      "Privacy-first by design",
+      "Entry-to-exit visibility",
+      "Sessions linked to events"
+    ]
+  },
+  "definition": {
+    "title": "What is session tracking?",
+    "text": "A session is the **window of activity** between a user arriving on your site and leaving. It starts with an entry page, includes every page view and event along the way, and ends when the user goes idle or closes the tab.\n\nMost analytics tools either give you **too little** (aggregated page-view counts with no sense of flow) or **too much** (full session recordings that raise privacy concerns and take hours to review). OpenPanel sits in the middle: you get a **structured timeline** of what happened in each session, without recording a single pixel of the user's screen.\n\nFor every session, OpenPanel captures:\n\n- **Entry page and exit page** - where the user started and where they left\n- **Pages visited in order** - the path through your site or app\n- **Events fired** - signups, clicks, feature usage, or any custom event\n- **Session duration** - how long the session lasted\n- **Referrer and UTM parameters** - how the user got there\n- **Device, browser, and location** - context without fingerprinting\n\nThis means you can answer questions like:\n\n- **What pages do users visit before signing up?**\n- **Do users from organic search behave differently than paid traffic?**\n- **How long are sessions for users who convert vs. those who don't?**\n\nUnlike session replay tools (Hotjar, FullStory, LogRocket), there are **no recordings to watch**, **no PII captured on screen**, and **no consent banners** needed for video replay. You get the analytical value of sessions without the privacy overhead.\n\nSessions in OpenPanel connect directly to **events and user profiles**. Every event belongs to a session, and every session belongs to a user. This means funnels, retention, and user timelines all have session context built in."
+  },
+  "capabilities_section": {
+    "title": "What you get with session tracking",
+    "intro": "Structured session data that answers real questions-without the privacy cost of recordings."
+  },
+  "capabilities": [
+    {
+      "title": "Entry and exit pages",
+      "description": "See where users land and where they leave. Identify your strongest entry points and the pages that lose visitors."
+    },
+    {
+      "title": "Page flow per session",
+      "description": "View the ordered sequence of pages a user visited in a session. Understand navigation patterns without watching a recording."
+    },
+    {
+      "title": "Events within a session",
+      "description": "Every event (signup, click, purchase) is tied to a session. See exactly what a user did and in what order."
+    },
+    {
+      "title": "Session duration and engagement",
+      "description": "Measure how long sessions last and how many pages or events they include. Spot high-engagement and bounce sessions."
+    },
+    {
+      "title": "Referrer and UTM attribution",
+      "description": "Know how users arrived-organic search, paid campaign, direct link-and compare session quality across sources."
+    },
+    {
+      "title": "Device and location context",
+      "description": "Capture browser, OS, and approximate location for each session. No fingerprinting-just standard request headers."
+    }
+  ],
+  "screenshots": [
+    {
+      "src": "/features/feature-sessions.webp",
+      "alt": "Session overview showing user sessions with entry pages and duration",
+      "caption": "See session activity at a glance-entry pages, duration, and event counts."
+    },
+    {
+      "src": "/features/feature-sessions-details.webp",
+      "alt": "Session events timeline showing user actions in order",
+      "caption": "Every event tied to its session. Understand user journeys without replay tools."
+    }
+  ],
+  "how_it_works": {
+    "title": "How session tracking works",
+    "intro": "Sessions are created automatically from the events you already send.",
+    "steps": [
+      {
+        "title": "Events create sessions",
+        "description": "When a user triggers their first event (page view, click, etc.), OpenPanel starts a session. No extra tracking code needed-sessions are derived from your events."
+      },
+      {
+        "title": "Activity is grouped automatically",
+        "description": "Subsequent events from the same user are grouped into the active session. If the user goes idle (30 minutes by default), the session ends and a new one begins on the next interaction."
+      },
+      {
+        "title": "Sessions connect to everything",
+        "description": "Each session links to the user profile, the events fired, and the pages visited. This means funnels, retention, and user timelines all include session context."
+      }
+    ]
+  },
+  "use_cases": {
+    "title": "Who uses session tracking",
+    "intro": "Teams that need to understand user journeys without the overhead of session replays.",
+    "items": [
+      {
+        "title": "Product teams",
+        "description": "Understand how users navigate your product. See the page flow and events in a session to identify friction points-without watching hours of recordings."
+      },
+      {
+        "title": "Support and success teams",
+        "description": "When a user reports an issue, pull up their recent sessions to see what pages they visited and what events they triggered. Context without asking \"can you describe what you did?\""
+      },
+      {
+        "title": "Privacy-conscious teams",
+        "description": "Get session-level insights without recording user screens. No PII in screenshots, no video consent banners, no GDPR headaches from replay data."
+      }
+    ]
+  },
+  "related_features": [
+    {
+      "slug": "event-tracking",
+      "title": "Event tracking",
+      "description": "Events are the building blocks of sessions. Track user actions that feed into session timelines."
+    },
+    {
+      "slug": "funnels",
+      "title": "Funnels",
+      "description": "Combine session data with funnel analysis to see where users drop off in multi-step flows."
+    }
+  ],
+  "faqs": {
+    "title": "Frequently asked questions",
+    "intro": "Common questions about session tracking with OpenPanel.",
+    "items": [
+      {
+        "question": "How is this different from session replay tools like Hotjar or FullStory?",
+        "answer": "Session replay tools record a video of the user's screen. OpenPanel doesn't record anything visual-it tracks structured data: which pages were visited, which events were triggered, and how long the session lasted. You get the analytical answers without the privacy cost or the hours spent watching recordings."
+      },
+      {
+        "question": "Do I need to set up session tracking separately?",
+        "answer": "No. Sessions are created automatically from the events and page views you already send. There's no separate session SDK or configuration step."
+      },
+      {
+        "question": "How does OpenPanel define a session?",
+        "answer": "A session starts when a user triggers their first event and ends after 30 minutes of inactivity. If the user returns after the timeout, a new session begins. This is consistent with how most analytics tools define sessions."
+      },
+      {
+        "question": "Can I see individual user sessions?",
+        "answer": "Yes. You can view a user's session history, including the pages they visited and events they triggered in each session. This is available in the user profile view."
+      },
+      {
+        "question": "Does session tracking require cookies?",
+        "answer": "No. OpenPanel can run without cookies. Sessions can be tracked using a lightweight session identifier that doesn't require cookie consent. If you enable first-party cookies, session continuity improves but it's not required."
+      }
+    ]
+  },
+  "cta": {
+    "label": "Start tracking sessions",
+    "href": "https://dashboard.openpanel.dev/onboarding"
+  }
+}

apps/public/content/features/share-and-collaborate.json

@@ -0,0 +1,168 @@
+{
+  "slug": "share-and-collaborate",
+  "short_name": "Share & Collaborate",
+  "seo": {
+    "title": "Share & Collaborate - Unlimited Members",
+    "description": "Invite unlimited team members with org-wide or project-level access. Share full dashboards or individual reports - publicly or behind a password. OpenPanel makes it easy to align everyone on the same data.",
+    "keywords": [
+      "analytics team collaboration",
+      "share dashboards",
+      "analytics access control",
+      "password-protected reports",
+      "unlimited team members analytics",
+      "project-level permissions analytics"
+    ]
+  },
+  "hero": {
+    "heading": "Invite the team. Share the numbers.",
+    "subheading": "Unlimited members, org-wide or project-level access. Share full dashboards or single reports - publicly or behind a password.",
+    "badges": [
+      "Unlimited members",
+      "Org-wide or project-level access",
+      "Share dashboards and reports",
+      "Public or password-protected links"
+    ]
+  },
+  "definition": {
+    "title": "What is share and collaborate?",
+    "text": "Share and collaborate in OpenPanel is how you **get the right data to the right people** without opening the door to everything.\n\n**Unlimited members** - There’s no cap on how many people you can invite. Add your whole team, contractors, or stakeholders and manage them from a single members view.\n\n**Flexible access** - Each member can have:\n\n- **Organization-wide access** - full visibility across all projects, ideal for admins and core team\n- **Fine-grained access** - access only to specific projects you choose, so stakeholders see only what’s relevant\n\n**What you can share** - You’re not limited to \"all or nothing\" views:\n\n- **Complete dashboards** - share an entire dashboard so others see the same layout and reports you use\n- **Individual reports** - share a single report (e.g. one funnel or one retention chart) for focused updates\n\n**How you share** - Every shared dashboard or report can be:\n\n- **Publicly available** - anyone with the link can view it (handy for status pages, exec summaries, or embedded views)\n- **Password-protected** - only people with the password can open the link, so you keep sensitive data under control\n\nInviting is straightforward: add members by email, assign access (org or specific projects), and optionally share dashboards or reports with public or password-protected links. Your team stays aligned on the same numbers without compromising security or clarity."
+  },
+  "capabilities_section": {
+    "title": "What you can do with share and collaborate",
+    "intro": "From inviting your first teammate to sharing a report with a client - everything is built in."
+  },
+  "capabilities": [
+    {
+      "title": "Unlimited members",
+      "description": "Invite as many team members as you need. No per-seat limits - add admins, analysts, and stakeholders and manage them from one place."
+    },
+    {
+      "title": "Organization-wide or project-level access",
+      "description": "Give members access to the entire organization or restrict them to specific projects. Fine-grained control keeps each person seeing only what they need."
+    },
+    {
+      "title": "Share full dashboards",
+      "description": "Share a complete dashboard so others see the same layout and reports. Perfect for weekly reviews, exec summaries, or keeping a team on the same page."
+    },
+    {
+      "title": "Share individual reports",
+      "description": "Share a single report - one funnel, one retention chart, or one breakdown - so you send exactly the view that matters without exposing the rest."
+    },
+    {
+      "title": "Public or password-protected links",
+      "description": "Shared dashboards and reports can be publicly viewable (anyone with the link) or protected with a password for sensitive or internal-only use."
+    },
+    {
+      "title": "Invite and manage in one place",
+      "description": "Invite by email, assign access, and see all members and their permissions in a clear members view. Update access or remove members anytime."
+    }
+  ],
+  "screenshots": [
+    {
+      "src": "/features/feature-members.webp",
+      "alt": "Members list showing team members and their access levels",
+      "caption": "Manage unlimited members and their access - org-wide or per project - from one place."
+    },
+    {
+      "src": "/features/feature-dashboard-share.webp",
+      "alt": "Sharing a dashboard with public or password-protected options",
+      "caption": "Share full dashboards or individual reports. Choose public links or protect them with a password."
+    },
+    {
+      "src": "/features/feature-invite-user.webp",
+      "alt": "Invite a new member by email and set project access",
+      "caption": "Invite new members by email and assign organization or project-level access in a few clicks."
+    }
+  ],
+  "how_it_works": {
+    "title": "How sharing and collaboration works",
+    "intro": "Invite members, set access, then share dashboards or reports as needed.",
+    "steps": [
+      {
+        "title": "Invite members",
+        "description": "Add team members by email from the members area. They receive an invite and can sign in to OpenPanel with the access you’ve assigned."
+      },
+      {
+        "title": "Set access level",
+        "description": "Give each member organization-wide access (all projects) or fine-grained access to specific projects only. You can change this anytime."
+      },
+      {
+        "title": "Share dashboards or reports",
+        "description": "From any dashboard or report, use Share to generate a link. You can share a full dashboard or a single report."
+      },
+      {
+        "title": "Choose public or password-protected",
+        "description": "Make the link public (anyone with the link can view) or set a password so only people who have it can open the shared view."
+      }
+    ]
+  },
+  "use_cases": {
+    "title": "How teams use share and collaborate",
+    "intro": "From internal alignment to client-facing reports - sharing and access control fit many workflows.",
+    "items": [
+      {
+        "title": "Internal team alignment",
+        "description": "Invite product, growth, and support with access to the projects they need. Share a main dashboard so everyone looks at the same KPIs in meetings."
+      },
+      {
+        "title": "Stakeholder and exec updates",
+        "description": "Give execs or stakeholders limited access to specific projects and share a single report or dashboard. No need to give them the full product - just the view that matters."
+      },
+      {
+        "title": "Client and partner reports",
+        "description": "Share a dashboard or report with a client or partner via link. Use a password when the data is sensitive so only authorized people can view it."
+      },
+      {
+        "title": "Public status or metrics pages",
+        "description": "Share a dashboard publicly and embed or link it from your status page, docs, or marketing site so visitors see live metrics without signing in."
+      }
+    ]
+  },
+  "related_features": [
+    {
+      "slug": "data-visualization",
+      "title": "Data visualization",
+      "description": "Build the dashboards and reports you’ll share - charts, breakdowns, and custom views that stay up to date when you share them."
+    },
+    {
+      "slug": "notifications",
+      "title": "Notifications",
+      "description": "Keep the team in the loop with alerts when key events happen. Complements sharing by pushing updates instead of requiring people to open a link."
+    },
+    {
+      "slug": "integrations",
+      "title": "Integrations",
+      "description": "Send data to Slack, Discord, or webhooks. Use integrations for real-time alerts alongside shared dashboards for deeper exploration."
+    }
+  ],
+  "faqs": {
+    "title": "Frequently asked questions",
+    "intro": "Common questions about sharing and collaboration in OpenPanel.",
+    "items": [
+      {
+        "question": "Is there a limit on how many members I can invite?",
+        "answer": "No. You can invite an unlimited number of members. Each can have organization-wide access or access only to specific projects you choose."
+      },
+      {
+        "question": "What’s the difference between org-wide and project-level access?",
+        "answer": "Org-wide access lets a member see and work with all projects in the organization. Project-level access restricts them to only the projects you assign - useful for clients, partners, or teams that only need a subset of your data."
+      },
+      {
+        "question": "Can I share just one report instead of a whole dashboard?",
+        "answer": "Yes. You can share a complete dashboard or a single report (e.g. one funnel or one chart). The shared link shows only what you chose to share."
+      },
+      {
+        "question": "Can shared links be password-protected?",
+        "answer": "Yes. When you create a share link for a dashboard or report, you can leave it public (anyone with the link can view) or set a password so only people with the password can open it."
+      },
+      {
+        "question": "Can I change a member’s access after they’ve joined?",
+        "answer": "Yes. You can update a member’s access (add or remove projects, or switch to org-wide) or remove them from the organization at any time from the members area."
+      }
+    ]
+  },
+  "cta": {
+    "label": "Invite your team and share your first dashboard",
+    "href": "https://dashboard.openpanel.dev/onboarding"
+  }
+}