Aanchal Parmar
Product Marketing Manager, Flexprice
PostHog is an all-in-one product analytics and experimentation platform built for engineering-led teams. It combines product analytics, session replay, feature flags, surveys, data warehouse syncing, and error tracking, into a single stack.
Instead of putting together separate tools for tracking, testing, and understanding user behavior, PostHog lets you run the entire product analytics workflow in one place.
Its pricing model follows a consistent pattern across every product: a free monthly quota that resets each month, followed by usage-based charges once you exceed that quota. Each product is metered independently, so you only pay for the modules you actively use.
The Core structure of PostHog’s pricing
PostHog’s pricing is built to let teams start small, scale gradually, and pay only for the products and volumes they actually use. The framework applies consistently across all modules, but the way you experience costs depends heavily on your usage patterns.
1. Free monthly quota for each product
Every module, Analytics, Session Replay, Feature Flags (and Experiments, billed together), Surveys, Data Warehouse, Error Tracking, comes with its own free monthly allowance.
These quotas reset automatically on the first of each month. This setup allows you to experiment with multiple products without instantly committing to paid usage.
Example:
Your first 1M analytics events, 5k replay recordings, and 1M feature flag requests in a month are all free, regardless of whether you’re paying for other modules.
If you only enable a product for occasional testing (e.g., run a few surveys), you might never cross the free limit.
2. Usage-based billing after the free tier
Once you pass a product’s free quota, charges kick in for every additional unit consumed that month. PostHog uses tiered, step-down rates, meaning the per-unit price decreases as you move into higher usage brackets.
Example:
If you send 12M analytics events in a month:
1M events are free
The next 1M are billed at $0.0000500 each = $50.00
The remaining 10M are billed at $0.0000343 each = $343.00
Total: $393.00 for analytics
The same pattern applies to other products, just with different unit types (recordings, requests, responses, rows, exceptions) and pricing ladders.
3. No per-seat fees
Unlike tools that charge for every team member or tracked user, PostHog includes unlimited seats and tracked users on all plans. This encourages company-wide adoption without the hidden cost of “seat creep” as teams grow.
Example:
A 5-person startup and a 50-person product org will pay the same for 2M analytics events, the bill depends only on events, not headcount.
4. Per-product billing limits
You can set a hard monthly spend cap for each product. Once you hit the cap, PostHog will stop processing usage for that product until the next month, preventing runaway costs.
Example:
You set a $200/month limit for Session Replay.
If your volume crosses that limit halfway through the month, recordings stop until the next cycle, while other products (like Analytics or Surveys) continue unaffected.
What you get for free
Every PostHog product comes with a fixed monthly free quota that resets at the start of each billing cycle. These allowances are the same whether you’re on the Free plan or already paying for other products, paid usage in one product doesn’t affect your free quotas in others.
Free monthly allowances by product:
Analytics: 1,000,000 events
Session Replay: 5,000 recordings
Feature Flags (and Experiments): 1,000,000 requests
Surveys: 1,500 responses
Data Warehouse: 1,000,000 rows synced
Error Tracking: 100,000 exceptions
Usage-based tiers by product
Once you pass a product’s free monthly quota, PostHog charges per unit consumed, with step-down pricing, the more you use, the lower the per-unit cost at higher volumes. Each product has its own meter, rates, and volume thresholds.
1. Analytics (per event)
1–2M: $0.0000500
2–15M: $0.0000343
15–50M: $0.0000295
50–100M: $0.0000218
100–250M: $0.0000150
250M+: $0.0000090
Example: 12M events in a month
First 1M: free
Next 1M @ $0.0000500 = $50.00
Remaining 10M @ $0.0000343 = $343.00
Total: $393.00
2. Session replay (per recording)
5k–15k: $0.0050
15k–50k: $0.0035
50k–150k: $0.0020
150k–500k: $0.0017
500k+: $0.0015
Example: 20k replays in a month
First 5k: free
Next 10k @ $0.0050 = $50.00
Remaining 5k @ $0.0035 = $17.50
Total: $67.50
3. Feature flags and experiments (per request)
1–2M: $0.000100
2–10M: $0.000045
10–50M: $0.000025
50M+: $0.000010
Example: 3M requests in a month
First 1M: free
Next 1M @ $0.000100 = $100.00
Remaining 1M @ $0.000045 = $45.00
Total: $145.00
4. Surveys (per response)
1.5k–2k: $0.100
2k–10k: $0.035
10k–20k: $0.015
20k+: $0.010
Example: 2,500 responses in a month
First 1,500: free
Next 500 @ $0.100 = $50.00
Remaining 500 @ $0.035 = $17.50
Total: $67.50
5. Data warehouse (per row synced)
1–10M: $0.000015
10–100M: $0.000010
100M+: $0.000008
Example: 8M rows synced in a month
First 1M: free
Remaining 7M @ $0.000015 = $105.00
6. Error tracking (per exception)
100k–325k: $0.000370
325k–10M: $0.000140
10M+: $0.000115
Example: 200k exceptions in a month
First 100k: free
Remaining 100k @ $0.000370 = $37.00
Takeaway: The largest cost drivers for most teams are Analytics events and Session Replays, while Surveys, Feature Flags, and Data Warehouse rows often stay manageable unless heavily scaled.
Feature gating and bundling logic
PostHog’s pricing is structured to avoid penalizing teams for using interconnected features. Instead of billing every action separately, it bundles related products and ensures you aren’t charged twice for the same underlying activity.
No double-charging for dependent usage
Some features naturally trigger multiple actions under the hood. For example, a feature flag evaluation might also generate an analytics event. In PostHog’s model:
You’re only billed for the flag request in this case, not the associated event.
This prevents inflated bills from “invisible” usage created by dependent features.
Why it matters: Without this rule, teams could be paying twice for the same user interaction, once as a request, and again as an event. This is common in platforms that meter everything separately without relationship logic.
Experiments bundled under Feature Flags
Experiments in PostHog are powered by feature flags. Because of this dependency, there is no separate meter for Experiments, usage is counted and billed entirely under Feature Flags’ request quotas.
If you run an experiment that evaluates 500k users, those requests consume 500k from your Feature Flag quota.
You won’t see a separate Experiments line item on your bill.
Impact on cost control
Bundling and no-double-charge rules make it easier to forecast costs:
You only have to monitor a single meter for certain workflows (e.g., flags + experiments).
You can model the effect of launching new experiments by estimating the extra Feature Flag requests it will generate, without worrying about hidden secondary charges.
Example: If your team runs three concurrent experiments targeting the same user cohort, those evaluations will still only show up as Feature Flag requests, not as duplicate Analytics events.
Platform add-ons and data retention
Beyond metered product usage, PostHog offers platform-level add-ons and enforces data retention windows that vary by plan. These factors can affect your bill even if your core product usage is steady.
Platform add-ons (monthly cost)
Boost: $250/month
Scale: $750/month
Enterprise: $2,000/month
These are optional, platform-wide upgrades that can include benefits such as higher API throughput, dedicated support SLAs, or performance boosts across all products. They are not tied to a specific product’s usage meter.
Example:
If you’re on paid Analytics and Replay tiers but need faster ingestion speeds during a product launch, adding the Boost package will affect all products for that month without altering your usage tier calculations.
Data retention by product (Cloud)
Paid plans:
Analytics events & user data: 7 years
Session Replay recordings: 3 months
Error Tracking: Same as analytics events (7 years)
Free plan:
Analytics events & user data: 1 year
Session Replay recordings: 3 months
On self-hosted ClickHouse instances, session replay retention defaults to 1 month unless you extend it manually.
Cold storage: Older data may be moved to slower storage tiers, which can impact query performance. For high-volume teams, the practical effect is that queries against historical data might take seconds instead of milliseconds.
Why retention matters for cost and performance
Retention doesn’t directly add line-item charges, but it influences your infrastructure footprint and how you query data:
Longer retention = more historical data to query, which can slow analytics performance without additional compute.
If you need more than the default retention (e.g., for compliance reasons), you may need to negotiate an enterprise contract.
Example:
A compliance-heavy fintech might require 10-year event storage. While PostHog offers 7 years on paid plans, extending beyond that would likely push you into a custom enterprise agreement with a higher monthly commitment.
Controlling and forecasting your bill
PostHog’s usage-based model gives you control over what you pay, but only if you actively manage it. Without monitoring, it’s easy to overshoot quotas, especially with high-volume products like Analytics and Session Replay.
1. Set per-product billing caps
Every product in PostHog allows you to define a hard monthly spend limit. When you hit the cap, PostHog stops processing that product’s usage until the next cycle.
Example: If you set a $200 cap for Session Replay and reach it by day 20, recordings stop, but Analytics and other products continue unaffected.
2. Filter and sample before ingestion
You can filter events, target session replays, and restrict surveys before they’re ingested—avoiding unnecessary charges.
Example:
Only capture replays from error-prone flows or specific URLs.
Track fewer “noise” events like minor UI interactions.
3. Forecast usage with tier ladders
Use your current month’s numbers to predict next month’s bill. Since pricing tiers are fixed, you can estimate cost increases if usage grows.
Example:
If you’re at 9M analytics events and expect a 20% growth:
New volume = ~10.8M events
First 1M = free
Next 1M @ $0.0000500 = $50.00
Remaining 8.8M @ $0.0000343 = $301.84
Forecasted total: ~$351.84
4. Review usage patterns weekly
Don’t wait for the end-of-month bill. Weekly checks help spot anomalies like sudden replay spikes or unexpected flag requests
5. Revisit retention needs
If 7-year retention for Analytics isn’t necessary, you might store data externally after a shorter period to keep queries fast and storage lean (applies more to self-hosted setups).
Bottom line: Controlling spend in PostHog isn’t about using fewer features—it’s about measuring what you truly need and applying the right caps, filters, and sampling rules before the meter runs.
How can you replicate PostHog's pricing with Flexprice
PostHog's pricing model is genuinely one of the more complex ones in the SaaS world. Multiple independent meters, step-down volume tiers, free quotas per product, bundling rules that prevent double-charging, per-product spend caps, and platform-wide add-ons all running in parallel. Rebuilding something like this from scratch on a generic billing system would take weeks of engineering time and constant maintenance.
Flexprice handles this class of pricing natively. Through its MCP server, you describe your pricing model in plain language, and Flexprice translates that into a working billing configuration without touching infrastructure code. Want five independent usage meters with different unit types and step-down tiers? That's a prompt. Want a free quota that resets monthly before any charges kick in? That's a prompt. Want to bundle two products so one meter feeds into the other without creating a separate line item? Also a prompt.
The PostHog model specifically maps well to what Flexprice supports out of the box. Each product (Analytics, Session Replay, Feature Flags, and so on) becomes its own usage-based meter with its own tier ladder. The bundling logic between Experiments and Feature Flags, where experiment evaluations simply consume from the flag request quota rather than creating a new meter, is expressible as a relationship between meters rather than custom code. Spend caps per product, the kind that cut off a single module at a threshold without affecting others, are a native configuration on each meter rather than a workaround.
What Flexprice adds beyond just mirroring the structure is the operational layer that makes this pricing actually run at scale. Real-time event ingestion handles the volume that products like Analytics and Feature Flags generate. Credit wallets cover prepaid or quota-based scenarios. Multi-currency invoicing and Stripe or Razorpay integration handle collection. None of that needs to be wired together separately.
The broader point is that PostHog's pricing is not a special case; it is just a combination of patterns that appear across AI-native tools, observability platforms, infrastructure products, and developer tooling. Flexprice's MCP server lets teams describe any such combination in prompts and get a production-ready billing model out the other side, without starting from a rigid template or rebuilding logic every time the pricing changes.
Making the right call on PostHog’s pricing
PostHog’s pricing is designed to scale with you—but it’s not “set and forget.” The free quotas are generous enough for early-stage teams to run multiple modules at no cost, while the usage-based tiers reward higher volumes with step-down rates. This keeps it competitive against seat-based tools, especially for engineering-heavy teams that grow quickly in headcount.
The biggest drivers of your bill will almost always be Analytics events and Session Replays. These should be the first areas you monitor, cap, and optimize. Smaller meters like Surveys, Feature Flags, and Data Warehouse rows often stay well within budget unless they’re tied to high-frequency workflows.
If you want predictability:
Cap spend per product to avoid surprise bills.
Filter aggressively at ingestion so you’re only paying for meaningful data.
Forecast with tier ladders so you know exactly how growth will affect costs.
