PostHog vs Mixpanel vs Amplitude vs Plausible: Product Analytics in 2026

Product analytics has never been more consequential — or more contested. Privacy regulations have tightened, third-party cookies are gone, and the gap between “we track everything” and “we respect users” has become a legitimate product differentiator.

In 2026, four platforms dominate the conversation: PostHog, Mixpanel, Amplitude, and Plausible. Each represents a distinct philosophy about what product analytics should be.

This guide compares them honestly, with concrete pricing, real feature tradeoffs, and a decision framework for different types of teams.

---

Quick Comparison

	PostHog	Mixpanel	Amplitude	Plausible
Pricing model	Event-based free tier	MTU-based	Event-based	Pageview-based
Free tier	1M events/month	20M events/month	10M events/month	None (trial only)
Self-hosting	Yes (open source)	No	No	Yes (open source)
Session recording	Yes	No	No	No
Feature flags	Yes	No	No	No
Privacy-first	Optional	No	No	Yes
GDPR compliant	Yes (self-hosted)	Partial	Partial	Yes

---

PostHog: The All-in-One Open-Source Platform

PostHog arrived with an ambitious premise: replace your entire analytics stack with one open-source platform. In 2026, it’s succeeded more than most expected.

What PostHog Is

PostHog is a product analytics platform that includes:

• Event analytics: funnels, retention, user paths, trends
• Session recording: full session replay with click maps
• Feature flags: A/B testing and gradual rollouts
• Experiments: statistical significance testing
• Surveys: in-app user surveys
• Data warehouse: connect external data sources
• CDP (Customer Data Platform): data pipelines and transformations

This breadth is PostHog’s biggest differentiator. Most teams paying for Mixpanel + Hotjar + LaunchDarkly can consolidate into PostHog.

PostHog Setup

npm install posthog-js

// app/providers.tsx
'use client'
import posthog from 'posthog-js'
import { PostHogProvider } from 'posthog-js/react'
import { useEffect } from 'react'

export function PHProvider({ children }: { children: React.ReactNode }) {
  useEffect(() => {
    posthog.init(process.env.NEXT_PUBLIC_POSTHOG_KEY!, {
      api_host: process.env.NEXT_PUBLIC_POSTHOG_HOST || 'https://us.i.posthog.com',
      person_profiles: 'identified_only',
    })
  }, [])

  return <PostHogProvider client={posthog}>{children}</PostHogProvider>
}

Capturing events:

import { usePostHog } from 'posthog-js/react'

function CheckoutButton() {
  const posthog = usePostHog()

  return (
    <button onClick={() => {
      posthog.capture('checkout_started', {
        plan: 'pro',
        source: 'pricing_page'
      })
    }}>
      Start Checkout
    </button>
  )
}

PostHog’s Strengths

Open source = zero vendor lock-in. You can self-host PostHog on your own infrastructure, own all your data, and never pay per-MAU pricing. The self-hosted version is production-ready and actively maintained.

The consolidation play. One platform for analytics, session recording, feature flags, and experiments eliminates coordination costs between tools. Events you track for analytics automatically work for feature flags and experiments.

Privacy by design. Self-hosted PostHog keeps all data on your infrastructure. The cloud version offers EU hosting, IP masking, and robust GDPR tooling.

Feature flags are first-class. PostHog’s feature flags integrate directly with analytics — you can analyze the impact of any flag on your funnels automatically.

Generous free tier. 1 million events per month on the cloud version, forever free. For early-stage products, this is more than enough.

PostHog’s Weaknesses

Self-hosting complexity. Running PostHog yourself requires meaningful DevOps investment. Kafka, ClickHouse, and Redis need proper configuration and maintenance.

UI polish gaps. PostHog’s interface has improved significantly but still lags behind Amplitude and Mixpanel on visual polish and data exploration ergonomics.

Session recording storage costs. Session replays eat storage. Self-hosted teams need to plan for this; cloud pricing for recordings can add up.

Newer than alternatives. PostHog is younger than Mixpanel and Amplitude. Some enterprise features (like advanced revenue analytics) are less mature.

PostHog Pricing (2026)

• Free: 1M events/month, 5K session recordings, unlimited feature flags
• Pay-as-you-go: ~$0.000225/event beyond free tier, ~$0.005/recording
• Teams: $450/month for higher limits + premium features
• Enterprise: custom pricing, SSO, SLAs

Self-hosting: free forever (infrastructure costs only).

---

Mixpanel: The Product Analytics Veteran

Mixpanel pioneered product analytics and remains the go-to for product managers who grew up on it. In 2026, it’s a mature, reliable platform with deep funnel analysis capabilities.

What Mixpanel Does Well

Mixpanel’s core strength is event-based analytics with excellent UX for PMs:

• Funnels: multi-step conversion analysis with attribution
• Flows: user path analysis (what do users do before converting?)
• Retention: cohort-based retention curves
• Insights: flexible metrics and trend analysis
• Boards: dashboards for sharing insights

Mixpanel Setup

import mixpanel from 'mixpanel-browser'

mixpanel.init(process.env.NEXT_PUBLIC_MIXPANEL_TOKEN!, {
  debug: process.env.NODE_ENV === 'development',
  track_pageview: true,
  persistence: 'localStorage'
})

// Track events
mixpanel.track('Checkout Started', {
  plan: 'pro',
  source: 'pricing_page',
  value: 29
})

// Identify users
mixpanel.identify(user.id)
mixpanel.people.set({
  $email: user.email,
  $name: user.name,
  plan: user.plan
})

Mixpanel’s Strengths

Best-in-class funnel analysis. Mixpanel’s funnel builder is the most intuitive in the market. Product managers can build complex multi-step funnels without SQL.

MTU (Monthly Tracked User) pricing. Unlike event-based pricing, Mixpanel’s MTU model means you’re not penalized for tracking more events per user. Heavy event tracking is economically rational.

Retroactive analysis. Mixpanel stores raw events and lets you build funnels retroactively — you don’t need to predefine your analysis before collecting data.

Data quality tooling. Lexicon (schema management) and Mixpanel’s data governance features help teams maintain event taxonomy at scale.

20M free MTU. The free tier is exceptionally generous for a hosted product.

Mixpanel’s Weaknesses

No session recording. You’ll need a separate tool (Hotjar, LogRocket, etc.) for session replay. This fragmentation is a real cost.

No feature flags or experiments. Mixpanel is analytics only. Growth teams often need a separate tool for A/B testing.

Privacy and GDPR complexity. Mixpanel is US-based SaaS. Sending EU user data to Mixpanel requires careful GDPR analysis. No self-hosting option.

Pricing confusion. MTU vs event pricing sounds simple but has gotchas. Anonymous users tracked before identification count separately.

Limited dashboarding. Mixpanel Boards are functional but not as flexible as Amplitude’s dashboards for executive reporting.

Mixpanel Pricing (2026)

• Free: 20M MTU/month (very generous)
• Growth: $28/month, up to 100K MTU
• Enterprise: custom pricing, advanced governance, SLAs

---

Amplitude: The Enterprise Analytics Platform

Amplitude positions itself as the analytics platform for mature product organizations. It’s feature-rich, expensive, and genuinely powerful for teams that need what it offers.

What Amplitude Does Well

Amplitude’s strength is depth and enterprise scale:

• Behavioral analysis: advanced cohorts, predictive analytics
• Revenue analytics: LTV, subscription metrics
• Experiment analysis: integrated with flagging tools
• Data management: Amplitude CDP and event taxonomy tools
• Collaboration: annotation, governance, team dashboards

Amplitude Setup

import * as amplitude from '@amplitude/analytics-browser'

amplitude.init(process.env.NEXT_PUBLIC_AMPLITUDE_KEY!, {
  defaultTracking: {
    sessions: true,
    pageViews: true,
    formInteractions: true,
    fileDownloads: true,
  },
})

// Track events
amplitude.track('Checkout Started', {
  plan: 'pro',
  source: 'pricing_page',
  revenue: 29
})

// Set user properties
const identifyEvent = new amplitude.Identify()
identifyEvent.set('plan', 'pro')
identifyEvent.set('signup_date', new Date().toISOString())
amplitude.identify(identifyEvent)

Amplitude’s Strengths

Best dashboards in the market. Amplitude’s dashboard capabilities for C-suite reporting are unmatched. Complex metrics, annotations, benchmarks, and beautiful visualizations.

Predictive analytics. Amplitude uses ML to predict user churn, conversion likelihood, and LTV. For mature products with enough data, this is genuinely valuable.

Revenue analytics. Amplitude’s revenue analysis features are the best for subscription businesses — cohort-based LTV, subscription metrics, and revenue forecasting.

Experiment platform. Amplitude Experiment is tightly integrated with analytics, making it easy to analyze experiment results with your full behavioral data.

Data governance at scale. For large organizations managing complex event taxonomies across multiple teams, Amplitude’s governance tools are best-in-class.

Amplitude’s Weaknesses

Expensive. Amplitude’s free tier (10M events) is reasonable, but paid tiers are steep. The “Plus” plan starts at $61/month; meaningful enterprise features require custom pricing.

Complexity. Amplitude’s power comes with complexity. Small teams often find it overwhelming and underutilize the platform.

No session recording or feature flags. Like Mixpanel, Amplitude is analytics-only. You need additional tools for the full product stack.

Pricing opacity. Enterprise pricing requires sales engagement. Budget uncertainty is a real concern for fast-moving startups.

No self-hosting. US-based SaaS only. EU data compliance requires analysis.

Amplitude Pricing (2026)

• Starter: Free, 10M events/month
• Plus: $61/month, 10M events + more features
• Growth: custom pricing
• Enterprise: custom pricing, advanced governance, SSO

---

Plausible: Privacy-First Simple Analytics

Plausible takes a fundamentally different approach: simple, privacy-friendly web analytics that respects users and doesn’t require cookie consent.

What Plausible Is (and Isn’t)

Plausible is not a product analytics tool in the Mixpanel/Amplitude sense. It’s a privacy-first web analytics tool, closer to Google Analytics than PostHog.

What Plausible tracks:

• Pageviews and sessions
• Referral sources (traffic channels)
• Devices, browsers, OS
• Countries and regions
• Custom events (button clicks, form submissions)
• Revenue goals

What Plausible doesn’t track:

• Individual user journeys
• Cohort analysis
• Funnels (beyond simple conversion goals)
• Retention curves
• User identification/profiles

Plausible Setup

Add a script tag — that’s it:

<script defer data-domain="yourdomain.com" src="https://plausible.io/js/script.js"></script>

For Next.js:

// app/layout.tsx
import Script from 'next/script'

export default function RootLayout({ children }) {
  return (
    <html>
      <head>
        <Script
          defer
          data-domain="yourdomain.com"
          src="https://plausible.io/js/script.js"
        />
      </head>
      <body>{children}</body>
    </html>
  )
}

Plausible’s Strengths

GDPR-compliant by design. Plausible doesn’t use cookies. It doesn’t track individuals. No consent banners required. This is a genuine competitive advantage in markets with strict privacy regulation.

Lightweight script. The Plausible script is < 1KB. It won’t slow your site.

Transparent and simple. The dashboard shows what matters — pageviews, referrers, conversions — without overwhelming complexity.

Open source + self-hosting. Plausible Community Edition is MIT-licensed. Self-host on your own infrastructure for zero per-pageview cost.

EU-hosted option. Plausible’s cloud product is hosted in the EU (Germany), addressing data sovereignty concerns.

Plausible’s Weaknesses

Not a product analytics tool. If you need funnels, retention, user journeys, or behavioral cohorts, Plausible doesn’t provide them. You need a separate tool.

No free tier. Plausible doesn’t offer a permanent free tier. There’s a 30-day trial, then paid plans start at $9/month.

Limited event properties. Plausible’s custom events have limited property support compared to PostHog or Mixpanel.

Small team. Plausible is a small, bootstrapped company. Feature velocity is slower than VC-backed alternatives.

Plausible Pricing (2026)

• Trial: 30 days free
• Starter: $9/month, 10K pageviews/month
• Growth: $19/month, 100K pageviews/month
• Business: $59/month, 1M pageviews/month
• Self-hosting: free (Community Edition)

---

Privacy Comparison Deep Dive

Privacy has become a genuine technical and business concern, not just a compliance checkbox.

Concern	PostHog	Mixpanel	Amplitude	Plausible
Cookie consent required?	Optional (cookie-free mode)	Yes	Yes	No
Self-hosting option?	Yes	No	No	Yes
EU data hosting?	Yes (cloud)	Partial	Partial	Yes
CCPA compliant?	Yes	Yes (with DPA)	Yes (with DPA)	Yes
HIPAA available?	Yes (enterprise)	Yes (enterprise)	Yes (enterprise)	N/A
Data deletion API?	Yes	Yes	Yes	Yes

For EU-first products, Plausible (privacy, simplicity) or PostHog (self-hosted, full control) are the strongest choices.

---

Pricing at Scale

For a product with 500K monthly active users and 50M events/month:

Platform	Estimated Cost
PostHog (cloud)	~$2,250/month
PostHog (self-hosted)	~$200-500/month (infrastructure)
Mixpanel	~$3,000-5,000+/month
Amplitude	Custom/enterprise pricing
Plausible	~$19-59/month (if pageview-focused)

Self-hosted PostHog becomes compelling at scale. Plausible is dramatically cheaper if you don’t need deep behavioral analytics.

---

Decision Guide

Choose PostHog if:

• You want to replace multiple tools (analytics + session recording + feature flags)
• Data ownership and self-hosting matter to you
• You’re a developer-led team comfortable with open-source tooling
• GDPR compliance is critical and you want full data control
• You’re early-stage and need generous free limits

Choose Mixpanel if:

• Your product team is Mixpanel-native (PM experience matters)
• Funnel analysis and user journey mapping are core to your work
• MTU pricing aligns with your usage patterns
• You don’t need session recording or feature flags
• You want a stable, proven, PM-friendly interface

Choose Amplitude if:

• You’re a mature product org with data governance needs
• Revenue analytics and predictive modeling matter
• You have a dedicated analytics/data team
• Executive-level dashboards and reporting are important
• Budget isn’t the primary constraint

Choose Plausible if:

• Simple web analytics is all you need
• Privacy compliance is a hard requirement
• You don’t need individual user tracking or behavioral analytics
• You want a lightweight script and simple dashboard
• You’re running a content site, blog, or small web app

---

The Hybrid Stack

Many sophisticated teams use a combination:

Plausible + PostHog: Plausible for public traffic/SEO analytics (no cookies, fast), PostHog for authenticated user product analytics.

PostHog + Amplitude: PostHog for session recording and feature flags, Amplitude for executive reporting and revenue analytics.

Mixpanel + Hotjar: Classic combination for product analytics + session replay (though PostHog now replaces both).

---

Related DevPlaybook Resources

• JSON Formatter — format and inspect analytics event payloads
• UTM Builder — generate UTM parameters for campaign tracking
• Base64 Encoder — decode analytics tokens and IDs

---

Summary

The analytics market has fragmented in a useful way: there’s now a genuine best choice for each team type.

Developer-led teams building products → PostHog. The consolidation of analytics, session recording, feature flags, and experiments into one open-source platform is uniquely valuable.

Product-led growth teams → Mixpanel. Best funnel UX, generous free MTU tier, deep PM expertise built into the product.

Enterprise product organizations → Amplitude. Revenue analytics, governance, and executive dashboards at scale.

Privacy-first or simple analytics needs → Plausible. No cookies, no consent banners, lightweight, and genuinely private.

The wrong choice here isn’t catastrophic — event data can be migrated and tracking implementations changed. But picking a tool that mismatches your team’s needs creates ongoing friction that compounds over time.