Thirty-two tools landed in PostHog's MCP server this week:

Experiments

• Recalculate experiment metrics
• Get experiment results
• Get experiment recalculation run

Web analytics

• Run a web analytics overview query
• Run a web analytics breakdown table query
• Run a web vitals path breakdown query

ReviewHog

• Get a ReviewHog review
• List ReviewHog reviews
• Trigger a ReviewHog review

Streamlit apps

• Create Streamlit app
• Delete Streamlit app
• Get Streamlit app
• List Streamlit apps
• Set Streamlit app source
• Start Streamlit app
• Get Streamlit app status
• Stop Streamlit app
• Update Streamlit app
• List Streamlit app versions

Notebooks

• Configure notebook compute
• Get notebook
• List notebook dataframes
• Interrupt notebook cell run
• Get notebook cell run result

Customer analytics

• List account channel summaries
• List announcement channels
• Send announcement
• List announcements
• Get announcement

Replay vision

• Create vision action
• Delete vision action
• Update vision action

Data Warehouse GitHub sources can import deployment and deployment-status records alongside the rest of your repository data.

Added 28 tables to the Mailchimp source

The Data Warehouse Brevo source has moved from alpha to beta after a clean run with active users. Same connector, less caveat.

Data Warehouse can now import data from nine additional services:

• Codemagic build and CI data
• Discourse community data
• Apitally API analytics data
• Aha! Ideas product-feedback data
• CAST AI cloud-optimization data
• DocuSign agreement data
• Gusto payroll and HR data
• Etsy marketplace data
• Zoho CRM customer data

Data Warehouse can run live, read-only HogQL queries against ClickHouse and ClickHouse Cloud sources. No import required when you need the current data.

Data Warehouse Cloudflare sources can now import 33 additional tables, giving you more of your Cloudflare data to query.

Added 23 tables to the Clerk source

Added 23 tables to the Sentry Data Warehouse source

Add leads table to HubSpot Data Warehouse source

Added 25 tables to the Zendesk Data Warehouse source

Added a Marketo Data Warehouse source

Added a Qualtrics Data Warehouse source

Added a Pardot Data Warehouse source

Added 24 tables to the Klaviyo Data Warehouse source

Added an Adobe Analytics Data Warehouse source

Added an Adobe Commerce Data Warehouse source

Added an Adyen Data Warehouse source

Added a BILL.com Data Warehouse source

Added a Workday Data Warehouse source

Inbox reports can include inline charts and tables beside a scout’s written findings. See the data behind quantitative alerts without hunting down a separate insight.

Add a note when dismissing or snoozing an inbox report, and the Scout that filed it receives that feedback before its next run. Your “not useful” now has somewhere useful to go.

Create a Scout with AI guidance or fill out the prompt, schedule, and Slack destination yourself. Daily schedules can run at a chosen time in your project timezone.

Batch Exports resume interrupted reads from staging storage at the last completed batch, rather than restarting the file and potentially duplicating rows at the destination.

AI observability now supports Vercel Eve’s OpenTelemetry traces.

You can now store more than just a prompt inside Prompt Management. Metadata like model parameters can be stored and retrieved at runtime.

Traffic from AI assistants like ChatGPT, Claude, Gemini and Perplexity is now classified under a new "AI" channel type instead of "Referral" or "Organic Search". Channel type is computed at query time, so historical sessions reclassify too: if you filter or alert on "Organic Search" or "Referral", counts may shift. No data is changed or lost, only how sessions are classified.

Run live SQL queries against synced Data Warehouse sources from the SQL editor. Enable direct querying in source settings, or jump in from a source's schema tab.

The Notebook SQL schema browser now lists the dataframes, tables, and views available in your live kernel, so you can query them without guessing their names.

AI Observability boolean evaluations that run against traces can now generate and deliver evaluation reports. Trace citations and report navigation stay linked to the trace being evaluated.

Images and audio stored with AI traces now render in the trace view, while other files can be downloaded instead of appearing as phaiblob:// pointers.

Fetch a named LLM prompt version by its label, such as production, with the prompt API. Label changes clear cached lookups, so consumers receive the current version.

AI observability session summarization has graduated from early access and is now available to everyone.

Session Replay can capture native screens covering a Flutter app, such as login flows and paywalls, instead of freezing on the last Flutter frame. Enable it with captureNativeScreens.

Built-in Hog evaluation templates now work for both individual generations and whole traces. The editor also shows consistent recommended variables and tests against complete AI input and output.

Autocapture can record touch swipes that do not cause a visible change as $dead_swipe events. The events include direction and distance, alongside the existing dead-click detection.

Pass a defaultValue to isFeatureEnabled in the JavaScript and React Native SDKs. It returns that boolean while flags are unavailable, still loading, or missing.

Exceptions captured inside an active OpenTelemetry span now include trace and span IDs. Error Tracking can link the exception back to the trace where it happened.

Ruby apps can load Feature Flag definitions through the background poller instead of making a synchronous request during setup or evaluation. Use feature_flags_loaded? to wait until definitions are ready.

Error Tracking links now use an issue fingerprint when available, so alerts, emails, and tracker tickets keep opening the same issue after issues are merged. Existing issue-ID links still work.

Feature Flag payloads keep evaluating when an older dependency uses a numeric key. One malformed flag no longer prevents the rest of your project's flags from loading.

Feature Flags using cohorts with unsupported filter leaves no longer fall straight back to their default value. Unsupported conditions count as non-matches while the rest of the cohort can still be evaluated.

Ask MCP for a Feature Flag definition using its readable flag key, without looking up the numeric ID first.

Realtime cohort membership now follows the surviving person when profiles are merged. That keeps cohort-based targeting and cohort calculations from hanging onto the old profile.

Customer Analytics has an Announcements tab for writing a message, choosing customer Slack channels, and sending it without double-posting. Delivery history shows what reached each channel and what did not.

Monthly, quarterly, and yearly Trends insights now exclude events from before your chosen start date. Short ranges no longer quietly include the rest of the bucket.

MCP dashboard-building tools can search and inspect official dashboard templates before creating a dashboard.

Managed Warehouse tables are available in the SQL editor through a project-scoped, read-only connection. New tables are picked up automatically.

Each project in an organization can join its managed warehouse with its own schema name. Availability is checked before onboarding, so conflicting names fail early.

The Data Warehouse overview shows when each schema was last applied, rather than an unavailable status. It replaces the unreliable queue status check.

Filter Experiment recordings to sessions where selected metric events fired, then jump straight to those moments in the player. Metric events are marked in the sidebar, seekbar, and inspector.

Experiment maturity and mean or ratio metrics now anchor to each person's first exposure. Re-evaluating a flag no longer shifts that window and changes already-mature results.

Set sharing rules for individual Replay Vision scanners, plus a project-wide default. Scanner actions follow the same access rule, so permissions stay consistent.

Replay Vision scanners use session event evidence alongside recordings when reaching a verdict. Navigation events and tighter handling of hidden errors and gestures reduce misleading friction findings.

See how many users and sessions a Replay Vision scanner affects, then save the affected users as a static cohort. Classifier tags can also create cohorts for their matching users.

Start a Replay Vision group summary whenever you need one, without changing its schedule or starting duplicates. Daily digests also appear alongside other summaries and alerts.

Select multiple recordings on the Replay Vision on-demand tab and scan them together. The batch reports which scans started, were already running, or were skipped because of limits.

Android Session Replay no longer skips screens during fast navigation when recording throttling is active.

Replay Vision checks inline observation citations against the underlying outcomes before sending group summaries. Reports are less likely to attribute errors to clean sessions.

Event-triggered Surveys stay tied to the session that triggered them. An un-dismissed survey will not follow someone into their next session.

URL targeting in the full Survey editor now shows an estimated audience size, matching the wizard. You can sanity-check how many people a condition may reach before publishing.

Draft mode adds a confirmation step before a ticket reply goes out. Set it as your local default, then override it on individual tickets when you need to move faster.

Send a reply and move the ticket to pending, on hold, or resolved in the same action. Support will flag any other unsaved sidebar edits before they go along for the ride.

Support ticket workflows can filter on the assigned team, and can start as soon as a ticket is assigned. Useful for routing each team's tickets to its own follow-up workflow.

Support tickets have a new critical priority above high, with its own badge color and filter option. The truly on-fire ones have somewhere to go now.

Combine users, roles, and unassigned Support tickets in one assignee filter. Selections are matched together, so a shared queue no longer needs a scavenger hunt.

Pick which columns appear in the Support ticket list. Column choices are stored locally in your browser for now.

Support ticket filters and sorting are saved in the URL, so filtered lists can be bookmarked or shared. Search text stays private to your current session.

Configure multiple log ID attribute keys to associate logs with the right person. Logs using different identifier fields can now appear in the person view and hover context.

Log groups can now stack up to four dimensions, with a value column for each. Drill into combinations instead of asking one attribute to explain everything.

MCP agents can retrieve tracing latency Heatmaps with the new apm-spans-latency-heatmap tool. It includes guidance for reading latency patterns across time.

Self-driving Inbox can flag flaky checks, a failing default branch, and CI duration regressions from your GitHub data. Each issue is deduplicated and can be researched and routed through the normal signal workflow.

Configure a Slack destination for each Self-driving Scout and receive its completed run output there. Scout delivery is separate from Inbox report notifications, so each can mind its own business.

Run Self-driving Scouts at fixed times, such as every weekday morning or twice a day, instead of only on rolling intervals. Custom cron schedules set through the API remain visible in the settings UI.

Start a deployed Self-driving Scout from an existing PostHog MCP session, continue the conversation with send, and check progress with listen. No separate MCP server setup required.

Leave team-wide or skill-specific notes to guide what Self-driving Signals scouts investigate without editing their skills or schedules. Notes can expire when the nudge has done its job.

Assign explicit owners to a skill, and Self-driving Signals will prioritize them when suggesting reviewers for scout reports. No more treating the last person to edit a skill as its permanent owner.

When a resolved Self-driving Signal appears again, Inbox creates a new linked report instead of reopening the old one. The new investigation can use the previous report to tell a regression from a repeat offender.

Set viewer, editor, and manager permissions for MCP Analytics. Session-intent summaries follow those permissions too.

Upload CSV, JSON, or Parquet files directly into Data Warehouse as self-managed tables. No separate sync pipeline required.

Data Warehouse sources can automatically enable and sync newly discovered tables or channels. Use glob patterns such as raw_* to limit which schemas join in.

One GitHub Data Warehouse source can now sync multiple repositories. New repositories keep separate schemas and webhook mappings under the same source.

Filter Customer Analytics accounts using custom account properties. Filters are saved with views and included in shared view links.

Visits from AI assistants such as ChatGPT, Claude, and Perplexity are classified in a dedicated Web Analytics AI traffic channel instead of being mixed into Direct, Referral, or Search.

Electron desktop apps such as Claude and ChatGPT, plus self-declared AI crawlers, are classified as AI agents in Web Analytics.

The new query-web-vitals MCP tool returns Core Web Vitals path breakdowns with metric, percentile, and threshold options, without hand-rolling SQL.

Data Warehouse can now import data from 22 additional services, ready to join with the rest of your tables.

• Microsoft Clarity
• KnowBe4
• Lightdash
• npm registry
• Omni Analytics
• RubyGems.org
• Spot by Flexera
• Telnyx
• Eppo
• Courier
• BugHerd
• Zylo
• Trunk.io
• FusionAuth
• Dovetail
• Descope
• DebugBear
• Cortex
• CodeScene
• CloudZero
• Census
• Ably

Saved ticket views are easier to identify, find, favorite, and use without losing your sort order:

• Active-view indicator and clear control
• Favorite views for quick access
• Search views by name
• Keep sorting when using a saved view

Product Analytics dashboards and individual tiles give you more control over how filters affect the data you see:

• Dashboard-wide test-account filtering can be forced on or off, or inherited from each insight.
• Individual tiles can ignore dashboard filters entirely.
• Tiles can override their own interval and breakdown.

Support preserves more of the customer message when tickets arrive by email or are imported from Zendesk:

• Keep complete inbound email text
• Preserve text in forwarded emails
• Retain Zendesk comment text alongside images

Self-driving Inbox can now turn records from 32 additional sources into actionable signals, including support desks, issue trackers, error tools, security scanners, feedback tools, reviews, Intercom, and HubSpot. Setup also uses a shared OAuth flow instead of provider-specific forms.

• Self-driving Inbox signal emitters for 30 warehouse sources
• Inbox source picker for 30 warehouse-backed sources
• Generic OAuth setup for Inbox sources
• Intercom and HubSpot Inbox signal emitters
• Intercom and HubSpot Inbox connection UI

Instrumentation health issues – such as missing events, outdated SDKs, ingestion warnings, and broken warehouse models – can now surface in Self-driving Inbox. Enable the source from the Agents roster and handle them alongside other signals.

• Health-check issues as Inbox signals
• Health checks card in the Agents roster

Replay Vision alert creation and history are easier to understand, so it is clearer what fired, when it recovered, and how to configure notifications:

• Alert history records recoveries with threshold and duration details
• Alert messages lead with the alert name and link to the run
• Separate creation flows distinguish summaries from alerts
• Conditions separate matching criteria from notification timing

Bootstrap identity and feature flag state across Android and Flutter SDKs, so early events and flag reads can use known values before the first flag request.

• Android core bootstrap configuration
• Android package release support
• Flutter bootstrap configuration

Bing Ads in Data Warehouse is now marked as generally available instead of beta. Nothing else changed, so the connector still does the same thing, just with a less tentative label.

AirOps now shows up as a Data Warehouse source, so you can connect a workspace API key and sync your apps plus execution telemetry like status, inputs, output, credits used, runtime, and feedback. It runs as full refresh only, because AirOps doesn’t give us a clean timestamp filter and the executions like to keep changing after they’re born.

PyPI is now a Data warehouse source, so you can pull package metadata, release files, and known vulnerabilities for the Python packages you care about. It uses the public JSON API, so there’s no setup beyond entering package names, and every sync runs as a full refresh since PyPI doesn’t give us a “changed since” filter.

Kernel can now sync into the Data Warehouse, pulling in apps, deployments, invocations, browsers, and profiles so you can join agent activity with your product data. It ships as a full-refresh source for now, because we couldn’t verify Kernel’s since filter without a live key, so incremental gets to stay in the queue for once.

You can now pull a Storage by Zapier store into Data Warehouse as a full-refresh source: it fetches the whole key/value store with a secret and turns it into one row per key. The source is alpha, uses a single required secret, and stops on bad auth instead of retrying forever like a very committed raccoon.

Replicate is now wired up as a Data Warehouse source, so you can sync predictions, trainings, deployments, models, hardware, and account data into PostHog. Predictions sync incrementally off created_at; the rest do full refresh, because the API apparently enjoyed keeping the nice filter to itself.

Cal.com bookings sync now stays under the API’s 100-item page limit, so it stops tripping over a 400 on the first request. Webhooks keep their 250-item page size, because apparently one endpoint’s ceiling is another endpoint’s bad idea.

Browserbase can now sync its sessions and projects into the Data Warehouse, using full refresh since the API doesn’t offer a real incremental path. It ships as an alpha, visible source with the Browserbase key passed in as X-BB-API-Key, so you can pull browser automation data in without the stub doing nothing anymore.

You can now sync Google PageSpeed Insights scores into Data Warehouse from a list of URLs, with separate desktop and mobile tables. It pulls the Lighthouse report plus core scores like performance, accessibility, best practices, and SEO, and keeps appending results over time so you can watch your pages get judged repeatedly.

Twelve Labs now has a working Data Warehouse source, so you can pull in indexes, tasks, and videos instead of staring at an empty stub. Indexes and tasks sync incrementally, while videos fan out per index and stay full refresh only for now, because the API decided that was the least annoying option.

Healthchecks.io is now available as a Data Warehouse source, so you can pull in checks, notification channels, status-change history, and recent ping logs. Flips sync incrementally; the rest do a full refresh, because the API apparently enjoys keeping us humble.

Hatchet can now be connected as a Data Warehouse source, pulling workflow runs, task runs, events, and event keys into PostHog. It uses the Hatchet API token to figure out your tenant and server URL, with optional host and tenant overrides if you’re self-hosting or the token won’t play nice.

Windmill now syncs into Data Warehouse, pulling job history and workspace tables like scripts, flows, apps, schedules, resources, users, and audit logs. Completed jobs can sync incrementally; everything else gets a full refresh, because not every API wants to make our lives easy.

Metorial is now a Data warehouse source, so you can pull sessions, messages, tool calls, provider runs, deployments, and error telemetry into PostHog. It syncs incrementally, keeps going after interruptions, and leaves providers off by default because apparently even catalogs need a little self-control.

Firecrawl is now wired into Data Warehouse, so you can sync account activity, credit and token usage, active crawls, monitors, and monitor checks into PostHog. It runs full refresh only, because Firecrawl doesn’t give us an “updated since” filter, which is rude but consistent.

Trigger.dev can now be connected as a Data Warehouse source, pulling in task runs, schedules, and queues. Runs sync incrementally with a short lookback so late updates get picked up, and self-hosted instances can point the connector at their own API URL.

You can now import Scaleway into the Data warehouse to pull IAM, billing, account, instance, and audit trail data into PostHog alongside the rest of your stuff. It handles Scaleway’s weird little pagination flavors and region/zone fan-out, but ships as full refresh only for now, because incremental support would have been asking for trouble without live credentials.

Alguna billing data now syncs into Data warehouse as eight full-refresh tables: customers, invoices, subscriptions, payments, refunds, plans, products, and billable metrics. It’s still tucked behind an alpha gate, because no live account was available to fully bully-test it.

You can now pull Maxio Advanced Billing data into Data warehouse, including customers, subscriptions, invoices, products, coupons, components, payment profiles, events, and credit notes. It supports US and EU sites, with incremental sync where the API actually behaves itself and full refresh everywhere else.

Linode now has a working Data warehouse source, so you can pull account, billing, and infrastructure data like linodes, volumes, domains, users, invoices, payments, and audit events into PostHog instead of staring at the Cloud Manager tab like it’s helping. Events sync incrementally from the last 90 days, invoices update by date, and the rest do full refreshes because apparently not every API wants to be convenient.

Data Warehouse can now pull Writesonic GEO analytics into your warehouse, including daily performance exports and config tables for topics, platforms, websites, and prompts. It syncs incrementally by day, resumes mid-run without skipping data, and uses the usual auth, retries, and error handling so it mostly just gets on with it.

ElevenLabs now syncs real data into Data Warehouse instead of sitting there looking decorative. You can pull in speech generation history, conversations, agents, voices, and models, with incremental sync where the API supports it and resumable pagination so interrupted runs can pick up where they left off.

You can now run direct query against Redshift instead of importing it first, using the same setup you already had for Postgres, MySQL, and Snowflake. The Redshift printer keeps the shared Postgres-ish SQL surface, but blocks the bits Redshift can’t handle so the query fails loudly instead of pretending everything is fine.

Anthropic can now sync Claude usage, cost reports, org members, workspaces, invites, and API keys into the Data warehouse. The daily usage and cost tables run incrementally with a one-day lookback, so your LLM spend doesn’t get lost in the usual API paperwork.

You can now import ChartHop into Data Warehouse, pulling in people, org chart, compensation changes, and a few related lookup tables. changes syncs incrementally, while the snapshot-style endpoints do a full refresh because ChartHop makes that part awkward.

You can now sync Cursor team data into the Data warehouse: members, daily usage, usage events, and current-cycle spend. The connector handles Cursor’s weird little POST-based pagination, rate limits, and incremental backfills so it doesn’t immediately fall over like the rest of us.

GitHub warehouse sources now sync pull request reviews, so you can build review metrics like reviews per PR, time to first review, and approval latency. It uses the pull_request_review webhook as the source of truth, with polling only re-fanning recent PRs instead of doing a full historical crawl.

RevenueCat is now generally available in Data Warehouse, so you can connect it without the beta rollout gate. Nothing about the connector changed under the hood - this is just a status bump from beta to GA.

You can now pull Metorial MCP observability data into PostHog, including sessions, messages, tool calls, errors, provider runs, deployments, and providers. The sync is resumable and incremental where Metorial supports it, so interrupted backfills don’t have to start from page one.

Decagon now syncs into Data warehouse, pulling conversation history, CSAT ratings, tags, and metadata through a single conversations stream. It runs as a full refresh, remembers its cursor so long backfills can resume, and throttles itself to Decagon’s 1 request per second limit so it doesn’t get itself banned for enthusiasm.

Anthropic now syncs into Data Warehouse, pulling Claude usage, cost, and org admin data so you can poke at spend and token usage next to the rest of your stuff. The reports sync incrementally, the admin tables full refresh, and the whole thing is wired up with resumable pagination so it can crash and keep going like a well-behaved gremlin.

Sentiment evaluations now show up in AI Observability evaluation reports, with positive, neutral, and negative distributions.

Prompt labels now give you a movable pointer like production for a prompt version, so you can promote or roll back without changing code.

The inbox report detail pane now has a Discuss button instead of Feedback, so you can actually talk back to the agent that made the report or opened the PR. Hitting it starts or reuses a discussion task right in PostHog, and the old thumbs up/down feedback dialog and its analytics bits are gone.

Signals can now surface Product analytics anomaly investigations in the inbox. When an insight alert triggers and the investigation agent runs, you get a dedicated signal card with the report, links back to the insight, investigation, and alert, plus a per-team enable/disable setting so it can be turned on without much ceremony.

Customer Analytics MCP tools now let you read and manage account relationship definitions and assignments: list, create, update, destroy, assign, and end. Assign works like an upsert, and ending a relationship keeps the history around.

SDK Health now recognizes both the legacy posthog-java and current posthog-server SDKs. Similarly it now correctly detects posthog-kmp (Kotlin).

You can now refund a Signals PR charge from the report, and PostHog will either drop it from usage if it happened the same UTC day or issue a credit later in the billing period. Reports coming from PostHog-owned system checks are also marked billing-exempt up front, so they never get charged in the first place.

The .NET SDK now supports a BeforeSend callback via PostHogOptions. Set it to inspect, modify, or drop events before they're uploaded. BeforeSend runs after full event enrichment (super properties, groups, feature flags), so you have the complete picture.

Return null to drop the event entirely.

Workflows now track conversions as a metric in the Metrics tab. You get a Converted count card, a trend line, and a Conversion rate card (conversions ÷ started, capped at 100%) so you can finally see how many people actually hit your conversion goal.

The PostHog PHP SDK now supports a before_send callback. Pass it as a client option to inspect or modify the fully enriched event payload before it's queued. You can also use it to drop events by setting the event to null.

Feature Flags now exposes getAllFeatureFlags() in JavaScript Web and React Native SDKs. It returns all currently loaded flags as structured results – key, enabled state, variant, and payload – without triggering a network request or $feature_flag_called events, so it's safe to use freely in debug panels or log enrichment. Mobile SDKs already had this; the JS SDKs are now at parity.

You can mix quotes with headings and lists in Notebooks.

Workflows now has a subscription matcher consumer that wakes parked hogflow jobs when a matching event arrives. It looks up jobs waiting on a wait_until_condition or events-based conversion goal by distinct_id or person_id, evaluates incoming events against each candidate's filter, and reschedules matching jobs – with teams that have no waiting conditions paying zero extra Postgres queries.

The span list in Distributed Tracing now has clickable sort controls on the Timestamp and Duration column headers. Click a header to sort by that column, click again to flip direction. The active sort is shown with a directional arrow and persisted in the URL.

posthog.mcp brings MCP Analytics to Python – previously the @posthog/mcp package was TypeScript-only, leaving Python MCP servers out in the cold.

Install with pip install posthog[mcp] and call instrument(server, posthog_client) once; works with FastMCP, the official low-level Server, and jlowin's FastMCP 2.0.

Evaluations now support sentiment analysis. It runs locally using the cardiffnlp model on user messages.

This uses traditional sentiment analysis, which means they're very cheap 😉

Workflows wait steps can now wait to advance on future events, not just property conditions. Configure an "Events to wait for" list on any wait step will move the workflow forward on a matching event.

Workflows now emits email engagement events – $workflows_email_sent, $workflows_email_delivered, $workflows_email_opened, $workflows_email_link_clicked, $workflows_email_bounced, $workflows_email_blocked, and $workflows_email_failed. Use them to track and build dashboards on your workflow emails.

Each event includes $workflow_id, $workflow_action_id, $email_to, and $email_subject to tie it back to the exact email step and recipient.

Product Analytics insight alerts can now notify Microsoft Teams directly. Just paste your incoming webhook or Power Automate workflow URL – no OAuth or extra integration required.

Error Tracking now works out of the box for Next.js apps using @posthog/next.

• Browser-side exception capture is enabled by default.
• New onRequestError / createOnRequestError helpers cover server-side request errors from Next.js instrumentation.
• Server errors capture path-only $pathname values, so query strings and fragments stay out of your event properties.

The browser SDK now captures $device_model on Android Chromium via the User-Agent Client Hints API, bringing it in line with the native iOS and Android SDKs that already send this property.

The value is resolved once at init and registered as a super-property – so it shows up automatically on subsequent events without touching the capture hot path. You can opt out with disable_device_model: true.

PostHog agents can detect problems in your product data, investigate, and deliver a fix. It's called self-driving.

How it works:

• Scouts – scheduled agents that comb your product data, using connected tools like error tracking or product analytics
• Reports – findings are clustered and ranked by priority and delivered to your inbox or Slack with draft PRs
• Inbox – where self-driving hands work back to you, with reports and PRs that ready to review

Your first 3 PRs are free every month. Then it's $15/PR, with a default $150 billing limit. Scouts and reports are free.

Run npx @posthog/wizard self-driving to get started.

Auto-captured browser console.* logs now link to person profiles and run through logs.beforeSend, with a smaller bundle (OpenTelemetry removed).

Workflow email activity (sent, delivered, opened, clicked, bounced, failed) is now captured as events on the recipient, so you can analyze deliverability and engagement and trigger follow-up workflows.

Enable it per project in workflow settings.

Workflows can now respond to what people actually do, not just time delays.

Wait for an event in Workflows. Add a Wait until step that holds each person until they trigger a chosen event (or a max wait elapses), then routes them down the matching branch.

Automatic server-side and client-side exception capture for Next.js apps using @PostHog/next

Microsoft teams is now explicitly supported as a destination for insight alerts.

View real-time logs in your dashboards with widgets, so you can monitor a service without leaving the page.

The JS web SDK now captures $device_model as a property when the browser exposes it. Works for Android Chromium users and can be opted out with disableDeviceModel: true

Get all of a user's currently loaded feature flags in one call, returned as a list where each flag includes its key, enabled state, variant, and payload.

It reads the cached flags (no network request) and doesn't send a $feature_flag_called event, so it's safe for inspecting or listing flags — debug panels, support tools, or forwarding flags elsewhere — without affecting your experiment results.

Available in the JS web SDK

We want to bring the same functionality to Android that we have for Web Surveys.

If you have any feedback or specific feature requests, please comment on the linked GitHub issue.

Capture logs from your mobile application directly in PostHog

You can now send Product Analytics insight alerts to Discord. Add an incoming webhook URL and you're done! No OAuth or integration setup required.

The Go SDK now supports a BeforeSend hook via Config.BeforeSend. It runs after SDK enrichment and right before the event is sent, so you can inspect or modify the payload – or return nil to drop it entirely.

The Android SDK now supports exception steps for Error Tracking.

Call PostHog.addExceptionStep("message", properties) to record a rolling buffer of breadcrumb-style context that attaches to every $exception event as $exception_steps. The result: a timeline of activity leading up to each crash, so you know exactly what happened before things went sideways.

Steps are buffered synchronously, so anything recorded right before a fatal crash gets captured too.

Logs in the browser SDK now support a logs.beforeSend hook. Pass a function to inspect, redact, or drop log records before they leave the browser. Return null to drop a record, or return the log to let it through.

Feature Flags in posthog-react-native and posthog-js-lite now support two new runtime options:

• disableRemoteFeatureFlags – stops the SDK from fetching flags from the server, so identify(), group(), and reset() no longer trigger /flags calls.
• updateFlags(flags, payloads?) – push locally evaluated flag values at runtime, no network request needed.

Logs are now available in the Flutter SDK. Use Posthog().captureLog(...) or the Posthog().logger facade (trace through fatal) to ship structured logs from your Flutter app. They'll appear alongside your events and session replays, just like on iOS, Android, web, and React Native.

Follow the Flutter installation guide to get started.

Product Analytics lifecycle insights now have a Show percentages on series toggle. Enable it alongside Show values on series and each segment label displays both the absolute count and its share of that band:

Surveys now support an opt-in back button for multi-question and branching surveys for posthog-js >= 1.386. Enable it via allowGoBack in your survey appearance settings, and respondents can navigate back through the exact path they took – with their previous answers pre-filled.

You can now apply a limit which will be applied to each issue individually automatically. No more exploding issues.

You can now attach W3C trace context to your PostHog logs on Android, so logs can be correlated with a distributed trace.

The Flutter SDK now supports setPersonPropertiesForFlags and setGroupPropertiesForFlags (plus reset variants), matching our iOS, Android, and JS SDKs.

Set a targeting property and it's sent inline with the next flag evaluation, so flags resolve to the correct value.

The alerts list in Product Analytics now has a search bar and a created-by filter.

Error Tracking in the React Native SDK now supports native crash capture for iOS and Android, not just JS-layer errors. Set errorTracking.autocapture.nativeCrashes: true and install @posthog/react-native-plugin to opt in. The Expo config plugin also gains an uploadNativeSymbols option to upload dSYMs and R8 mapping files so those stack traces are actually readable.

The Node SDK now has setPersonProperties() and unsetPersonProperties() helpers, bringing it in line with the browser, core, and React Native SDKs. No more hand-crafting $set events just to unset a property.

The span inspector in the trace drawer now has a Logs tab, so you can see logs emitted by a specific span or the whole trace without leaving the trace view. An Open in Logs button deep-links into Logs pre-scoped to the same trace or span and time window when you need the full experience.

You can now send the "Fix" and "Explain" action prompts directly to PostHog Code, Claude Code, Cursor, or Codex. You can still copy it manually if that's your thing.

Workflows now supports creating and editing email templates over MCP. Templates are authored as design JSON and rendered server-side by Unlayer. Anything an AI agent generates opens as fully editable blocks in the visual editor, not opaque HTML you can't touch.

Android apps no longer need a custom-built UI to display Surveys. The new posthog-android-surveys-compose module provides a ready-made Jetpack Compose UI. Use it by adding the dependency and setting surveys = true. The core SDK picks it up automatically.

It supports open text, single and multiple choice, NPS, emoji ratings, link questions, and server-driven multi-question branching, with full theming via PostHogDisplaySurveyAppearance.

You can find instructions in the updated Android Surveys installation docs

You're a wizard, Error Tracking. Source maps for JS-based frameworks are now part of the PostHog Wizard giving you a one-shot setup for OAuth, secure API key storage, and full build pipeline wiring.

Insight and dashboard subscriptions are now available on the free tier. Paid plans get unlimited subscriptions.

The Error Tracking symbol sets page now has a search box. Filter server-side by reference, release version, project, or commit SHA – no more paginating through the full list to find one set.

Product Analytics funnels now respect path cleaning rules when breaking down by event properties. Consistency: achieved.

Let your agents handle it. Workflows are now available through PostHog MCP, so agents can create drafts, test, update, enable, disable, and archive workflows directly.

Workflows now has three MCP tools for batch operations: workflows-blast-radius to size the audience before you do anything regrettable, workflows-run-batch to run a one-off broadcast, and workflows-schedule-create for recurring RRULE schedules. The blast-radius count is recomputed server-side on every run and rejected if the audience has drifted, so agents can't accidentally broadcast to everyone.

The PostHog AI MCP query-results app now renders trends line charts using the same shared view as the web UI. The shared transforms were neutralized to remove runtime dependencies so both the web frontend and the MCP bundle can import them cleanly.

Error Tracking now respects per-project rate limit settings during ingestion. Teams can configure their own token bucket parameters (project_rate_limit_value and project_rate_limit_bucket_size_minutes), which the ingestion pipeline now reads and applies – falling back to environment defaults when none are set.

Mention @PostHog in any Slack channel and the PostHog Slack app will answer questions about your product data, plan and code features, run your checks, and open a draft PR.

It's the same agent behind PostHog AI and PostHog Code, just summoned from where your team already works.

Stop building (and maintaining) your own backend for customer-facing analytics. Turn any saved insight or SQL query into a fast, versioned, authenticated API using Endpoints.

Hit it from your product, a dashboard, an internal tool, or an LLM. Endpoints offer...

• Materialized queries on a configurable schedule
• Configurable cache TTL per endpoint
• Versioned, pin a query snapshot so upstream edits don't break
• 2,400 req/hr default rate limit
• Parameterized queries for per-user / per-tenant safety

Try it fully featured for free until our new Managed Warehouse launches in beta, join the waitlist to be the first to know about it.

Try Endpoints → Read the docs → Tutorials →

Adds request-scoped context to the server-side JVM SDK so that backend events, exceptions, and feature flag evaluations can automatically link to the same frontend user/session.

Under the hood, the sessionId and distinctId are automatically parsed from the request and used to link events to frontend sessions.

You can now use PostHog Code on Linux x64 and arm64. You can find the Linux packages in the latest releases.

Experiments now supports winsorization to reduce the effects of outliers for ratio metrics. The numerator and denominator are capped independently, each with its own percentile bounds, so your delta-method variance stays consistent with the capped point estimate.

Feature Flags now has a dedicated testing tab where you can enter a person or distinct ID and see real-time evaluation results with a full condition breakdown – including which conditions win, which don't, and why.

You can now configure event filters that drop unwanted events at ingestion time, before they ever hit your data. You can configure them in Event ingestion filtering to build filter rules using a boolean expression tree, test them against live cases with pass/fail feedback, and roll out in disabled, dry-run, or live mode.

Session Replay minimum duration is now supported in the Flutter SDK (5.24.3+), joining Web (posthog-js 1.291.0+), iOS (3.53.0+), and Android (3.44.0+). You can configure minimum duration under Settings > Session replay> Recording conditions.

Product Analytics trends line and bar charts now support custom X-axis and Y-axis labels. Set them in the chart's Options. Long labels are automatically truncated so they don't clip the chart.

The Android SDK now ships a posthog.logger API, bringing Logs capture to Android. It supports batching, offline persistence, redaction via beforeSend hooks, and a rate cap.

Enable it like this:

val config = PostHogAndroidConfig(
    apiKey = "<ph_project_token>",
    host = "<ph_client_api_host>",
).apply {
    logs.serviceName = "my-app"        // OTLP service.name – shown in the Logs UI
    logs.environment = "production"    // OTLP deployment.environment
    logs.serviceVersion = "1.2.3"      // OTLP service.version
}

And log like this:

// Per-level convenience methods
PostHog.logger.info("checkout completed", mapOf("order_id" to "ord_789", "amount_cents" to 4999))
PostHog.logger.warn("payment retry", mapOf("attempt" to 2))
PostHog.logger.error("payment failed", mapOf("code" to "E001"))

// Generic entry point for a runtime severity (e.g. mapping a Timber priority)
PostHog.logger.log("rendered cart", severity = PostHogLogSeverity.DEBUG)

More in the Logs docs.

$screen_name is now automatically attached to every event captured on the iOS Swift SDK after a PostHog.screen()call (manually or via captureScreenViews). Previously only $screen events carried it, which made filtering exceptions, identifies, autocaptured taps, and custom events by screen frustrating

$screen_name is now automatically attached to every event captured on the Android SDK after a PostHog.screen() call (manually or via captureScreenViews). Previously only $screen events carried it, which made filtering exceptions, identifies, autocaptured taps, and custom events by screen frustrating

You can now mute error notifications for individual data pipelines destinations, transformations, Batch Exports, and legacy plugin destinations. Find the controls in your notification settings.

Experiments now supports an organization-level default minimum detectable effect (MDE). Set it once in Experiments Settings and every new experiment inherits it, no more re-entering a stricter threshold each time.

Cohorts now have an activity log. On any saved cohort, a History section shows what changed, who changed it, and when. Track field updates, manual person additions and removals, and creation or deletion events.

Surveys in the iOS SDK now support per-language translations. The SDK resolves the display language from an init override, a person property, or the device locale – applies the matching translation to all user-visible strings, and stamps $survey_language on every survey event when a translation is active.

Pasting Markdown into a notebook now renders it properly instead of dropping it in as a wall of plain text. Headings, lists, blockquotes, tables, and code blocks are all detected and parsed. No more converting everything by hand with slash commands.

pganalyze is now a signal source. Actionable Postgres findings – missing indexes, vacuum lag, schema problems – get routed into the same signals grouping and report pipeline alongside your customer-facing sources like Zendesk, Linear, and GitHub.

Batch Exports now has a dedicated API for programmatic file downloads on demand. Three new endpoints let you create a run, check its status, and download the resulting file – without needing to set up a recurring batch export or a destination.

Surveys in the Android SDK now support translations. You can provide per-language overrides for all user-visible strings via a translations map, and the SDK will resolve the right language at display time – checking an init override first, then the person's language property, then the device locale. A $survey_language property is stamped on all survey events when a translation takes effect.

We’ve made Error Tracking queries significantly faster and more efficient for better performance across all volumes and time ranges.

• 0–10k exceptions → p50 24% faster, p95 20% faster
• 10k–100k exceptions → p50 20% faster, p95 12% faster
• 100k–1M exceptions → p50 26% faster, p95 30% faster
• 10M+ exceptions → p50 26% faster, p95 38% faster

A new feature-flags-test-evaluation-create MCP tool lets you test Feature Flags evaluation against specific users directly from a coding agent, with detailed condition analysis so you can see exactly why a flag resolves the way it does.

You can now connect GitHub as a Support channel and reply to issues directly from PostHog.

Logs now has a SQL tab that drops you into a HogQL editor pre-filled with SELECT * FROM logs LIMIT 10. Run custom queries against your log data without leaving the scene.

The Experiments notebook node now shows exposures with a sparkline, metric results, significance status, and winning variant summary. Your notebook just got an upgrade!

The React Native SDK now supports first-party Log capture. You can send structured records with posthog.captureLog() or the posthog.logger.{trace,debug,info,warn,error,fatal}() convenience methods – logs are buffered, rate-capped, and flushed in gzipped batches to /i/v1/logs.

Session Replay now detects rage clicks on iOS and macCatalyst. Upgrade to 3.55.0+ to start capturing furious taps from your users.

Session Replay on iOS now supports a minimum recording duration, so short sessions that aren't worth your time don't end up cluttering your replays.

The iOS SDK now supports configuring a delay before a Surveys popup appears. Available in 3.54.0+.

The Android SDK now supports a minimum recording duration for Session Replay, so short sessions that aren't worth your time get filtered out before they ever hit your quota.

The split person modal now lets you extract specific distinct IDs from a merged profile instead of blowing the whole thing apart. Useful when a handful of IDs got accidentally merged into one mega person and the rest should stay together.

SDK Doctor is now accessible as an MCP tool. Agents can call sdk-doctor-get (scoped to project:read) and get back a full SDK health report, including outdatedness status, banner copy, and drill-in query links, without touching the UI.

Learn more in the MCP docs.

You can now connect your GitHub account under Settings → Personal integrations. This lets PostHog hold server-side GitHub credentials for your account – needed for coding features like PostHog Code and Slack-triggered cloud runs.

Together AI is now supported as BYOKey for running evaluations or trying things out in the LLM Analytics playground.

Searching in the filter bar now matches attribute values, not just attribute names. This makes it much easier to search for values which you know are present somewhere without having to know the exact attribute name it belongs to.

Resend is now available as a beta source in the Data Warehouse. Pull your audiences, broadcasts, domains, emails, and contacts into PostHog to analyze them alongside your product data.

LLM Analytics now supports Azure OpenAI as a BYOK provider. Supply your Azure endpoint, API version, and key to use your deployed OpenAI models in the playground and as a judge in evals.

Enables creation of usage metrics directly from Data Warehouse tables, allowing customers to use all connected sources.

Learn more in the docs

PostHog AI agents now support Slack destinations when creating insight alerts through the PostHog MCP.

Session Replay AI summaries now support custom product context – admins can add free-text context about their product, terminology, and intentional behaviors so summaries stop treating everything like it's generic software.

The PostHog AI MCP server now accepts an x-posthog-mcp-mode header or mode query parameter to explicitly force either tools mode (individual PostHog tools) or cli mode (single exec-based tool) – overriding the auto-detection logic that previously had the final say.

Sometimes PostHog Code reports fail to research due to system issues we're resolving. We now allow you to still see the un-researched reports with clear error messages on failure, so you can see where things stand, and never get the feeling that data disappears.

Support now lets you configure multiple Slack channels for ticket creation – previously you were stuck with just one.

You can now connect ClickHouse as a source in our Data Warehouse. The import streams data in Arrow batches rather than buffering it, so multi-terabyte, multi-billion-row tables while keeping memory bounded.

The SQL editor in PostHog now supports pie charts as a visualization option.

Web Analytics summary data is now accessible via MCP. You can query a weekly summary for traffic, top pages, and referrers data through any MCP-compliant AI agent or tool.

The PostHog VS Code extension brings feature flags, experiments, event analytics, and session replay data directly into your editor. It works with JavaScript, TypeScript, Go and Ruby files (.js, .jsx, .ts, .tsx, .go, .rb).

Install the extension from the VS Code Marketplace or VSX Marketplace.

You can now set up tailored notifications for Surveys to send completed responses straight to Slack, Discord, and other platforms. Responses come pre-filled so your team sees the answer in context.

Workflows can now run on a recurring schedule. Set any workflow to repeat daily, weekly, or monthly with timezone support, end conditions, and a preview of upcoming runs.

Works with batch triggers that target by person, or a new schedule trigger for cron-style automation without one. Great for recurring reports, data hygiene jobs, and anything else you'd rather not babysit.

Your Web Analytics dashboard now comes to you. Opt in to the weekly digest for a summary of visitors, pageviews, top pages, and goal conversions - delivered straight to your inbox.

Great for strategic business partners who want the numbers without opening PostHog, and for you on Monday morning before coffee kicks in.

Snowflake batch exports in CDP now support a snowflake_ingested_timestamp column, so you can tell when an event was loaded into Snowflake versus when it actually happened. Handy for debugging pipeline delays.

To populate the column, add it to your destination table manually as a TIMESTAMP.

When uploading source maps or debug symbols with the PostHog CLI, you can now pass --build alongside --release-version to track your build number separately from your app version. Both show up in the Error Tracking UI, making it easier to pin down which build a stack trace came from.

Works across hermes, dsym, proguard, and sourcemap.

You can now enable automatic PII scrubbing for Logs at the project level. We redact common patterns before anything hits storage: emails, card-like number sequences, Bearer tokens, and sensitive-looking attribute keys all get replaced with {{REDACTED}}.

It's lossy – no un-redacting later – so keep treating logs as sensitive. But it's one less thing to worry about leaking.

The Customer.io integration in Workflows now syncs opt-out preferences in both directions: PostHog receives opt-out updates via a reporting webhook and sends preference changes back via the Track API.

When searching through property filters, you can pin them for quicker access elsewhere in the future. Pinned properties will appear in the Pinned category.

Customer journeys let you visualize how users move through key conversion steps in your product. They combine funnels and paths into interactive flow graphs, so you can see both where users convert and what they do between steps.

You can learn more in the customer journeys docs.

Subscriptions are difficult to understand, so we made these changes to make them clearer:

• Next delivery date both in the overview and edit modal.
• A "weekday" option so that you can schedule a subscription on a specific weekday of a month.
• An option to manually trigger a subscription for testing.

You can learn more in the subscriptions docs.

The PostHog PHP SDK now supports both automatic and manual error tracking!

# Install
composer require posthog/posthog-php

# Initialize
PostHog\PostHog::init(
    'sTMFPsFhdP1Ssg',
    ['host' => 'https://us.i.posthog.com']
);

# Capture
try {
    // Your code that might throw
    riskyOperation();
} catch (\Throwable $e) {
    PostHog\PostHog::captureException($e, 'user_distinct_id');
}

Try error tracking for PHP

Now you can create multiple directed acyclic graphs (DAGs) for your data modeling needs.

This is great for semantic separation between your models:

• Separation by product area, like finance, marketing, and analytics
• Separation by environment, like dev, staging, and production

You can now copy experiments across different projects in your organization.

There’s now a new subscriptions page for you to manage all of your subscriptions from any insight or dashboard.

Insights can now automatically generate names and descriptions with AI. Click the ✨ button to give it a try.

Batch Exports now have a History tab showing the full activity log. See exactly what changed and when, right from the batch export page.

In Data Warehouse, you can now copy query results from the SQL editor as Markdown. Handy for pasting tables into LLMs and agents.

Insights now have a Recent tab, so you can quickly reuse events and property filters without searching for them again. Recent property filters even restore the previously used value.

Matching recent items also appear in Suggested filters.

You can now organize your saved views into folders in the SQL editor for Data Warehouse. Keep things tidy as your view count grows.

Dashboard insights now have a Alerts option in their menus. Jump straight to an insight's alerts and manage them without navigating away.

Click and drag the timeline within an Error Tracking issue to filter exceptions to a specific time range. Hovering shows the exact date as you move across the chart.

Set up a filter in Logs once, save it, and it's there whenever you need it. Find saved views under the new Saved views button.

Sometimes 1% is too many people. Feature Flags now support decimal rollout percentages, so you can roll out to 0.5%, 0.1%, or wherever you want to start.

Right-click any label in a trends insight to isolate a series or toggle everything else off. Good for when your chart is a little too honest.

Experiments now supports CUPED - a statistical method that cuts experiment variance by 20–40%. Same data, sharper results.

Stack traces in Elixir error tracking now include source code context when enabled. There's also a new dedicated setup page to get started.

Copy Experiments and early access features between projects. Start from something that already works.

The Vercel integration now includes a project picker, so you can link an existing PostHog project and get feature flags and environment variables syncing properly.

Teams can now pin their posthog-js snippet to a specific major, minor, or exact version. Update on your own terms, not ours.

You can now use data warehouse sources directly in funnel and lifecycle insights. This lets you analyze conversions and user behaviour using warehouse tables, combine them with events that already live in PostHog, and explore complete journeys in a single insight.

You can:

• build insights using only warehouse data, including multiple tables or the same table with different configurations
• combine warehouse sources with PostHog events in one insight
• click through to persons or groups when working with person or group level data
• filter and break down by data warehouse properties
• use step funnels, time to convert analysis, and historical trends

To learn how to set up these insights, see the docs here: https://posthog.com/docs/data-warehouse/insights

Your dashboards can now link out to internal pages, external tools, or anywhere else your team needs. Add a button tile and make dashboards your actual home base.

Cluttered dashboards? You can now show or hide labels on individual insights without leaving your dashboard.

Copy widgets and text cards between dashboardsdirectly from the dashboard page. Great for keeping related insights in sync.

Surveys now supports the following features in the latest version of all mobile SDKs:

• Event trigger property filters
• Repeated surveys (show every time)
• Survey wait period (do not show to anyone who saw a survey in the past N days)

Update to the following SDK versions to give it a try!

• React Native: 4.16.0+
• iOS: 3.47.0+
• Android: 3.38.0+
• Flutter: 5.20.0+

You can now add CC and BCC for email actions in Workflows.

You can now copy actions, insights, and cohorts from one project to another.

Early access opt-outs can now be overridden when promoting a feature to general availability.

Previously, users who opted out of early access features would never receive them, even after general release.

You know what’s annoying? Trying to get exactly 25% on a percent slider using a track pad.

This change adds clickable tick marks to the feature flag rollout percentage slider, making it quicker to set common percentages like 10%, 25%, or 50% with a single click.

You can now audit activity logs with the help of your favorite AI agents using the activity-logs-list MCP tool.

You can now break down your funnels by cohorts.

You can now use a rich markdown editor when editing text cards on the dashboard.

Publicly accessible and embedded dashboards auto-refresh every 30 minutes by default. This requires no configuration and is enabled automatically when the page is open.

No more stale dashboards!

If you have known or noisy exceptions that you don’t want in Error Tracking, you can suppress them with suppression rules.

You can also choose to sample some percent of a frequently occurring error to track, which can lower costs.

TypeForm is now available as a Data Warehouse source to pull your forms and answers into PostHog.

Materializing queries greatly improves performance and reduces cost by precomputing results periodically. You can now materialize timestamp based query filters through timestamp bucketing.

LLM Analytics now supports the Pi Coding Agent using the @posthog/pi extension. Try it by following the LLM Analytics installation docs.

Clusters is a new feature in LLM Analytics which automatically groups traces and generations. It runs once a day and sorts the last 7 days of AI activity into similar buckets.

Each bucket gets a name and summary – we even attach some nice metrics to them like cost, latency, error rate, and token usage. This helps you quickly understand LLM usage patterns, track trends, and detect unusual behavior.

There's an interactive 2D scatter plot chart to visualize clusters. Click any of them to dig in deeper.

You can now view persons for funnel insights that are aggregated by sessions. Select a funnel step to explore which users converted or dropped off at each stage.

You can now choose which insights to include in dashboard subscriptions. This enables you to tailor notifications and share relevant parts of a dashboard with different teammates.

Error Tracking is now supported by our iOS SDK. Configure exception autocapture or use captureException to manually capture exceptions with custom properties.

View the installation guide to get started.

You can now visualize numeric property distributions over time using box plot charts in Product Analytics. Box plots show quartiles, median, mean, and min/max values, helping you understand how a metric’s distribution changes across time periods.

The email template editor for Workflows now lets you hide metadata fields so you can focus on writing your content. You can toggle their display in the top right.

You can now sort exceptions by property with quick filter shortcuts in Error Tracking.

Error Tracking now sends a weekly digest email per organization, with a section for each project that has activity.

You can also manage notifications, including selecting which projects should send weekly digest updates. By default, PostHog will automatically enable notifications for the busiest project in your organization, but you can customize this anytime.

Error tracking now has a new tabbed layout. Configuration lives in its own tab. A new Insights tab includes stats and charts showing exception count and crash-free session rate over time, which you can add to dashboards with a click.

You can now send alerts to Slack or Discord from events in Error Tracking. Get notified when new errors occur or error rates spike.

Navigate to Configuration > Alerting to get started.

You can now move dashboards into folders directly from the All dashboards view.

You can now connect your Pinterest Ads account as a Marketing Analytics data source to track campaign performance alongside your other ad platforms.

See cost, impressions, clicks, conversions, and more.

You can now add Sentry as a new data source for Data Warehouse, enabling users to connect their Sentry data to the PostHog platform.

Experiments can now be created and launched without metrics. Roll out variants and start gathering event data right away. Metrics define how results are measured, so add, modify, or delete them whenever you're ready.

You can now connect your existing PostHog organization to Vercel Marketplace instead of creating a new one. Billing stays with PostHog, your data stays put, and you avoid the hassle of setting up another account.

Our Support product (in private alpha) now tracks Service Level Agreements (SLAs). First response and resolution times are tracked automatically and visible in a new SLA column in the ticket list. Hold your team accountable, or at least pretend to.

Before running a batch export backfill, you can now see an estimated row count so you know what you're getting into. Surprised by the volume? Cancel before it runs.

B2B product? Your weekends probably look like a ghost town. Toggle Hide weekend data under Options > Display in Product Analytics to filter out Saturday and Sunday and keep your charts focused on what actually moves.

Workflows now auto-saves as you go. Edit live workflows via drafts before publishing, with visual indicators for unsaved changes and deleted actions. Ship when you're ready, not when you accidentally close the tab.

Custom tags are now available for our Support product (in private alpha). Finally, a filing system you actually designed yourself.

The Product Analytics dashboards table now includes a Project column, so you can see exactly where each dashboard lives at a glance.

Large numbers in data visualizations can now be displayed in short format. Think "1.2K" instead of "1,200" or "1.5M" instead of "1,500,000". Find it under the formatting options in Product Analytics insights. Your dashboards will thank you.

Track crashes and exceptions from the React Native SDK

You can now recover your support tickets when you move across browsers by sending a recovery link through email.

See the location of your visitors in real time on your Web Analytics dashboard.

You can now manually control Session Replay recordings with start and stop methods in the React Native SDK.

// Start recording (resume current session)
await posthog.startSessionRecording()

// Start recording with a new session
await posthog.startSessionRecording(false)

// Stop recording
await posthog.stopSessionRecording()

Do you have a TV in your office that you’re not using? Play real session recordings on a loop using kiosk mode!

This helps your team pick up user behavior patterns and is more fun than watching TV screen savers.

You can filter by nearly any property in PostHog. Endless possibilities and endless distractions.

PostHog now suggests the most commonly accessed filters, like URL, email, and screenname to help you build insights faster.

Adds a "last seen" column to the persons list, person profiles, and notebook nodes, allowing users to quickly see and sort by a person's last activity time.

Proxies help you get around ad blockers when capturing events. You can now set up a proxy for free using PostHog’s managed proxies.

Do you use Claude?

Access your analytics, feature flags, experiments, and error tracking directly from Claude using the official connector.

After connecting, try asking Claude a question about:

• "How many unique users signed up in the last 7 days, broken down by day?"

• "What are the top 5 errors in my project this week?"

• "Create a feature flag called new-checkout enabled for 10% of users"

• "Create an A/B test for the pricing page that measures conversion to checkout"

You can now view live PostHog events directly in your terminal using the posthog-live CLI tool.

Adds a Pull new schemas button to pipelines. Users can now instantly refresh schema updates, grabbing the latest changes without waiting for a scheduled sync to kick in.

You can combine multiple events into a single funnel step using inline combination. This lets you treat several events as one step without creating a custom action.

You can now use Slack as a support channel by adding the SupportHog Slack app. There are three ways to create a ticket:

• Use a dedicated Slack channel where every message creates a ticket
• Mention the SupportHog bot in any channel where it’s installed
• React to a message with a configured emoji

You can now clearly see the access levels granted to each role and member in access control settings. This reduces confusion when configuring access controls at multiple levels.

You can now manage dashboard layouts with Terraform.

Adds a Sync now button to easily sync all enabled schemas in one go, replacing the need to sync them individually. Also includes a schema count in the table view.

You can now access cohort operations through the PostHog MCP!

Setup the PostHog MCP and try one of these prompts:

• "Create a dynamic cohort called 'power-users' for users who completed the purchase event more than 5 times"
• "Create a static cohort called 'beta-testers' that I can manually add users to"
• "List all cohorts in my project"

Need to know who changed what? And when? Ask PostHog AI in chat. It searches your activity logs and finds answers instantly.

You can ask questions like:

• When did the beta feature flag change?
• Who logged into my PostHog organization yesterday?
• Who ran the latest A/B experiment for the home page?

Workflows now supports organization-level scopes for creating templates. Templates can be shared across all projects within an organization.

You can now manually control [Session Replay] recordings with start and stop methods in the Flutter SDK.

• startSessionRecording({bool resumeCurrent = true})
• stopSessionRecording()

Attach images and screenshots to custom event definitions to add visual context.

Instead of remembering or decoding a long list of vague event names, you can glance at an image and choose the right events for the funnels and insights you’re building.

In Workflows, we’ve added an interactive JSON tree picker that lets you click through a step’s response to select the exact data path. You can also store multiple variables from a single step.

You can now create Jira issues directly from Error Tracking, making it easier to triage and track errors alongside your existing systems and workflows.

In Session Replay, we’ve added a new synthetic collection for frustration signals like rage clicks and errors, making it easier to spot user pain points.

You can now reject events with invalid schemas at ingestion. You can validate the presence and type of required properties and block events that don’t match, helping you keep your data clean and reliable.

You can now copy dashboards from one project to another directly from the dashboard’s context panel.

Evaluations in LLM Analytics now supports Firework API keys, enabling you to bring-your-own-key (BYOK) alongside other providers like OpenAI, Google Gemini, Anthropic, and OpenRouter.

You can now export up to 10,000 Logs into a CSV file. Get them printed, turn them into a book, or just analyze them in a spreadsheet. The possibilities are endless.

Want to send plain text emails in Workflows without any fluff and styling? We gotcha.

You can now switch to the plain text editor and send the barebones emails you always wanted to send.

You can now connect Amazon Redshift as a data source in your PostHog project. Supports both direct connection strings and secure SSH tunnels for flexible integration.

When an Experiment metric fails, you now get clear error messages with actionable options: retry the metric, report the issue to support, or debug. No more cryptic errors leaving you wondering what happened.

It’s like spring cleaning for Feature Flags. Select multiple flags and delete them in one go. We’ll even give you PostHog AI-powered suggestions to clean up corresponding code references.

Experiments can now summarize session replays related to your experiment results. Get qualitative feedback to understand the story behind the stats. Because numbers alone don’t always tell you why users behave the way they do.

If you’re logging with a sessionId, you can now see related errors right in log details. The new Related errors tab shows error tracking issues from the same session within a 6-hour window. Debug production issues without a tab-switching workout.

We redesigned the access control settings to be more intuitive and easier to use.

You can now send private messages in support tickets that only your team can view.

PostHog AI can now carry out deep research for in-depth data analysis.

When you select research mode, PostHog AI will conduct research in two phases: Planning phase: Creates a structured research plan notebook Research phase: Executes the research plan and generates a final report

Deep research is ideal for complex tasks like root cause analysis, cross-metric investigation, strategic analysis, and comprehensive audits. Learn more in the docs about research mode.

You can enable browser notifications to get an alert when new support messages arrive.

You can configure autocapture controls to selectively enable autocapture based on the scenario. You can create rules based on:

• URL matching
• Event triggers
• Feature flag
• Sampling rate

Click Enable autocapture controls in the Exception autocapture settings to configure them.

You can now link Attio as a data source in your PostHog project to access CRM data for analytics.

We’ve added a dedicated area to view and manage SQL variables, including where variables are used inside saved insights.

You can now link Mailchimp as a data source in your PostHog project. This lets you access campaigns, contacts and report data in PostHog.

Now you can break down your experiment results by event properties. Click on the breakdowns button in the bottom right corner of your metric title and select up to three event properties to break down your results.

Made a mistake? Has your workflow changed? No problemo! You can now re-arrange actions and adjust your workflow to your needs!

You can now estimate running time of an experiment, even while it’s a draft.

It can be tedious to keep event definitions up to date in PostHog, so automate it with the event-definition-update MCP tool.

You can now link GitHub as a data source in your PostHog project. This lets you access commits, issues, pull requests, releases, and stargazer data in PostHog.

Adds a visualization tool to make survey branching logic easier to understand and manage when creating surveys.

Now you see me, now you don’t.

You can now add OpenRouter API keys to run LLM Evaluations with. This gives you access to all the models and providers supported by OpenRouter!

PostHog is now the final destination for your logs. Logs is generally available, and it lives in the same place as your errors, session replays, and product data. The place where an investigation begins is now also where it ends.

TL;DR

• Logs is now available for free, up to 50 GB for free every month.
• Then pay $0.25 per GB ingested, (or $0.15 per GB at 300 GB+).
• 14-day retention, no per-seat pricing, no query fees.
• Frontend and backend context, linked to users and sessions.
• Uses standard OpenTelemetry – no proprietary SDKs.
• Structured logs you can pivot around, not raw text you scroll through.

Bring PostHog's beloved hedgehog mascot to any website! An adorable animated companion that walks, jumps, and keeps you company while you browse.

Download the repo and add the browser extension.

Databricks officially in open beta for batch exports. Move data securely and smoothly between your PostHog projects and Databricks workspaces.

You can now sign up and create PostHog accounts using passkeys. One less password to forget.

LLM Analytics now tracks time to first token (TTFT) for streaming responses, so you can see how quickly a model starts responding – not just total duration. This makes it easier to spot latency issues, compare providers, and optimize the experience where fast initial responses matter most.

You can combine multiple events into a single series using inline combination, allowing you to analyze trends without creating custom actions.

Select the events to include, and they will be treated as a single series in your analysis. The combination uses a logical OR, so any occurrence of the selected events will count toward the series.

It’s time for us to make less money.

Event definitions are now free for all users. You can add metadata like descriptions, tags, and statuses to keep your events organized.

These definitions also show up when searching for events throughout PostHog, providing more context and quick access with filters.

Still making less money.

Tagging is also now free for all users. You can add tags to dashboards, insights, actions, and even feature flags or experiments. Use tags to filter, search, and stay organized as your product data grows.

Batch exports can now be scheduled. You can set the timezone and start time for daily exports, or choose a weekly schedule with a specific day and hour.

We have a new visualization type for SQL queries: 2D heatmaps!

It’s helpful for visualizing metrics across two categorical dimensions with color intensity representing the value. For example, with LLM analytics, you can compare latency across providers and task types at a glance, identifying which combinations have performance issues.

Experiments can now be paused and resumed, making it easy to temporarily halt experiments if need be. The pause action is available behind the ... button next to ship a variant.

The Power Users table in Customer Analytics now includes MRR and LTV columns for individual users, so you can quickly spot your highest-value customers.

New search is here! Access it via Cmd+K or /search. Find workflows, paste email addresses or distinct IDs to jump to persons, and enjoy a leaner, faster search experience.

Passkeys now work for two-factor authentication. Use them for login instead of typing codes like it’s 2015.

Group profiles now show Monthly Recurring Revenue (MRR) and Lifetime Value (LTV) pulled directly from Revenue Analytics, with visual indicators showing where the data comes from.

Persons and groups lists now show total record counts and how many match your current filters in Customer Analytics. No more guessing how much data you’re looking at.

Set an error rate threshold for notifications with Data Pipelines. Only get pinged when things are actually broken, not for every little hiccup.

Set a team-level default confidence level (90%, 95%, or 99%) for new experiments. The default applies automatically, but don’t worry, you can override it per experiment when you need to.

Evals are now in public beta for LLM Analytics. Run AI-powered tests that verify AI outputs against curated inputs to test prompt performance, spot regressions, and compare model versions. Use templates or create evaluations from scratch.

When viewing Logs, clicking a distinct ID in your browser logs now takes you straight to that person's profile. No more copy-pasting IDs to track down users.

Embed PostHog Surveys as iframes on your site. Create a hosted survey, enable embedding, copy the code, and paste it into your HTML - automatic resizing and distinct IDs included.

Get an email whenever a passkey is added or removed from your account, so you’ll know immediately if someone makes security changes.

Integrate Linear, GitHub, or GitLab with Session Replay. Enable integrations in replay settings and create or link issues directly from the activity panel. Spotted a bug? Ship it to your issue tracker without leaving the replay.

We updated our filters in workflows so you are able to do the following things:

• Filter out internal- and test-users: Just like with Destinations you can now filter out internal- and test-users from your event triggers by flipping the toggle!

• Use persons timezone: When waiting until a specific window to move to the next action you can now use the persons timezone to do that instead of a hard-coded timezone that applies to all of your customers!

We now support experimental CLI commands for managing the Endpoints product via YAML files. You can now run commands like posthog-cli exp endpoints pull monthly-active-users or posthog-cli exp endpoints push ./monthly-active-users.yaml.

The posthog-cli exp endpoints set of commands include:

• list - list all endpoints
• get - show the state of the endpoint
• open - open the endpoint's page in PostHog
• pull - pull remote endpoint to a local YAML file
• push - push local YAML to remote endpoint
• diff - what it says on the tin, show the diff between remote and local
• run - for when you don't want to push yet, but you want to see the effect of your query changes on the query results

Stop stashing SQL in Typescript comments. Save materialized queries as code instead.

Azure Blob Storage is now available as a Batch Exports destination, with built-in validation and connection testing to help you configure exports confidently.

Smart meets polite: PostHog AI now asks you for approval before making changes. We’ve added a confirmation step for PostHog AI dashboard edits, preventing accidental data loss or unexpected changes.

You can review proposed updates, approve or reject them, or add extra before PostHog AI applies them.

Feature Flags now support semver (semantic versioning) operators in our targeting UI, enabling you to target users based on app version comparisons like "greater than 2.0.0" or "matches ~1.5.x range."

You can now fully customize the in-app sidebar. Pin the products you use most, organize your shortcuts, and enable auto-suggestions for new apps.

Your sidebar, how you like it.

Logs are going down in history! Or your queries at least. Your last 10 logs queries are now saved in a handy-dandy history bar.

You can now configure and customize which tiles appear on person and group profiles.

Click the edit button on any profile to toggle tiles on or off: properties, events, related records, whatever you need. Your layout is saved project-wide. Hit reset to return to discard your changes.

Materialized endpoints now support 5x higher rate limits with smart caching. You can query your data more often without hitting limits.

Click View details on any log entry to open a modal with timestamps, severity, a collapsible JSON viewer, and AI-powered analysis. Dive into individual log lines without losing your place (or your mind).

Toggle zen mode with a keyboard shortcut (Cmd/Ctrl + Option + Z) or from your account menu. Hide distracting UI elements for a more peaceful experience.

Create your own workflow templates or use official ones to speed up repetitive tasks across your team.

PostHog AI can now summarize open-ended survey responses. It surfaces key themes and insights, saving you the headache of reading responses manually.

Click into any log entry to find a new “Explore with AI” tab. It analyzes severity, impact, probable cause, and suggests actions.

Control who can view your shared experiment metrics through a new access management panel in the sidebar.

You can now find average time on page metrics under Web Analytics > Pages reports tab.

You can create surveys that target a specific section of a Web Analytics breakdown, such as users entering from a common path, from a common referrer, or entering with a common UTM parameter.

Switch tabs and come back to your replay without losing your place in the video. Session Replay now remembers where you were, so you can multitask without the dreaded reload.

Get real-time alerts when changes occur in your PostHog project. Send activity log updates to Slack, Discord, Microsoft Teams, or a custom webhook. Filter to see only the events you care about.

This feature is available on Scale and Enterprise plans.

With the Terraform provider, users can manage their resources through Infrastructure-as-Code (IaC), creating an auditable and enforced single source of truth. This is great for use cases like deploying golden signal dashboards.

Enable it now under feature previews.

PostHog AI can now reference up-to-date information about the world and conduct research on the internet.

• This lets PostHog AI handle advanced prompts and use cases like:
• Is the recent dip in traffic related to an AWS outage?
• How does our conversion rate compare to industry benchmarks published this quarter?
• Why might signups to my ticket sales portal have tripled this week for Brazilian users?

Did you know that you can navigate PostHog with keyboard shortcuts? You can find a list of available shortcuts with Cmd/Ctrl + Shift + K.

Below are some new shortcuts we just released:

Tired of creating the same nodes over and over again in your workflow? You can now duplicate existing workflow nodes by clicking copy.

You can now reorder pinned log columns by clicking a column, then clicking move left or move right.

You can now track retention performance against custom goals set by your team. When editing an insight, you can find the new goal lines under Advanced options > + Add goal line.

There’s now a recent items button on the top nav to help you return to recent tabs and page.

You can now set assignees and labels when sharing a recording as a Linear issue. Find these under More options.

You can now share recordings to GitHub Issues. Find it under the Share menu in any session recording.

You can now customize the confidence thresholds of experiments.

What’s better than reading the changelog on our website? Reading the changelog directly in PostHog, of course!

PostHog AI now respects resource-level access controls you define. If someone don’t have permission to view or create something, like insights or feature flags, they won’t be able to create it through the PostHog AI chat either.

Go to Settings > Access in your PostHog project to set resource-level permissions.

Marketing Analytics is now available to everyone. Track campaigns, costs, and conversions across multiple advertising platforms, all in one dashboard with pre-built insights that help you understand your data and performance.

Starting from a blank canvas can be hard. You can now save workflows as templates and give your team or organization a library of ready-to-use campaigns.

PostHog AI now automatically adds clear titles and descriptions to the insights it creates, so dashboards are easier to scan.

Endpoints now have a new rate limiter that supports up to 10 concurrent materialized endpoint executions, which perform much better than traditional API calls.

Experiments now support retention metrics, helping you understand impact over a specific window of time. It answers the question: "Of the users who did X, how many came back to do Y within N days?"

To create one, define a start event, completion event, and retention window.

Endpoints can now materialize from insights, not just raw PostHog SQL. We automatically convert the insight query into PostHog SQL and then store that when materializing for execution, making it easier to turn insights into reusable, performant endpoints.

The Surveys UI customization is now more organized and easier to use. Settings are now grouped into new sections, you can control text colors directly (with helpful auto-contrast hints), and the layout is responsive.

Logs can now prettify individual rows making them easier to read. Each row has a toggle next to the pin icon, and you can press P to prettify the currently focused log. Prettified rows also wrap automatically, so long log lines are easier to scan.

You can now pass multiple directory arguments to the PostHog CLI when injecting and uploading source maps.

posthog-cli sourcemap inject --directory dir1 --directory dir2

Try it on the PostHog CLI for version 0.5.19 and above.

You can now deliver SMS alerts triggered by PostHog events through Kudosity. Try the new Kudosity realtime destination template.

You can now quick-add an attribute as a display column when triaging logs by clicking the column icon.

Your PostHog Endpoints now come with OpenAPI 3 specification for each endpoint under /openapi.json.

For example, if you have an endpoint at:

/api/environments/2/endpoints/hello_world/

You’ll find its OpenAPI specs at:

/api/environments/2/endpoints/hello_world/openapi.json

You can now set your scheduled feature flag changes to repeat daily, weekly, or monthly. For example, you can disable a feature flag during Black Friday sales to mitigate risk, or automatically disable a flag over the weekend when you expect the most traffic to your site.

Do you develop mobile apps with the iOS, Android, Flutter, or React Native SDK?

You can use the mobile crash-free rates dashboard to automatically compute crash-free user and session rates to help you monitor your app’s stability.

PostHog AI can now help you automatically configure Customer Analytics events that correlate to user behavior – like daily activity, signing up, subscribing, and completing a payment.

The manual process can be tedious, so why not let PostHog AI help?

You can drag to resize the session recording player.

PostHog AI can now read 📊charts!

Previously, PostHog AI could search for insights and dashboards, but it could not make sense of the data inside. Now it can find your existing insights and dashboards, analyze their contents, then answer questions using their data.

PostHog AI can now hold ten distinct conversations with you in parallel – which according to maths means 10x the output, right?

Open PostHog AI and try starting multiple tabs and conversations.

You can now pin breakdown columns when viewing insights so you can keep track of the breakdown values as you scroll horizontally through the table.

Enables users to bring their own OpenAI API keys for running evaluations. Users get 100 free evaluations to kick things off with LLM Analytics before needing their own key.

You can now send feedback to PostHog AI directly in the chat with the new /feedback command. Just leave a quick comment.

PostHog AI now lets you open session recordings directly in the chat from filtered results. Go from insight to playback in one click.

Learn more about PostHog AI session summaries.

The PostHog Toolbar now warns you when an action uses a fragile CSS selector that’s likely to break. We’ll also (politely) nudge you toward more stable selectors with recommendations.

When linking Stripe as a data source, you can now use our pre-configured URL to open Stripe’s restricted API key creation screen with the required permissions already filled in – saving you a few clicks and at least a few dozen keystrokes.

Non-integrated conversions (those with UTM parameters that don’t match any integrated campaign data) are now shown in a separate table in Marketing Analytics.

You can map sources or campaigns using cell actions, or map both together using row actions.

There’s a new Health tab that shows how your Web Analytics installation setup is doing at a glance. If something important is missing, you’ll see an alert so you can make fixes to get accurate metrics.

You can now expand log rows to see all their attributes in Logs. When expanded, it’s easy to add or exclude filters, break things down by attribute, or copy values.

The power users table in customer analytics and person profiles now show when each user was last seen, so you can quickly tell who’s active and who isn't >:(

There’s now a manual calculation mode in the running time config for Experiments. Plug in your baseline conversion rate (or average events/property value), daily exposure, and MDE to calculate sample size and estimated running time.

It’s useful when planning experiments before launch.

You can now view reported conversion value and ROAS (return on ad spending) directly on Marketing Analytics trend lines.

You can opt into the Marketing Analytics beta in feature previews.

Logs is here, and it's in beta. It's free to use.

Thinking of a fire now the weather's getting colder? WELL THEN YOU WILL NEED LOGS.

Learn more about Logs

You can now connect your Supabase database to PostHog as a data source. Import tables from Supabase to combine with your product analytics data for deeper insights.

Learn more about querying Supabase data

PostHog AI now asks for feedback on your overall conversation experience. Rate how helpful the conversation was, and if something didn’t work well, you can open a support ticket directly from the chat.

This feedback appears at smart intervals to avoid interrupting delivering value for shareholders. Be honest – the AI can take it.

Setting up error tracking in React Native apps using Expo is now easier with the new posthog-react-native/expo plugin. It automatically patches the necessary files for source map uploads, so you can spend less time configuring and more time shipping.

Learn more about React Native error tracking

When viewing a person’s feed in a notebook, PostHog now automatically filters events to show only those related to that person. No more manually setting up filters every time you want to analyze a user’s journey.

PostHog now warns you before launching a survey if you’re using features that aren’t supported by your current SDK version. No more launching surveys into the void wondering why they’re not showing up.

PostHog now automatically summarizes your LLM traces every hour in the background. These summaries are generated using GPT-4.1 mini and will power upcoming clustering features that help you spot patterns across thousands of traces.

PostHog AI’s session replay mode just got a lot smarter. It now separates recording filtering from session summarization, giving it better context for analyzing your replays. PostHog AI can now research events and properties more effectively and supports “had event” filtering.

TL;DR: It asks better questions before diving into your sessions, which means more accurate insights when you ask PostHog AI to analyze user behavior in recordings.

You can now generate strongly typed Python event definitions straight from your PostHog schemas. Get autocomplete and type checking for your events, so you never have to guess if it’s user_signed_up or user_signup again.

Access it using the API endpoint or use posthog-cli to generate typed Python files for your project.

Learn more about schema management

You can now create surveys directly from your customer analytics funnels. Spotted a drop-off in your funnel? Click the ask users why button to survey customers that bailed at that exact step.

You can now name your conditional branches in workflows. Give them descriptive names like “Ideal customer profile” or “Churned users” or “Free-tier freeloaders” instead of trying to remember what each conditional branch does.

You can now use feature flags, HogQL, and person property filters in batch exports, not just event property filters. This brings batch export filtering up to speed with what you can already do in workflows.

Learn more about batch exports

You can now use error tracking on Android even with minified builds. Install the PostHog Android Gradle plugin to automatically upload your app’s symbol mappings and get readable stack traces.

Learn more about Android error tracking

Monitor your logs in real-time with the new “live tail” toggle. Watch new log entries appear automatically as they’re captured, without manually refreshing your search.

Adds a new Surveys tab on individual persons profiles, so it’s easier to find survey responses from an individual.

New dive deeper section introduced below insights.

Use the recommended related insights to explore and understand your data better.

You can now add session properties as a column in your activity feed.

You can now add Bing Ads as a new data source for CDP.

You can now copy a read-only link to any PostHog AI conversation to share with teammates. The link opens a new window of PostHog AI and displays the conversation.

These links aren't public, users still need access to the organization to view the conversation.

It works. It doesn’t throw an error. That’s it.

SELECT 'hell_yeah' AS can_i_semicolon;

(You can finally add ; in PostHog SQL)

Introduced a new Feed tab in the left-hand navigation. In your feed, you’ll find:

• AI powered discoveries, like suggested insights, dashboards, experiment summaries, and more.
• Updates from your team, like new dashboards, events, experiments, feature flag roll outs, and more.
• Filter for specific changes, by event type or by author. Use feed to stay up to date with your team’s changes in your PostHog projects.

Feature flag responses now include an $feature_flag_evaluated_at timestamp to make debugging timing-related issues much easier.

PostHog AI now automatically selects special agent modes for analytics, SQL, and session replay.

You can expect better, faster and more accurate responses in these specialized modes.

Try asking PostHog AI a question like, show me pageview data in SQL .

Don’t understand Bayesian statistics or the frequentist method? Summarize experiments with PostHog AI to help you understand the results and make informed decisions.

Ask PostHog AI to summarize an experiment, or read about boring maths in the experiments docs

You can now create feature flags with the power of your mind!

PostHog AI just hit general availability. We opened it up to everyone because productivity at this scale is simply too good to keep locked up.

• Search and filter: Find insights, filter session recordings, search the docs (it's basically Cmd+F for PostHog and your data)
• Write SQL: Generate and debug queries without switching tabs (PostHog AI knows your event names, properties, and actions)
• Create and modify: Build dashboards, create insights, set up surveys, feature flags and funnels (get complex outputs from simple instructions)

You get 2,000 free credits every month to use AI features in PostHog ($20 value).

P.S. In beta we called it "Max AI" which is kind of like calling Godzilla "Larry." We fixed this.

PostHog AI can now create experiments for you, just explain what your experiment should look like, then relax and let the AI cook your variants for you.

You can now customize your LLM analytics dashboard just like any other dashboard. This means you can:

• Add custom text cards and labels
• Import custom insights
• Reuse this dashboard across the platform

Quickly understand LLM trace behavior with AI-generated summaries that provide actionable insights at a glance. Choose minimal mode for 3-5 bullet points or detailed mode for 5-10 comprehensive points with ASCII flow diagrams.

Summaries include:

• Clickable line references that jump directly to specific lines in the text view
• Highlighting of interesting patterns, errors, or unusual behavior

You can now monitor and debug errors in your React Native applications with automatic crash reporting and stack traces for JavaScript and native errors.

Enable error tracking with a single configuration flag in the React Native SDK.

You can now link to GitLab sources when creating releases in error tracking. Click the view commit button in your stack traces to see the referenced file in GitLab.

Create event definitions directly in the PostHog dashboard before any events are captured. Define the event name, add an optional description, assign an owner, and add tags to organize your events. First seen and last seen timestamps will be automatically set when the first actual event is ingested.

Customize where your feedback button appears on your pages. Feedback button surveys now support multiple position options beyond the default right side placement.

You can now delete stuff right in the product OS sidebar. Try right-clicking or selecting the kebab menu beside an item, and hitting Delete. Most deletes allow you to click Undo if you change your mind.

(This action can be irreversible, so please don’t delete anything important)

You can now define schemas for your PostHog event properties, enabling you to:

• Define events upfront: Create event definitions before implementing instrumentation to get type safety from day one.
• Label groups of properties: Name groups by their purpose (e.g., "E-commerce Properties", "User Context").
• Make your analytics more maintainable: Avoid breaking your analytics implementation by adding type safety to your queries.

Event schemas are optional and builds guardrails around your critical events. You can still define arbitrary events during capture.

Read the docs to learn more

Have any outdated, unhelpful, or irrelevant survey responses laying around? Archive them to reduce noise. You can also un-archive them later or show archived results, nothing’s lost.

Releases are versions of your application that have been deployed. These contain git metadata such as the commit SHA, branch, and repository URL, which helps you track down the source of errors.

They are automatically created when you upload source maps to PostHog.

You can now find a record of all your releases in your error tracking settings.

You can now pin logs to easily compare them side by side. Remember to enable prettify JSON to make logs easier to read.

In the overview properties of a session replay, you can click the filter icon beside a property to search for other sessions with a common property.

This lets you quickly filter for sessions with similar referrers, belonging to the same user, and more.

The web SDK can now automatically ignore rage clicks on buttons and links for navigation. This includes elements with aria-label that contain next, previous, prev, >, <.

To enable this on your projects, update your configuration defaults to 2025-11-30 like this:

posthog.init('<ph_project_api_key>', {
   api_host: '<ph_client_api_host>	',
   defaults: '2025-11-30',
})

You can still manually configure more ignores using the rageclick configs

You can now schedule workflows to be triggered for a later date and time.

You can copy web analytics data directly to your clipboard in multiple formats, including CSV, JSON, and XLS.

In error tracking, you can use code variables to see the state of variables in each stack frame. This makes it much easier to understand the exact state your application was in when the exception occurred and eliminates the need to reproduce errors locally.

Read our docs for more details.

You can now plot specific time periods in retention insights. Select individual weeks or months to visualize and quickly see how retention is improving over time.

The sessions model for batch exports is now generally available. You can now export session-level data to destinations like S3, Snowflake, Postgres, BigQuery, and more.

In the workflows email editor, you can now save any email you’re working on as a reusable template at any time.

You can now pause and resume managed migrations, giving you more control and flexibility to deal with rate limits as you bring data over from S3, Mixpanel, or Amplitude.

Check out the docs to learn more about managed migrations.

We’ve added velocity stats to your experiments to help keep track of your launch cadence. Stats for your stats!

Filter your event definitions by specific tags for easier, more streamlined event management.

You can now define custom time brackets for retention insight, enabling you to specify your own intervals for analyzing user engagement.

We’ve updated the UI for session replay filters and added new shortcuts that let you instantly filter by email, user ID, path name, and URL.

You can now import opt-out or unsubscribe lists from Customer.io into PostHog, making it easier to migrate your messaging setup without losing your users’ existing communication preferences.