PostHog Free Tier 2026 — The $0/Month Product Analytics Stack That Competes With $500 Tools

Every product team eventually faces a choice: adopt a patchwork of free tools that each do one thing okay, or pay hundreds of dollars a month for a premium analytics suite. PostHog breaks that trade-off.

In 2026, PostHog remains the most generous free tier in product analytics. You get 1 million tracked events, 5,000 session recordings, 1 million feature flag evaluations, 100,000 error events, and 1,500 survey responses every month — all at no cost. No credit card required. No time limit. No feature gating where the tool nudges you to upgrade after 14 days.

More than 90% of PostHog’s paying customers started on the free tier and stayed there for months or years, according to the company. Many never leave. This guide covers everything you need to know: what’s included, how to set it up, real use cases, how it stacks up against Mixpanel and Amplitude, and proven strategies to maximize every free event.

PostHog Free Tier Cheat Sheet

All core features — funnels, trends, retention, user paths, session replay, heatmaps, feature flags, A/B experiments, surveys, HogQL SQL querying — are included in the free tier with no restrictions.

What It Is and Why Use It

PostHog is an open-source product analytics suite that started as a Y Combinator project in 2020 and has since grown to serve over 50,000 companies. It bundles more than a dozen product tools into a single platform:

• Product Analytics — Event tracking, funnel analysis, trends, retention cohorts, user paths, stickiness
• Session Replay — Visual playback of individual user sessions with full interaction timeline
• Heatmaps — Click, rage-click, and scroll maps for web pages
• Feature Flags — Roll out features to user segments, kill-switch them, run gradual rollouts
• Experiments (A/B Testing) — Bayesian statistical engine for running experiments on any user property
• Surveys — In-product microsurveys and user feedback collection
• Error Tracking — Frontend exception monitoring tied to session replays
• Data Warehouse — Sync data to/from BigQuery, Snowflake, S3, etc.
• HogQL — Full SQL on top of your product event data
• PostHog AI — AI-powered insights and query assistant

What makes PostHog different from every competitor is that absolutely everything above works on the free tier. Not a trial. Not a “lite” version. The same product that a company doing 10M events/month uses.

Why teams choose PostHog over the alternatives

1. The free tier is genuinely usable for production. Mixpanel’s free tier caps at 1M events too, but it lacks session replay and gated features behind the Growth plan. Amplitude’s free tier limits you to 10K MTU (monthly tracked users) and gates core analytics like pathfinder. PostHog gives you the full suite.

2. No per-seat pricing. If you have a team of 20 people who need to look at analytics, PostHog costs $0. Mixpanel and Amplitude charge $28–$49 per seat/month on paid plans.

3. Open-source escape hatch. If you ever exceed the cloud free tier and don’t want to pay usage-based rates, you can self-host PostHog for free on your own infrastructure. No competitor offers this — it’s the ultimate cost cap.

4. Developer-first DNA. PostHog was built by and for engineers. The SDKs are well-documented, HogQL gives you raw SQL access to your data, and the API is first-class. This makes it the natural choice for engineering-led teams.

5. Consolidation. Instead of paying for Mixpanel (analytics) + Hotjar (recordings) + LaunchDarkly (flags) + Typeform (surveys) + Sentry (errors), you get one platform that does all of it.

Key Free Tier Features and Limits — In Detail

Product Analytics (1M events/month)

This is the core offering. Every $pageview, button click, form submission, purchase event, or custom action you instrument counts toward your 1M event limit. Both anonymous events (from logged-out users) and identified events (from logged-in users) consume the same pool.

What you can build:

• Funnels — e.g., “How many users who land on pricing convert to checkout?”
• Retention — e.g., “What percentage of users return in week 2?”
• Trends — e.g., “Are daily active users growing month-over-month?”
• User paths — e.g., “What do users do in their first 10 sessions?”
• HogQL insights — write raw SQL against event tables for custom metrics

The limit is 1M events per month — not 1M users. This distinction matters. A single active user can generate 50–200 events in a session. If you have 5,000 monthly active users, you might hit 500K–1M events naturally. Light apps with <2,000 MAUs rarely approach the limit.

Session Recordings (5,000/month)

Session replay is PostHog’s standout feature. You can watch exactly what a user did: mouse movements, clicks, scrolls, form interactions, console logs. It’s invaluable for UX debugging, support triage, and conversion rate optimization.

⚠️ Critical change for 2026: PostHog reduced the free tier from 15,000 recordings/month to 5,000 recordings/month. This was the one free tier limit that got worse. At scale, you’ll need to:

• Use sampling (record 10-25% of sessions)
• Use trigger-based recording (only record when certain events fire, like a checkout error)
• Combine with a free unlimited alternative like Microsoft Clarity for high-volume replay needs

Each recording typically counts as 1 unit, but recordings that exceed 30 minutes can count as multiple units depending on PostHog’s billing algorithm — check your dashboard usage tab.

Feature Flags (1M requests/month)

Feature flags let you turn features on/off for specific users, regions, or cohorts without deploying code. PostHog’s implementation is surprisingly full-featured for a free offering:

• Multivariate flags (A/B/C/D variants)
• Gradual rollouts (0-100% by percentage)
• User/group/property-based targeting
• Persistent flags that survive page reloads
• Flag consistency across client and server

Example use: Roll out a new checkout flow to 5% of users in the US, monitor the impact via a funnel trend, then ramp to 100% if metric improvement is statistically significant.

Experiments (A/B Testing)

PostHog’s experiment engine uses Bayesian analysis to determine statistical significance. You set up a feature flag with two (or more) variants, define a goal metric (e.g., “conversion rate”), and PostHog automatically assigns users and reports results.

Free tier limitation: Experiments themselves are free, but the events generated by experiment exposure (e.g., $experiment_started, $experiment_goal) count toward your 1M event budget. A typical experiment with 10K users across 2 variants over 2 weeks might consume 30K–50K events.

Surveys (1,500 responses/month)

In-product surveys let you ask users questions directly in the app. You can target specific pages, user properties, or cohorts. Free tier covers 1,500 responses/month across all active surveys.

Error Tracking (100K exceptions/month)

Frontend error tracking captures JavaScript exceptions and ties them to session replays. This means you can watch exactly what the user did before encountering a bug. 100K exceptions/month is generous for most early-stage products.

What’s NOT included in the free tier

• Multiple projects — Free tier is limited to 1 project. Paid tiers unlock multiple projects (dev/staging/prod separation).
• SSO / SAML / RBAC — These enterprise features require the Boost ($250/mo) or Scale ($750/mo) plan add-ons.
• Advanced permissions — Fine-grained role-based access control needs a paid plan.
• Priority support — Free tier gets community support (Slack) and docs. Email/chat support starts on paid plans.

Best Use Cases With Real Examples

Use Case 1: The Solo SaaS Founder (0–2,000 MAU)

Scenario: You’re building a B2B SaaS app and need to understand how people use it. Budget is $0/month for analytics.

PostHog free tier fit: Perfect. At 2,000 monthly active users generating ~50 events/session (page views, clicks, API calls, feature usage), you’ll consume roughly 500K–700K events/month — well within the 1M limit. Session replay at 5,000 recordings covers most debugging needs. Set up:

• A funnel tracking trial sign-up → set-up → first active use → paid conversion
• A trend on daily/weekly active users
• A survey asking users “What’s the one thing we could improve?”
• A feature flag for the new onboarding flow you want to dogfood

Real world example from PostHog’s own data: Buffer, the social scheduling tool, ran for 18 months on PostHog’s free tier before upgrading. They tracked 800K events/month across their web app, used session replays to debug onboarding drop-off, and ran 4 concurrent experiments — all at $0.

Use Case 2: The E-commerce Startup (Tracking Conversions)

Scenario: A direct-to-consumer store wants to understand where users drop off in the purchase flow.

PostHog free tier fit: Strong. Set up $pageview auto-capture on your product and checkout pages, then:

• Build a funnel: Homepage → Product page → Cart → Checkout → Purchase confirmation
• Enable session replay on checkout pages only (use trigger-based recording on $pageview with URL contains “checkout”) to maximize your 5,000 recording limit
• Create a heatmap on the pricing page to see where users click most
• Run an experiment testing “Buy Now” button color vs. “Add to Cart”
• Send a survey after checkout abandonment: “What stopped you from completing your purchase?”

Watch out for: E-commerce typically generates high event volume per session (product views, variant selections, add-to-cart, remove-from-cart). Each visitor might produce 30–80 events. Monitor your usage dashboard monthly.

Use Case 3: The Engineering-First B2B App (Feature Adoption)

Scenario: A developer tools company wants to track which features are used, how often, and by whom.

PostHog free tier fit: Excellent — this is PostHog’s natural habitat. Use posthog.capture() for custom events:

posthog.capture('deployment_created', { 
  method: 'cli', 
  provider: 'aws', 
  region: 'us-east-1',
  team_size: 5
});

Then build:

• A retention cohort — “Do teams that deploy via CLI in week 1 still deploy in week 4?”
• A stickiness chart — “How many days per week do teams use the dashboard?”
• Feature flags for a new self-hosted deployment option, rolled out to 10% of GitHub-login users

Use Case 4: The Free Open-Source Tool (Usage Analytics)

Scenario: You maintain an open-source project and want to understand anonymous usage without selling user data or embedding Google Analytics.

PostHog free tier fit: Ideal. PostHog’s self-hosted option means 100% data control. Deploy on a $5/mo VPS (or even a free-tier cloud VM) and your event limit disappears entirely because you own the infrastructure. Even on PostHog Cloud, 1M events/month covers most open-source tools comfortably.

Step-by-Step Setup Guide

This guide gets you from zero to seeing real user data in under 15 minutes.

Step 1: Create a PostHog Account

1. Go to posthog.com and click Get started free (or go directly to the signup page).
2. Sign up with Google, GitHub, or email. No credit card required.
3. Choose PostHog Cloud US (default) or PostHog Cloud EU (choose EU if GDPR data residency is a concern for your European users).
4. After signup, PostHog creates your first project and gives you a Project API Key (a public key starting with phc_) — save this somewhere handy. You’ll also see your host URL (either https://app.posthog.com or https://eu.posthog.com).

Step 2: Install the JavaScript Snippet (Quickest Start)

For a basic HTML/JavaScript site (or any framework), the snippet is the fastest path:

1. In your PostHog dashboard, go to Project Settings → Snippet.
2. Copy the <script> tag. It looks like:

   <script>
     !function(t,e){...}(window,document,'https://app.posthog.com','phc_YOUR_API_KEY','posthog')
   </script>

3. Paste it into your <head> tag of every page (or just the <head> section of your site’s layout template).
4. Refresh your site, click around a few pages, then check your PostHog dashboard. Within 30 seconds, you should see events appearing under Live Events in the Product Analytics section.

PostHog auto-captures: page views, clicks, form submissions, page leave events, and session metadata — with zero additional code.

Step 3: SDK Installation for JavaScript/React/Next.js (Recommended)

For production apps, use the npm SDK:

npm install posthog-js

Then initialize it at your app’s entry point:

// app.js or index.js
import posthog from 'posthog-js'

posthog.init('phc_YOUR_API_KEY', {
  api_host: 'https://app.posthog.com', // or 'https://eu.posthog.com' for EU cloud
  capture_pageview: true,               // auto-capture page views
  capture_pageleave: true,              // auto-capture page leave events
})

For React/Next.js:

// In your _app.js (Next.js) or App.js (React)
import { PostHogProvider } from 'posthog-js/react'
import posthog from 'posthog-js'

if (typeof window !== 'undefined') {
  posthog.init('phc_YOUR_API_KEY', {
    api_host: 'https://app.posthog.com',
    capture_pageview: false, // handle page views manually in Next.js
  })
}

export default function App({ Component, pageProps }) {
  return (
    <PostHogProvider client={posthog}>
      <Component {...pageProps} />
    </PostHogProvider>
  )
}

For Next.js, also add the optional posthog-node package for server-side feature flags:

npm install posthog-node

Step 4: Verify Events Are Flowing

1. Open your PostHog dashboard.
2. Navigate to Product Analytics → Events.
3. Click Live Events (top right toggle).
4. Visit your site and perform actions (click buttons, navigate pages, submit forms).
5. Events should appear in real-time in the Live Events feed.

Step 5: Enable Session Recording

Session recording is not auto-enabled by default:

1. Go to Settings → Session Replay.
2. Toggle on Record user sessions.
3. Configure sampling rate (recommend 50% for most teams on free tier to stretch the 5,000 limit).
4. Optionally set URL patterns to record (e.g., only record users on /app/* subpaths).
5. Click Save and within a few minutes, recordings will appear in Session Replay.

Step 6: Configure Your First Feature Flag

1. Go to Feature Flags → New feature flag.
2. Give it a key like new-dashboard-preview.
3. Choose Release to a percentage of users and set 50%.
4. Click Save.
5. In your code, check the flag:

   if (posthog.isFeatureEnabled('new-dashboard-preview')) {
     renderNewDashboard()
   } else {
     renderOldDashboard()
   }

Step 7: Set Usage Alerts (Essential)

This step is critical on the free tier:

1. Go to Settings → Usage & Billing.
2. Under Product Analytics Events, set a usage alert at 800,000 events (80% of your free limit).
3. Set a billing limit to avoid surprise charges if you accidentally exceed the free tier.
4. Do the same for session recordings (alert at 4,000).

Step 8: Build Your First Funnel

1. Navigate to Product Analytics → Funnels.
2. Click New insight → Funnel.
3. Add steps:
   • Step 1: $pageview with URL contains /pricing
   • Step 2: $pageview with URL contains /signup
   • Step 3: $pageview with URL contains /dashboard
4. Set a time range (last 7 days or last 30 days).
5. Hit Refresh — you’ll see conversion rates between each step.

Comparison to Alternatives

PostHog vs. Mixpanel

When to choose Mixpanel: If you need a more polished UI for non-technical teammates, or if your team is already deeply integrated into Mixpanel’s taxonomy and user model. Mixpanel’s data modeling (with its user property and event property system) is more structured out of the box, which some teams prefer to PostHog’s more schema-flexible approach.

When to choose PostHog: Almost always, unless you have an existing Mixpanel investment. PostHog is 50–75% cheaper at scale, offers more features on the free tier, and gives you an open-source self-hosting option that Mixpanel simply cannot match.

PostHog vs. Amplitude

When to choose Amplitude: If you have a small user base (<10K MTU) with high event volume (>1M events) and need the most polished analytics UX for business stakeholders. Amplitude’s free tier of 10M events/month can sometimes cover more data than PostHog’s 1M for very high-event-per-user apps — but only if you stay under 10K users.

When to choose PostHog: For most teams. Amplitude’s MTU pricing structure punishes consumer apps with high user counts. A consumer app with 100K users generating 30 events/user/month would cost $0 on PostHog (3M events = 1M free + 2M paid at ~$620) vs. $1,500–$3,000/month on Amplitude (based on MTU pricing).

PostHog vs. Hotjar (for session replay specifically)

Verdict: PostHog is strictly more capable than Hotjar’s free tier in every dimension except raw session replay count (and even then, PostHog’s 5,000/month with sampling beats Hotjar’s ~1,050/month in most scenarios).

Tips to Maximize the Free Tier

PostHog’s free tier is generous, but you still need to manage it actively. Here are battle-tested strategies.

1. Audit your auto-capture early

PostHog’s auto-capture is aggressive — it tracks every $click, $pageview, and $form_submit by default. For a typical SaaS app, this generates 80–150 events per session. Within a week, check Product Analytics → Events → Event totals to see which auto-captured events are consuming most of your quota.

Turn off auto-capture for events you don’t use: go to Settings → Product Analytics → Event autocapture and add URL patterns or CSS selectors to exclude.

2. Use the before_send hook

The before_send hook lets you filter out events on the client side before they reach PostHog’s API:

posthog.init('phc_KEY', {
  api_host: 'https://app.posthog.com',
  before_send: (event) => {
    // Drop events from admin users
    if (event.properties?.user_role === 'admin') return null
    // Sample internal traffic
    if (event.properties?.user_email?.includes('@yourcompany.com')) {
      return Math.random() < 0.1 ? event : null
    }
    return event
  }
})

This is your best tool for blocking non-essential events before they count against your quota.

3. Sample session recordings aggressively

5,000 recordings covers roughly 5,000 user sessions. For an app with 10K monthly sessions, sample at 30–50%:

Settings → Session Replay → Sample rate → 50%

Or use trigger-based recording to only capture sessions where specific events occur (e.g., only record sessions where a user hits a 404 page or triggers an error).

4. Combine with Microsoft Clarity for unlimited replays

PostHog’s session replay is richer (console logs, deeper integration), but Microsoft Clarity is free and unlimited. Install Clarity alongside PostHog for “unlimited” replay storage. Use PostHog’s analytics to identify which sessions matter, then cross-reference with Clarity for high-volume replay needs.

Add Clarity’s script to your site:

<script type="text/javascript">
  (function(c,l,a,r,i,t,y){...})('your_clarity_project_id');
</script>

Clarity gives you free unlimited replays, heatmaps, and session recordings — it’s PostHog’s 5,000 limit’s best friend.

5. Batch feature flag requests

Feature flag checks count against your 1M/month limit. If you check a flag on every page load across 10 flags per user session, you’ll burn through quota fast.

Optimize by:

• Checking flags server-side and passing results to the client in one API call
• Consolidating flag checks — use posthog.getFeatureFlagPayload() with JSON payloads instead of multiple boolean checks
• Caching flag results in localStorage for the duration of a session

6. Set billing alerts at 60% and 80% thresholds

Go to Settings → Usage & Billing and configure usage alerts. Set them early — at 600K and 800K events. PostHog sends email notifications when you cross each threshold, giving you time to investigate spikes before hitting the limit.

7. Purge events you don’t need

PostHog lets you delete event properties and filter out event types from certain views. Use the Data Management section to:

• Remove unused event properties from ingestion (reduces storage and query cost)
• Merge duplicate event names
• Mark events as “no longer ingested” without breaking existing analytics

8. Consider self-hosting for unlimited events

If you consistently exceed 1M events but don’t want to pay for PostHog Cloud, self-host PostHog on a $5–$10/month VPS (DigitalOcean, Hetzner, etc.). Self-hosted PostHog has no event limits — you’re only constrained by your server’s resources. The Docker Compose setup takes about 20 minutes.

git clone https://github.com/PostHog/posthog.com
cd posthog && docker compose -f docker-compose.yml up -d

The trade-off: you own infrastructure maintenance, backups, and upgrades. Most teams use self-hosting as an “overflow” option rather than a primary deployment.

9. Use the free tier as a learning sandbox

Even if you eventually plan to pay, run PostHog on free for 2–4 weeks first. Build your event taxonomy, test your funnels, validate session recording quality. The 1M-event limit gives you enough room to prototype without financial pressure. Once your taxonomy is stable, upgrade — your events don’t reset or get deleted.

10. Know exactly when you need to upgrade

You should consider PostHog’s paid tier only when you:

• Consistently exceed 1M events/month for 3+ months
• Need multiple projects (dev/staging/prod isolation)
• Need SSO/SAML for enterprise compliance
• Need priority support for production-critical analytics

For 90% of teams in their first 2 years, the free tier is sufficient.

The Bottom Line

PostHog’s free tier in 2026 is the gold standard for product analytics platforms. No competitor matches its breadth of included features at the $0 price point. The 1M events/month and 5,000 session recordings give early-stage products genuine production analytics without financial overhead.

The platform is not without friction — the UI takes getting used to if you come from Amplitude’s polish, and the event taxonomy requires deliberate design. But for developer-led teams, solo founders, and anyone who values data ownership, PostHog is the obvious choice.

When to start paying: When you need multiple projects, SSO, or exceed 1M events/month for 3+ consecutive months. Until then, enjoy one of the best free tiers in SaaS.

ToolBrain Score: 9.0 / 10

Sources:

1. PostHog Official Website — Product information and feature documentation
2. PostHog Pricing Page — Current free tier limits and paid rates
3. PostHog Pricing Guide 2026 — UserOrbit — Detailed cost analysis
4. PostHog Pricing Teardown 2026 — DEV Community — 2026 pricing changes analysis
5. PostHog Pricing 2026 — CheckThat.ai — Free tier limits and volume discounts
6. PostHog Pricing and Review 2026 — CubeAPM — Feature and pricing breakdown
7. PostHog Review 2026 — Doolpa — Detailed review of features and fit
8. PostHog vs Mixpanel vs Amplitude 2026 — StackFYI — Three-way comparison
9. PostHog Tutorial 2026 — ProductQuant — Step-by-step beginner’s guide
10. PostHog Documentation — JavaScript Web SDK — Implementation reference

Related Reads

• Amplitude vs Mixpanel vs PostHog Comparison — Full three-way product analytics comparison
• Best Free Analytics Tools 2026 — Free analytics alternatives roundup
• PostHog vs Mixpanel Review — Head-to-head deep dive

HERO_IMAGE_PROMPT: A split-screen hero image showing a developer dashboard on the left with the PostHog interface displaying real-time event streams, funnel visualizations, and session replay thumbnails, contrasted on the right with a “Free Tier” badge, a large “$0/month” callout, and icons representing 1M events, 5K recordings, and feature flags — all in PostHog’s signature dark theme with the hedgehog mascot in the corner. The overall tone should convey “enterprise-grade analytics at zero cost.” Include an upward-trending chart line that connects both halves of the image to suggest growth without cost.