Open Source Amplitude Alternatives

PostHog gathers the tools a product team would otherwise buy separately, analytics, replays, flags, experiments, surveys and error tracking, into one platform. Because the data lives together, a rage click, a failed query and an exception trace back to the same session instead of being correlated across four vendors.

Instrumentation starts with autocapture or manual events, using SDKs for common frontend, mobile and backend frameworks. An MCP server brings the data into Claude Code, Cursor or any MCP-compatible agent, and the platform can be driven from the web app, a desktop client or your editor.

The suite covers a wide span of product work.

• Analytics: event-based analysis with visualizations or SQL, plus a dashboard for traffic, conversion, web vitals and revenue.
• Session replays: watch real sessions on a website or mobile app to see what a metric actually looked like.
• Flags and experiments: roll features out to selected users or cohorts and measure statistical impact on goal metrics.
• Error tracking and logs: alerts on exceptions, with logs ingested and searched next to product data.
• Data pipelines: filters and transformations on incoming events, then delivery to other tools, a webhook or a warehouse.

The hosted cloud carries a free tier for each tool and is the recommended path. A one-line Docker script deploys a hobby instance on Linux, which scales to roughly one hundred thousand events per month without support or guarantees. The repository is open source apart from its enterprise directory, and a fork purged of proprietary code exists for anyone who needs one.

Matomo is a web analytics platform that you download and install on your own webserver. The install takes about five minutes and ends by handing you a JavaScript tag to paste onto the sites you want to track, after which reports arrive in real time.

It is a PHP and MySQL application, independent of operating system and server. Because it runs on your infrastructure, the data sits in a database you control and comes back out through the analytics API, and the software can be configured to respect the privacy of the people it measures.

Requirements and the shape of the platform are worth checking before installing.

• PHP: version 8.1.0 or greater, with the pdo and pdo_mysql extensions, or MySQLi instead.
• Database: MySQL 8.0 or greater, or MariaDB 10.6 or greater.
• Plugin architecture: features are built as plugins, so you add the ones you want and remove the ones you do not.
• Dashboard: fully customizable, with widgets moved around by drag and drop.
• Tracking capabilities: ecommerce tracking, goals, campaigns and custom variables among the advanced options.

Quality assurance runs on thousands of unit tests plus integration, system, JavaScript and screenshot tests on a continuous integration server, and a bug bounty programme covers security reports. Free support comes from the community forums, and paid on-premise plans exist for teams that need them. More than 1,400,000 websites already run it.

The top one percent of companies spend thousands of hours building experimentation, feature flagging and analytics in house. GrowthBook exists so the other 99 percent get the same platform without paying for expensive third party SaaS or hacking together unmaintained libraries.

It is warehouse native, querying eleven data sources including BigQuery, Snowflake and Databricks rather than keeping its own copy of your events. Metrics are defined in SQL, from simple conversion rates to ratios and quantiles, and 24 SDKs cover React, Python, Kotlin, Swift and more.

The platform pairs the rollout side with the measurement side.

• Targeted flags: support advanced targeting, gradual rollouts and experiments from a single definition.
• Stats engine: runs CUPED, sequential and Bayesian analysis, post-stratification, bandits and SRM checks.
• Analytics suite: builds dashboards from warehouse data and shares them with the team.
• Documentation in place: attaches screenshots, custom meta fields and Markdown throughout the app.
• Webhooks and REST API: drive integrations and custom workflows.
• MCP server: creates features, starts experiments and cleans up stale flags from an agent.

GrowthBook is open core, most of the code under the permissive MIT license with several directories governed by a separate commercial enterprise license. Self-hosting is a clone and a docker compose up, using the prebuilt public image that needs no registry credentials, with the app waiting on port 3000.

Openpanel puts the depth of Mixpanel next to the simplicity of Plausible, an open source web and product analytics platform for teams who want funnels and user profiles without settling for Google Analytics to get them cheaply.

Events land in ClickHouse while Postgres holds the account data, with a Next.js dashboard, a Fastify event API, and Redis, BullMQ and GroupMQ behind the queues. Tracking is cookieless by default and GDPR compliant, and the SDKs cover web, Swift, Kotlin and React Native as well as server-side collection.

The feature set reaches well past counting pageviews.

• Funnels and cohorts: analyze how users move through a flow and group them by behavior.
• User profiles: keep session history per person rather than aggregates alone.
• Session replay: records and replays sessions with privacy controls and no monthly session cap.
• A/B testing: runs variant tests with detailed breakdowns in the same product.
• Revenue tracking: follows purchases, subscriptions and lifetime value beside product events.
• MCP server: exposes 38 hosted tools so Claude, Cursor or any MCP client can answer questions about your users.

Dashboards update live and can be assembled from custom charts, with event and funnel based notifications when something moves, and Google Search Console among the integrations that enrich the data. Self-hosting is documented and deliberately kept simple, while local development needs Docker, Node and pnpm.

Countly measures how people use mobile, web, desktop and connected device applications, then acts on what it finds through engagement features in the same system. Deploying on premises or in a private cloud settles the data ownership, compliance and infrastructure questions a SaaS-only analytics tool leaves open.

The server runs on Node.js with MongoDB behind it, and its architecture is plugin based, so existing features can be extended or changed and new capabilities added without forking. A documented read and write API covers everything the dashboard shows, and data can be sent in from any source.

This repository holds the server side, which carries most of the product.

• Analytics: session, view and event collection with built-in reports and customizable dashboards.
• Crash reporting: errors from iOS, Android, React Native, Flutter, Node.js, Unity, Java and JavaScript.
• Engagement: rich interactive push notifications for iOS and Android plus in-app rating widgets.
• Remote configuration: adjust an application's logic, appearance and behavior without a release.
• Data Manager: plan and manage events and event segmentations before they sprawl.
• Compliance Hub: consent collection and data subject request management.

Installation assumes a fresh Ubuntu, CentOS or RHEL machine with ports 80 and 443 free, and one command installs every dependency; a bundled shell script and Docker images are the alternatives. The code is AGPL-3.0 with a modified section 7. Countly Lite is free for individuals and small teams under a non-commercial license, while Enterprise and the managed Flex offering add the full suite, SLA and direct support.

Built specifically for mobile, desktop, and web applications, Aptabase offers itself as an alternative to Firebase and Google Analytics. It removes the tradeoff where getting usage numbers means adopting an identifier-driven tracking stack and the compliance work that trails behind it.

Instead of using unique identifiers, Aptabase prioritizes user privacy and collects minimal usage data, focusing on monitoring sessions, which is what keeps it compliant with GDPR, CCPA, and PECR. A built-in dashboard covers the essential metrics with no configuration to grasp how an app is being used. The project says it is highly inspired by Plausible, which does the same job for website analytics.

An SDK exists for most places an app gets written.

• Apple platforms: a Swift SDK for iOS and the rest of the Apple ecosystem.
• Android and cross-platform: Kotlin for Android, with React Native and Flutter alongside.
• Desktop shells: Electron and Tauri plugins, plus .NET MAUI and NativeScript.
• Game engines: SDKs for Unreal Engine and Unity Engine.
• Web: a JavaScript SDK for web apps, and a wiki guide for writing your own when a platform is missing.

A managed cloud runs the service for you, with updates and patches handled by the people who wrote it, while self-hosting is free and leaves maintenance to you, documented in a separate repository. The server is AGPLv3, so changes to it must be shared, while the SDKs are MIT and carry no such condition once embedded in an app.

Trench is an event tracking system the team at Frigade built to scale their own real-time pipeline, then released. It handles large event volumes, answers queries in real time, and is cookie-free plus GDPR and PECR compliant, with users able to access, rectify or delete their own data.

Apache Kafka carries ingestion and ClickHouse stores and queries the events. The API follows Segment's Track, Group and Identify calls, so existing instrumentation can point at Trench without being rewritten. A single production-ready Docker image is the deployment unit, and one node processes thousands of events per second.

Working with the data takes a few forms.

• Event ingestion: batched events post to the events endpoint with a public API key in the authorization header.
• Event queries: the same endpoint reads events back filtered by type, using the private key instead.
• Raw SQL: a queries endpoint accepts SQL directly against the events table.
• Webhooks: data connects onward to other destinations.
• Grafana: the demo video builds a basic Google Analytics equivalent by pairing Trench with Grafana.

The code is MIT licensed. Getting started needs only Docker and Docker Compose, with 4 GB of RAM and four CPU cores suggested for production. Cloning the repository and bringing up the dev compose file starts a server with local ClickHouse and Kafka on port 4000. A managed cloud with autoscaling exists for teams who would rather not operate Kafka themselves.

Understanding what people do inside a product usually means running a page view counter next to a separate analytics tool. Vemetric is an open source platform that keeps both views of the same traffic in one dashboard, so website behavior and product behavior are read together.

The platform records custom events alongside ordinary traffic and lets you slice them with filters to isolate the segment worth understanding. Tracking works across several subdomains, so a marketing site and the application behind it report into the same project.

The feature set stays deliberately small.

• Real-time analytics: visits and events appear as they happen rather than after a delay.
• User journeys: behavior tracking follows the path a person takes through the product.
• Custom events: anything the product cares about can be sent and counted next to page traffic.
• Filtering: conditions narrow the data down to the interactions you want to study.
• Subdomain tracking: one project covers a marketing site and the app it leads into.

Vemetric is licensed under AGPLv3, so a derivative that is distributed or offered as a network service has to be released under the same license with its source code available to every user of that service. Self hosting is planned as a Community Edition covering the dashboard and user journeys, but the maintainers call it early and not yet a priority, which leaves the hosted service as the current way in.