PostHog is an open-source product analytics platform tracking user interactions and behaviors to help teams refine features, improve funnels, and reduce churn
Triggers when an event matches one of the saved PostHog Actions you configure. Use this instead of Event Captured when the behaviour you care about spans several event names or element matches, and you want PostHog's Action definition to stay the single place it is described. Deliveries count toward your PostHog data pipelines usage, so it pays to watch just the Actions you act on.
Triggers when PostHog records an activity-log entry for the project — any audited change to a feature flag, insight, dashboard, destination, experiment or survey. This is the whole audit stream, so it is high volume; branch on `scope` and `activity` for the changes you care about.
Triggers when an early-access feature changes — most usefully when it moves between stages, such as concept to beta to general availability. The payload carries the whole feature both before and after, so compare `previous` with `next` to see what moved.
Triggers when an error-tracking issue is assigned to a user, a group or a role. Reassigning an already-assigned issue fires it again; clearing an assignee fires Error Tracking Issue Unassigned instead.
Triggers when PostHog groups an exception into an error-tracking issue it has never seen before. Fires once per issue, on the first occurrence — later occurrences of the same fingerprint do not fire it.
Triggers when fingerprints are split out of an error-tracking issue into new issues of their own. The payload is the original issue; `split_issue_ids` names the issues that were created.
Triggers when an error-tracking issue is resolved, reopened or suppressed. One trigger covers all three moves because PostHog sends an identical body for each; branch on `previous_status` and `status` to tell them apart.
Triggers when an error-tracking issue's assignee is cleared, leaving it unowned. Reassigning to a different person fires Error Tracking Issue Assigned instead, not this.
Triggers when two or more error-tracking issues are merged into one. The payload is the surviving issue; `merged_issue_ids` names the ones that were absorbed, so anything you track against those ids should be repointed.
Triggers when PostHog captures one of the analytics events you name. Fires on every matching event, including ones your backend or a third-party integration sent, not only browser events. Deliveries count toward your PostHog data pipelines usage, so it pays to name just the events you act on.
Triggers when a person's profile changes in PostHog — a property set, updated or removed, or two people merged into one. Everything the trigger reports is in `person`: PostHog synthesises the event around the updated profile, so `event` carries no properties and `event.distinct_id` holds the person's id rather than a distinct_id. Every profile change in the project is a delivery and deliveries count toward your PostHog data pipelines usage, which is worth knowing if your project updates people in bulk.
Retrieve account notebook in a PostHog project.
Add collaborators to a specific project dashboard. Requires 'project_id' and 'dashboard_id'. Supports JSON, form-urlencoded, and multipart data. Returns added collaborator details. Auth: 'PersonalAPIKeyAuth'. IMPORTANT REQUIREMENTS: 1. The dashboard must have restriction_level > 21 (not on the lowest restriction level). Use POSTHOG_PARTIAL_UPDATE_OF_A_PROJECT_S_DASHBOARD to set restriction_level to 37. 2. The user being added cannot be the dashboard owner or a project admin (they already have inherent access). 3. Currently only level 37 (edit access) can be explicitly specified. 4. Use POSTHOG_LIST_ORGANIZATION_MEMBERS_WITH_PAGINATION to find valid user UUIDs.
Add a member to an organization role by submitting their details and UUID in JSON/form, using organization and role IDs. Requires PersonalAPIKeyAuth. Success gives a 201 status.
Add persons to a static cohort by their UUIDs. Use when you need to manually add specific users to a static cohort. Only works with static cohorts (is_static=true), not dynamic cohorts.
Tool to add a product intent to a PostHog project. Use when you need to register a project's intention to use a specific PostHog product feature. Product intents help track which features (product analytics, feature flags, data warehouse, experiments, surveys) a project plans to use.
Add members with specific roles to a project by providing their user_uuid and level (member or admin). Requires project_id in the URL. Supports JSON, form-data, and form-urlencoded input. Returns the newly created membership data upon success. Note: This endpoint only works for projects with access control enabled (private projects). If the project does not have access control enabled, the API will return a 404 "Endpoint not found" error. Access control is an Enterprise feature that can be enabled in Project Settings > Access Control.
Add an existing session recording to a playlist. This endpoint associates a specific session recording with a playlist, making it part of that collection. Requires 'project_id' (project identifier), 'short_id' (playlist identifier), and 'session_recording_id' (recording identifier) in the URL. Optional body parameters can be used to update playlist properties. Works with both 'collection' and 'filters' type playlists. Returns the updated playlist details on success.
Append transcript segments to an existing desktop recording for real-time streaming support. Use when you need to add new transcript segments to a recording in batches as they become available from transcription services like AssemblyAI. Requires desktop_recording:write scope.
Archive dataset in a PostHog project. Archive a dataset. Archived datasets remain readable and reject item mutations.
Archive dataset item in a PostHog project. Archive an active item by creating a new immutable version.
Archive experiment in a PostHog project. Archive an ended experiment.
Archive feature flag in a PostHog project. Archive a feature flag, hiding it from the default flag list.
Archive named LLM prompt in a PostHog project.
Tool to archive a single survey response. Use when you need to hide a survey response from analytics while preserving it in the database.
Set up role-based access for a feature flag using `project_id` and `feature_flag_id`. Submit access info in JSON or form format, with `feature_flag:write` rights. Success returns new details with a 201 code.
Bulk-create PostHog organization invites with configurable access levels, messages, and private project access settings. Up to 20 invites can be sent per bulk request.
Bulk delete dashboards in a PostHog project. Soft-delete up to 100 dashboards. Optionally delete insights with no remaining dashboard. Report missing or inaccessible dashboards as skipped.
Bulk delete feature flags in a PostHog project using either filter criteria or explicit IDs. Returns an operation status and, when available, a deleted count.
Bulk delete insights in a PostHog project. Soft-delete insights in bulk by ID. Mirrors the single-insight delete: sets deleted=True, soft-deletes the insights' dashboard tiles, and removes their linked alerts. Insights the requester cannot edit are skipped and reported in `skipped`. Reversible via the bulk_restore endpoint.
Retrieve feature flag keys in bulk in a PostHog project. Get feature flag keys by IDs. Accepts a list of feature flag IDs and returns a mapping of ID to key.
Bulk restore insights in a PostHog project. Restore soft-deleted insights in bulk by ID — the inverse of bulk_delete. Sets deleted=False and re-activates the insights' dashboard tiles on dashboards that still exist. Linked alerts are not restored (they are removed on delete). Insights the requester cannot edit are reported in `skipped`.
Set test account filter in bulk in a PostHog project. Turn 'filter out internal and test users' on or off for every existing insight in the project. Requires project admin, matching the settings UI that fronts it. The setting of the same name only decides the default for new insights; this applies it to the insights that already exist. Only insights that store a query are changed; insights still holding legacy `filters` are counted in `legacy` and left as they are. Insights with nowhere to put the toggle, such as SQL insights, are left alone, as are insights the requester cannot edit. Dashboards follow their insights unless the dashboard sets its own override. Insights are updated in batches, so a failure part way through leaves the finished batches applied. Retrying is safe and picks up the rest.
Bulk update experiment tags in a PostHog project. Bulk update tags on multiple objects.
Bulk update feature flag tags in a PostHog project. Bulk update tags on multiple objects.
Submit a request to cancel a running or queued insight query in a PostHog project, typically using its client query ID.
Send a single analytics event to PostHog's public ingestion endpoint using a project API key. A success response indicates receipt, not guaranteed ingestion.
Check for available updates to a pipeline destination plugin by comparing the currently installed version (tag) with the latest version available in the plugin's repository. Use this to determine if a pipeline destination plugin can be upgraded to a newer version. Returns update information including current tag, latest tag, and whether an update is available. Note: This endpoint may require admin/staff permissions or may only be available for custom organization-owned plugins (not global PostHog Inc. plugins).
Retrieve the latest update information for a specific pipeline import app by its ID within an organization. This endpoint returns details such as plugin type, name, description, and version data. Requires 'id' and 'organization_id' as path parameters.
Get update status for a specific pipeline transformation plugin by its unique ID within an organization. This endpoint requires the 'organization_id' and 'plugin' IDs and returns details like plugin type, name, and update information.
Check if a project is currently generating demo data. This endpoint retrieves the demo data generation status for a specific project within an organization. Returns whether the project is currently in the process of generating demo data. **Important Authentication Note**: This endpoint requires session-based authentication (cookie-based) and does not support Personal API Key authentication. It may return 403 Forbidden when using API keys. This endpoint is primarily intended for use within the PostHog web application.
This endpoint duplicates a specified cohort as a static one within a project. Path parameters include `project_id` (string) and cohort `id` (integer). Successful requests return cohort details.
Create a notebook in a PostHog project. The feature is in early access and its API can have breaking changes without announcement.
Create account notebook in a PostHog project.
Create a PostHog alert configuration for an insight with thresholds and notification settings. The alert can notify subscribed users when threshold conditions are met.
Capture a batch of analytics events to PostHog using the public batch ingestion API. Use when you need to send multiple events efficiently in a single request (e.g., bulk event imports, offline event syncing).
Create a new batch export to automatically export PostHog data to external destinations like S3, BigQuery, or Snowflake. Use when you need to set up scheduled data exports with configurable intervals and destination-specific settings.
Tool to create a new backfill for a BatchExport. Use when you need to re-export historical data for a specific time range. Requires valid start_at and end_at timestamps in ISO 8601 format. The end_at timestamp cannot be in the future.
Tool to run a test step for a batch export configuration in PostHog. Use when you need to validate that a batch export is properly configured before enabling it. This endpoint triggers a test run to verify the destination connectivity and configuration.
Invoke canvas action in a PostHog project. Invoke one registered action verb as the viewer.
Create a customer profile configuration for a PostHog project. Use when you need to configure how customer profiles are displayed and organized for persons or groups within a project.
Copy dashboard tile in a PostHog project. Copy an existing dashboard tile to another dashboard (insight, text card, or widget tile).
Delete dashboard tile in a PostHog project. Soft-delete a single tile from a dashboard.
Move dashboard tile in a PostHog project.
Reorder dashboard tiles in a PostHog project.
Create a dashboard sharing password and return its plaintext value once. Requires password protection to already be enabled on the dashboard sharing configuration and the organization's Access Control feature. Does not enable sharing or password protection.
Rotate a dashboard sharing access token. Existing share links expire; distribute the returned token to continue sharing.
Create subscription nudge in a PostHog project. Send the requesting user an in-app notification suggesting they subscribe to this dashboard. Deduplicated server-side: at most one notification per user and dashboard, ever, so repeat calls return 200 with created=false.
Add a Markdown text or image tile to a dashboard in a PostHog project.
Update text tile in a PostHog project. Update the markdown body, layout, or color of an existing text tile on a dashboard.
Batch dashboard widgets in a PostHog project. Add multiple widget tiles to a dashboard in one atomic request.
Tool to create a new data color theme in a PostHog project. Use when you need to define custom color palettes for data visualization. Requires a theme name and list of hex color codes. Returns the created theme with auto-generated ID and metadata.
Tool to create a new dataset in a PostHog project. Use when you need to create a dataset for organizing data. Requires a project ID and a dataset name; description and metadata are optional.
Export dataset in a PostHog project. Create an asynchronous JSONL export pinned to an immutable dataset revision.
Restore dataset item in a PostHog project. Restore an archived item by copying content into a new immutable version.
Tool to create a new dataset item in a PostHog project dataset. Use when you need to add a new item with input/output data to a dataset for ML/AI experimentation or tracking.
Restore dataset in a PostHog project. Restore an archived dataset without changing its item states.
Create a new desktop recording and get Recall.ai upload token for the desktop SDK. Use when you need to initiate a new recording session and obtain credentials for uploading audio/video data.
Create and configure an authentication domain with SAML SSO for a PostHog organization. Requires Enterprise plan. Adds an email domain (e.g., 'company.com') to your organization and configures SAML Single Sign-On for users with matching email addresses. After creation, verify domain ownership via DNS TXT record before SAML activates. SAML parameters (entity_id, acs_url, x509_cert) come from your Identity Provider (Okta, OneLogin, Azure AD, etc.). Workflow: 1) Create domain (this endpoint) 2) Add DNS TXT record from verification_challenge 3) Verify domain 4) Configure IdP with PostHog SAML settings 5) Test authentication. Returns 201 with domain config on success, 403 if not on Enterprise plan.
Tool to create a new endpoint for a PostHog project. Endpoints allow you to define and execute custom queries (HogQL, Trends, Funnels, etc.) that can be accessed via a URL-safe name. Use when you need to set up a new data query endpoint with specific query configuration and caching options.
Retrieve last execution times in a PostHog project. Get the most recent execution time per endpoint (endpoint-level). Timestamps are recorded by the run path for personal-API-key calls. For per-version usage, query the query_log table directly.
Preview materialization transform in a PostHog project. Preview the materialization transform for an endpoint. Shows what the query will look like after materialization, including range pair detection and bucket functions.
Tool to create a new error tracking autocapture control configuration for a PostHog project. Use when you need to set up error tracking rules for specific libraries with URL triggers, event triggers, and sampling rates.
Get compact issue details in a PostHog project. Fetch one error tracking issue with impact counts, trend, top in_app frame, first and latest release, and optional sparkline and event breakdown.
List sampled exception events in a PostHog project. Fetch sampled exception events, stack traces, browser/SDK context, URL, and $session_id values for one issue.
List compact issues in a PostHog project. List error tracking issues with typed filters and compact aggregate counts.
Create a new error tracking release in PostHog. Use when you need to register a new application version or deployment for error tracking purposes. This helps track errors across different versions of your application.
Tool to create a new error tracking suppression rule for a project. Use when you need to automatically suppress specific error tracking issues based on filters. Suppression rules prevent matching errors from being reported or displayed.
Initiate a bulk upload of error tracking symbol sets for a PostHog project. The response may include an ID mapping for tracking.
Initiate a symbol set upload session for PostHog error tracking. The response may include a presigned S3 URL for uploading a symbol file chunk as part of the multi-step upload process.
Create a new evaluation for a PostHog project to assess AI-generated content or responses. Use when you need to set up LLM-based evaluation criteria for quality assessment, content moderation, or performance tracking.
Create an evaluation run for a specific existing PostHog event for asynchronous execution. The response may include a workflow ID and status.
Create a new event definition in a PostHog project. Event definitions help you organize and document the events being tracked in your application. Use this to formally define events, add descriptions, assign owners, and manage event metadata. This is useful for maintaining a clean event taxonomy and ensuring your team understands what each event represents.
Calculate experiment running time in a PostHog project. Estimate the recommended sample size and running time for an experiment.
Copy experiment to project in a PostHog project. Copy an experiment into another project in the same organization as a new draft.
Create an exposure cohort for an experiment in a project using the experiment ID and project ID.
Freeze experiment exposure in a PostHog project. Freeze exposure on a running experiment while metrics keep flowing.
Create a draft experiment comparing 2-10 distinct existing versions of one LLM prompt. Creates a NEW feature flag with control/test variants, equal traffic splits and JSON prompt-version payloads, plus primary metrics for distinct cost, latency or eval_pass_rate templates. Does not launch the experiment. Prompt versions must exist and be unarchived; an explicit flag key must not already exist.
Tool to create a new experiment holdout group in PostHog. Use when you need to set up a control group for experiments with specific filter configurations and rollout percentages.
Recalculate experiment metrics in a PostHog project. Trigger a batch recalculation of all metrics for this experiment.
Tool to create a new experiment saved metric in a PostHog project. Use when you need to define a reusable metric configuration for experiments. The query field requires 'kind' (ExperimentTrendsQuery or ExperimentFunnelsQuery) with a nested 'count_query' structure.
Query an experiment session bucket in a PostHog project and return matching session IDs for recordings.
Create session contexts in a PostHog project. Resolve experiment context for a batch of session recordings.
Calculate session event deltas in a PostHog project. The recordings worth watching for this experiment, grouped into cards.
Create experiment setup context in a PostHog project. Facts about this project that decide how to configure a new experiment.
Ship experiment variant in a PostHog project. Ship a variant and (optionally) end the experiment.
Tool to create a recalculation request for experiment timeseries data. Use when you need to recalculate metrics for an experiment. The experiment must have a start_date set (must be started) for recalculation to work.
Unfreeze experiment exposure in a PostHog project. Reopen enrollment on an exposure-frozen experiment.
Tool to create a new feature flag in a PostHog project. Use when you need to add feature toggles, perform gradual rollouts, or target specific user segments without deploying new code.
Create a dashboard for a specific feature flag in a PostHog project.
Roll flag out to everyone in a PostHog project. Serve a feature flag to every user.
Set release condition rollout in a PostHog project. Set what percentage of one release condition's audience a feature flag is served to.
Test feature flag evaluation in a PostHog project. Test feature flag evaluation against a specific user at an optional point in time.
Calculate user blast radius in a PostHog project.
Tool to create a new file system resource in PostHog with specified metadata and hierarchy. Use when you need to create folders, files, or other organizational structures in a project.
Create a new file system shortcut in a PostHog project. Requires 'file_system_shortcut:write' permission. Returns the created shortcut with all its properties including UUID, path, type, and creation timestamp.
Create a group with a unique key in an existing PostHog group type. Discover group types before creating a group. Returns the group's key, type, properties and creation timestamp. An existing key is rejected by PostHog; this is not an upsert. PostHog exposes no individual-group delete endpoint.
Delete group property in a PostHog project.
Update group property in a PostHog project.
Tool to create a new metric for a specific group type in a PostHog project. Use when you need to define custom metrics to track group-level analytics (e.g., company revenue, team activity). Requires project_id, group_type_index, metric id (UUID), name, and filters.
Create a new hog function in PostHog. Hog functions are serverless functions that can be triggered by events, used for transformations, destinations, or site applications. Use when you need to set up custom event processing, integrations, or in-app features like notification bars.
Check insight query data quality in a PostHog project. Check the events behind an insight for the common ways they mislead: internal and test users, local development traffic, bots and crawlers, and events sent twice. Works for trends, funnels, stickiness and lifecycle insights whose series are events. The checks apply the insight's own filters, and read the newest days of its date range, up to 7. The bot and duplicate checks read a sample of those days. For a token, the internal users check matches the emails of the organization's members only with the `organization_member:read` scope, and its verified domains only with `organization:read`. It names the emails it finds only with `person:read`. Nothing is stored. This route runs the query it is sent, so it needs query access as well as insight access. To check a saved insight by its id, send a GET request to `insights/{id}/data_checks/`.
Generate insight metadata in a PostHog project. Generate an AI-suggested name and description for an insight based on its query configuration.
Create a insight sharing password and return its plaintext value once. Requires password protection to already be enabled on the insight sharing configuration and the organization's Access Control feature. Does not enable sharing or password protection.
Rotate an insight sharing access token. Existing share links expire; distribute the returned token to continue sharing.
Create a new insight variable for a PostHog project. Insight variables allow you to define reusable parameters that can be referenced across insights and queries. Use when you need to create configurable variables like user segments, date ranges, or custom metrics that can be used in multiple insights.
Tool to create a new live debugger breakpoint in a PostHog project. Use when you need to set up debugging instrumentation for a specific file and line number in your application code. Client applications will receive this breakpoint configuration and can pause execution or log data when that line is reached.
Generate an AI-powered summary of an LLM trace or event. This endpoint analyzes the provided trace/event, generates a line-numbered text representation, and uses an LLM to create a concise summary with line references in [L45] or [L45-52] format. Use when you need to quickly understand complex LLM interactions, debug traces, or generate human-readable explanations of AI system behavior.
Tool to generate human-readable text representations of LLM trace events for display, logging, or analysis. Use when you need to convert LLM analytics events ($ai_generation, $ai_span, $ai_embedding, or $ai_trace) into formatted text.
Create a named, versioned LLM prompt in a PostHog project. Use to store a new prompt with optional model or agent configuration. To publish another version of an existing prompt, use the prompt publishing endpoint instead.
Tool to create a logs export job using HogQL queries in PostHog. Use when you need to export event logs or query results for analysis. The endpoint creates an asynchronous export job and returns metadata including the export ID, format, and filename that can be used to retrieve the exported data.
Tool to create and query insights using PostHog's Max AI assistant. Use when you need to generate insights from natural language queries. The AI interprets your query and creates the appropriate insight configuration (trends, funnels, or retention). Returns the generated insight with query configuration and results data.
Query metrics in a PostHog project.
Create a new PostHog organization with configurable security and notification settings. This action creates a new organization and automatically provisions a default project with an API token. The organization will be immediately active and ready for use. Returns complete organization details including: - Organization ID, name, and URL slug - Automatically created default project and team - API token for the default team - All security and access control settings Requires organization:write permission. The authenticated user becomes the first member of the newly created organization.
Create a new experiment in a specific PostHog project using experiment details and a personal API key. Returns experiment information.
Update collaboration presence in a PostHog project. PostHog documents this notebook API as early access and subject to breaking changes.
Save collaborative notebook in a PostHog project. PostHog documents this notebook API as early access and subject to breaking changes.
Complete notebook code in a PostHog project. Completions for the cursor position in a Python cell, from the notebook's running kernel. Returns no matches when no kernel is running or the kernel is busy, and never starts one. PostHog documents this notebook API as early access and subject to breaking changes.
Configure notebook kernel in a PostHog project. Set the notebook's kernel compute configuration. Applies at sandbox provision time: a currently running kernel keeps its resources until restarted. PostHog documents this notebook API as early access and subject to breaking changes.
Inspect notebook kernel in a PostHog project. The signature and docstring of the name at the cursor in a Python cell, from the notebook's running kernel. Returns found=false when no kernel is running or the kernel is busy. PostHog documents this notebook API as early access and subject to breaking changes.
Create notebook run in a PostHog project. Run every SQL and Python cell of a markdown notebook, in document order, stopping at the first cell that does not finish. Returns as soon as the run starts; poll the run status endpoint until the status is terminal. Flag-gated (revamped-py-notebooks). PostHog documents this notebook API as early access and subject to breaking changes.
Interrupt notebook run in a PostHog project. Stop a whole-notebook run and the cell it is on. Idempotent: stopping a run that already finished returns its outcome unchanged. Flag-gated (revamped-py-notebooks). PostHog documents this notebook API as early access and subject to breaking changes.
Create a notebook sharing password and return its plaintext value once. Requires password protection to already be enabled on the notebook sharing configuration and the organization's Access Control feature. Does not enable sharing or password protection.
Rotate a notebook sharing access token. Existing share links expire; distribute the returned token to continue sharing. The notebook API is early access.
Run notebook SQL in a PostHog project. Dispatch an asynchronous run of a notebook SQL or Python cell. Returns a run_id immediately; poll the run result endpoint until the status is terminal. One run at a time per notebook. Python notebooks enable all run types. HogQL runs without a connection or kernel are always available. PostHog documents this notebook API as early access and subject to breaking changes.
Interrupt notebook SQL run in a PostHog project. Stop a running cell. Idempotent: interrupting an already-finished run returns its outcome unchanged. Flag-gated (revamped-py-notebooks). PostHog documents this notebook API as early access and subject to breaking changes.
Create widget snapshot in a PostHog project. PostHog documents this notebook API as early access and subject to breaking changes.
Publish widget snapshot in a PostHog project. PostHog documents this notebook API as early access and subject to breaking changes.
Attach notebook widget in a PostHog project. PostHog documents this notebook API as early access and subject to breaking changes.
Cancel a notebook widget generation job in a PostHog project. The notebook API is early access and subject to breaking changes.
Fork notebook widget in a PostHog project. PostHog documents this notebook API as early access and subject to breaking changes.
Queue AI generation for an existing markdown Widget node in a PostHog notebook. Returns HTTP 202 status, not completed source. Requires organization AI data-processing approval and available AI credits; generation may incur charges. Reuse generation_id only for identical retries. PostHog documents this notebook API as early access and subject to breaking changes.
Pin notebook widget in a PostHog project. PostHog documents this notebook API as early access and subject to breaking changes.
Publish notebook widget in a PostHog project. PostHog documents this notebook API as early access and subject to breaking changes.
Revert notebook widget in a PostHog project. PostHog documents this notebook API as early access and subject to breaking changes.
Create and send an organization invitation to a user via email. This allows you to invite people to join your PostHog organization with a specific role (member, admin, or owner). The action creates an invite that can optionally send an email notification to the recipient. Returns the complete invite details including invite ID, timestamps, and the user who created it. Successful invitations return a 201 status with full invite details. Use cases: - Invite team members to collaborate on analytics - Grant admin access to manage organization settings - Add owners with full organizational control - Create invites without immediate email notification (set send_email=false)
Create a managed reverse proxy record for an organization to enable custom domain routing for PostHog analytics events. This bypasses ad blockers by routing analytics through your own domain. After creating the record, you must: 1. Create a CNAME DNS record pointing your domain to the returned target_cname 2. Wait 2-30 minutes for DNS propagation and SSL certificate provisioning 3. The status will progress from 'waiting' → 'issuing' → 'live' IMPORTANT: If using Cloudflare, set the CNAME to "DNS only" (disable proxy) to avoid SSL certificate provisioning issues. Requires organization write access (organization:write permission).
Create a new custom role within a PostHog organization with optional feature flag access permissions. This action creates an organization role that can be assigned to members to control their access levels. The role can include specific feature flag access permissions via the feature_flags_access_level parameter. Returns the created role with its unique ID, name, creation timestamp, and other metadata. Security: Requires PersonalAPIKeyAuth with organization admin permissions.
Tool to create a new persisted folder in a PostHog project. Use when you need to create a new folder for organizing data storage with a specific type and configuration.
Retrieve path analytics for a specific person within a PostHog project. This endpoint returns the navigation paths and user journey data for a person. Note: This endpoint requires session-based authentication and does not support Personal API Key access. To use this endpoint, you must be authenticated via the PostHog web application.
Request bulk deletion of persons by PostHog person IDs or distinct IDs. Options allow requesting deletion of associated events and recordings or retaining person records; deletion is asynchronous and batched.
Tool to create a new product tour in a PostHog project. Use when you need to set up guided tours to onboard users or highlight features. Requires a project_id and a name for the tour.
Create an action in a PostHog project using action details such as its name, description, tags, and steps. An optional format parameter selects CSV or JSON output.
Create cohorts for a specified project by POSTing JSON-form data to "/api/projects/{project_id}/cohorts/". Provide project_id in URL and the necessary payload, adhering to JSON schema constraints. Authentication required. Returns 201 upon success.
The POST endpoint creates a dashboard within a project using a `project_id`, accepting details in JSON/form formats. It uses 'PersonalAPIKeyAuth' for security and returns HTTP 201 with dashboard details on success.
Create custom analytics insights for a PostHog project. Supported query types (InsightVizNode.source.kind): TrendsQuery, FunnelsQuery, RetentionQuery, PathsQuery, StickinessQuery, LifecycleQuery, WebStatsTableQuery, WebOverviewQuery. IMPORTANT: HogQLQuery is NOT supported for saved insights. For ad-hoc HogQL queries, use POSTHOG_CREATE_QUERY_IN_PROJECT_BY_ID instead. Key parameters: - project_id (required): Project ID - query: InsightVizNode with source containing one of the 8 valid query types above - name: Display name - saved: Whether to save permanently (default: true) - tags: Organization tags - format: 'json' or 'csv' Returns the created insight with id, short_id, timestamps, and configured properties.
Create a new analytics insight in a PostHog project. Insights are saved queries that visualize data from your analytics events. Use this to create trends, funnels, retention, or other analytics visualizations. You can define the insight using either: - Legacy 'filters' format (simpler, widely supported) - Modern 'query' format (more powerful, recommended for new integrations) The optional 'format' parameter controls response format: - 'json' (default): Returns structured JSON with insight metadata - 'csv': Returns CSV-formatted representation of the insight Requires a valid project_id. Returns HTTP 201 on success with the created insight details including a unique ID and short_id.
Create a job for a pipeline frontend app config in a project. Requires `project_id` and config `id`, accepting JSON/form-data. Returns the created job's details.
Create a subscription for a given project by providing required details such as delivery method, frequency, and starting date. Requires a project ID and supports various content types. Returns the newly created subscription. Security: PersonalAPIKeyAuth.
Create a project survey with a name, type, and optional questions and targeting settings. Uses personal API key authentication and returns a survey object on success.
Record project insights as viewed by submitting their IDs to the insights timing endpoint. The configured connection uses a personal API key.
Submit a query for a specific project using structured query details. Supports asynchronous execution and returns query results or execution status.
Create and retrieve retention insights for a project using PostHog's Query API. Analyzes how users return over time based on specified events or actions. Uses the /api/projects/{project_id}/query/ endpoint with a RetentionQuery. Requires a project ID and authenticated access with 'insight:read' permission. If no query is provided, returns default retention data for $pageview events over 7 days.
Create playlists of session recordings for a specified project. Requires 'project_id' path parameter and personal API key with write access. Supports JSON, form-encoded, or multipart data. Returns 201 on success with playlist details.
Run report agent action in a PostHog project. Create a task linked to the report and start its first run in the background, with the instructions the inbox uses for the same action. `ask` sends your own message with the framing of the inbox's Ask AI. The run shows in the report's runs and counts toward the report's task limit. Nobody can answer questions in a background run, so the agent writes a note to the report's work log when it needs a decision.
Create a static cohort for a specific feature flag in a project.
Generate survey translations in a PostHog project.
Tool to create or regenerate a summary headline for a survey. Use when you need to generate an AI-powered headline summary of survey responses for a specific project survey. The endpoint processes survey data to create a concise headline.
Query tracing spans in a PostHog project.
Create a new warehouse saved query in PostHog for data warehouse operations. Use this to define reusable HogQL queries that can be executed against your warehouse tables. The query name must contain only letters, numbers, underscores, dots, or dollar signs.
Create a new web experiment in a PostHog project. Web experiments allow you to run A/B tests by dynamically transforming DOM elements on your website based on feature flag variants. Use when you want to test different UI variations, messaging, or layouts without deploying new code.
Create an annotation for a PostHog project.
Delete account notebook in a PostHog project.
Delete an alert configuration by providing its UUID and the associated project ID. Requires 'alert:write' permission. Returns no content with a 204 status on success.
Delete a customer profile configuration by ID in a PostHog project. Returns a success flag and confirmation message after a successful response.
Delete sharing password in a PostHog project. Delete a password from the sharing configuration.
Tool to delete a desktop meeting recording by its UUID and project ID. Use when you need to permanently remove a desktop recording from a PostHog project.
Delete an endpoint and clean up materialized query. Returns no content with a 204 status on success. Use when you need to remove an endpoint configuration from a PostHog project.
Delete an error tracking autocapture control configuration by UUID and project ID. Use when you need to remove autocapture settings for error tracking.
Delete a specific error tracking grouping rule by ID. Use when you need to remove a custom grouping rule that is no longer needed or was created incorrectly.
Delete an error tracking release by its UUID and project ID, requiring the 'error_tracking:write' scope. Returns a status code and a success flag that is true for HTTP 204.
Tool to delete an error tracking suppression rule by its UUID. Use when you need to remove a suppression rule that is no longer needed. Requires 'error_tracking:write' permission.
Delete an experiment holdout by providing its ID and the associated project ID. Requires 'experiment:write' permission. Returns no content with a 204 status on success.
Delete an experiment saved metric by ID from a PostHog project. Returns a success flag and the HTTP status code.
Tool to delete a file system resource in PostHog by UUID. Use when you need to permanently remove a file system. Returns deletion information including undo options if available.
Tool to delete a group usage metric by its UUID within a specific project and group type. Use when you need to remove a metric that tracks group-level analytics. Requires 'group:write' permission.
Attempt to delete an insight by ID from a PostHog project. A 405 response is reported as not supported; a 204 response is reported as successful.
Delete insight sharing password in a PostHog project. Delete a password from the sharing configuration.
Delete an insight variable by its UUID from a specified project. Requires 'insight_variable:write' permission. Returns no content with a 204 status on success.
Delete a live debugger breakpoint by providing its UUID and project ID. Requires 'live_debugger:write' permission. Returns no content with a 204 status on success.
Delete LLM prompt label in a PostHog project.
Delete notebook sharing password in a PostHog project. Delete a password from the sharing configuration. PostHog documents this notebook API as early access and subject to breaking changes.
Delete an organization by its UUID. Requires a 'PersonalAPIKeyAuth' with 'organization:write' permission. On success, returns a 204 status code with no response body.
Delete a specified project from an organization using the organization ID and project ID.
Delete a persisted folder by providing its UUID and the associated project ID. Requires 'persisted_folder:write' permission. Returns no content with a 204 status on success.
Delete a person by UUID in a PostHog project, optionally requesting deletion of their associated events.
Delete specific properties from a person record using the $unset operation. Use when you need to remove one or more properties from a person's profile.
Delete a product tour by providing its UUID and the associated project ID. Requires 'product_tour:write' permission. Returns no content with a 204 status on success.
Delete a session recording by providing the session's UUID and the associated project ID. Requires `session_recording:write` permission. Returns no content on successful deletion.
Delete a survey by providing its UUID and the associated project ID. Requires 'survey:write' permission. Returns no content with a 204 status on success.
Tool to delete a warehouse saved query from PostHog. Use when you need to remove a saved query from the data warehouse. The operation succeeds if the API returns 204 No Content status.
Delete a web experiment by its ID from a specific project. Use when you need to permanently remove a web experiment. Requires 'experiment:write' scope.
Disable feature flag in a PostHog project. Disable a feature flag.
Tool to duplicate an existing experiment in PostHog. Use when you need to create a copy of an experiment with the same configuration. The API automatically appends '(Copy)' to the duplicated experiment name and creates a new feature flag for it.
Duplicate named LLM prompt in a PostHog project.
Duplicate a survey to multiple projects in a single transaction. Accepts a list of target team IDs and creates a copy of the survey in each project. Uses an all-or-nothing approach - if any duplication fails, all changes are rolled back.
Enable feature flag in a PostHog project. Enable a feature flag.
Enables a new early access feature for a project using project ID, payload with details, and PersonalAPIKeyAuth. Returns a 201 status on success.
End experiment in a PostHog project. End a running experiment without shipping a variant.
Retrieves export unsubscribe configurations for pipeline transformations in an organization. This endpoint returns a list of configurations that define how users can unsubscribe from various pipeline transformation exports. Each configuration includes an ID, plugin type identifier, and configuration settings. Use case: Check which export transformations support unsubscribe functionality and their configuration details. This is useful for managing data export preferences and compliance requirements. Note: This endpoint may require specific organization permissions or enterprise features. If you receive a 403 Forbidden error, the organization may not have access to this feature.
Retrieve organization details by UUID. Endpoint requires 'organization:read' access. Response includes name, slug, timestamps, membership, plugins access level, and team structure.
Retrieve details of pipeline import app repositories for a specific organization by its UUID. Returns JSON with properties like plugin type, name, and URL. Supports 'local', 'custom', 'repository', 'source', 'inline' types.
Retrieve activity logs and metadata for a specific pipeline destination configuration. Returns activity information including latest updates, version tags, and operational status. Use this to monitor the activity and update history of a destination config. For complete destination config details (plugin settings, filters, enabled status), use POSTHOG_RETRIEVE_PIPELINE_DESTINATION_CONFIG_DETAILS instead. Required: project_id (integer) and destination config id (integer).
Retrieve available pipeline transformation plugins from the organization's plugin repository. Returns a list of transformation templates that can be used to modify, enrich, or filter events in real-time. Each plugin includes configuration schemas, capabilities, and metadata. Requires `organization_id` (organization UUID). Note: This endpoint requires specific authentication permissions beyond Personal API Keys and may not be accessible in all environments.
Retrieve the survey activity log for a project. Returns activity entries with user, action, item, change details and pagination information; requires personal API key access.
Retrieve session recording playlist details for a specific project by project_id and playlist short_id. Requires PersonalAPIKeyAuth with read access. Returns playlist metadata including creation and modification info.
Tool to finalize bulk upload of error tracking symbol sets for a PostHog project. Use when completing a multi-part symbol set upload process. This endpoint marks the upload as complete and makes the symbol sets available for error stack trace symbolication.
Update an annotation's deleted flag by project and annotation ID. The flag defaults to true to mark the annotation as deleted, but can also be set to false.
Generate an AI-powered summary for a session recording. Requires PostHog AI feature to be enabled. Provide the project_id and the session recording's UUID to get an AI-generated summary including key activities, user interactions, and insights about the session. Note: This endpoint requires PostHog AI to be enabled for your organization and may only be available on paid plans. Returns 403 Forbidden if the feature is not accessible.
Tool to generate an AI-suggested name for a PostHog insight based on its query configuration. Use when you need to automatically name an insight instead of manually creating a descriptive title.
The /api/projects/{project_id}/insights/funnel/correlation endpoint generates a correlation insight for funnel analysis in a project, accepting JSON/CSV and needing 'project_id' and insight details.
List account notebooks in a PostHog project. Returns one page; use the documented pagination parameters for additional pages.
List action references in a PostHog project.
Tool to retrieve backfills for a specific batch export within a project. Use when you need to view historical backfill operations for batch exports. Supports pagination via cursor and custom ordering of results.
Retrieve billing and subscription details for the connected PostHog account. Use this to inspect plan status, totals, discounts, and available product features.
Find blocking workflows in a PostHog project. Active workflows that block deleting this cohort or editing it so it stops updating in real time.
Tool to retrieve the calculation history for a specific cohort. Use when you need to track cohort recalculations, monitor calculation performance, or debug calculation errors. Returns paginated list of historical calculations with timing metrics and success status.
Find cohort usage in a PostHog project.
Tool to retrieve a specific conversation by UUID and project ID. Use when you need to access conversation details including messages, status, and associated user information.
Tool to retrieve conversations for a specific PostHog project with pagination support. Use when you need to fetch conversation data including messages, status, and user information.
Retrieve metadata, grants, and resource restrictions for the personal API key authenticating this connection. The normal response excludes credential fields.
DEPRECATED: Use POSTHOG_LIST_ALL_PROJECTS_ACROSS_ORGANIZATIONS instead. Diagnostic tool to validate PostHog credentials and retrieve current user information. Returns the authenticated user's profile along with accessible organizations, teams, and projects. Use this to confirm API key validity and discover team/project IDs for subsequent API calls. When multiple organizations or projects are returned, explicitly select the intended one by ID rather than defaulting to the first result.
Retrieve a specific customer profile configuration by its ID for a given project. Use when you need to fetch details about how customer profiles are configured for persons or groups.
Tool to retrieve customer profile configurations for a project with pagination support. Use when you need to list or access customer profile configuration settings for a specific PostHog project.
Run dashboard insights in a PostHog project and return their results. You can select specific insight tiles or run the dashboard's insight tiles.
Run dashboard widgets in a PostHog project.
Tool to retrieve a specific data color theme by ID from a PostHog project. Use when you need to fetch theme configuration details for data visualization.
Tool to retrieve data color themes for a specific project. Use when you need to list available color themes for data visualization. Returns paginated results with theme details including colors, creator information, and global status.
Retrieve detailed information about a specific dataset within a project. Use this to get dataset properties including name, description, creator info, and timestamps.
Retrieve dataset export in a PostHog project. Check the status of a dataset export created by the current user.
Download dataset export in a PostHog project. Download a completed dataset JSONL export.
Tool to retrieve a specific dataset item by its ID from a PostHog project. Use when you need to fetch details about a particular dataset item including its input, output, metadata, and creation information.
List dataset item versions in a PostHog project. List every immutable version of an item, newest first. Returns one page; use the documented pagination parameters for additional pages.
Tool to retrieve paginated dataset items for a specific project in PostHog. Use when you need to list or explore dataset items with optional filtering by dataset ID.
List dataset revisions in a PostHog project. List immutable dataset revisions, newest first. Returns one page; use the documented pagination parameters for additional pages.
Tool to retrieve datasets for a PostHog project. Use when you need to list or search datasets within a specific project. Supports filtering by IDs, searching by name/description, and ordering results.
Tool to retrieve desktop meeting recordings for a specific project. Use when you need to access recorded meetings with transcripts, summaries, and extracted tasks. Returns paginated results with support for limit and offset parameters.
Tool to retrieve feature flags eligible for use in experiments. Use when you need to find multivariate feature flags that can be used to run A/B tests. Only returns flags with at least 2 variants where the first variant key is 'control'.
Retrieve named endpoint in a PostHog project. Retrieve an endpoint, or a specific version via ?version=N.
Retrieve endpoint logs in a PostHog project, with optional time, execution instance, level, search and limit filters. Returns the provider response in data.
Get materialization status in a PostHog project. Get materialization status for an endpoint. Supports ?version=N query param.
Get OpenAPI 3.0 specification for a specific PostHog endpoint. Use this to generate typed SDK clients. Returns the complete OpenAPI schema including paths, components, and security definitions for the specified endpoint.
Execute a named PostHog project endpoint via GET and return its query results.
Tool to retrieve error tracking assignment rules for a project. Use when you need to list the configured rules that automatically assign error tracking issues to team members based on filters. Supports pagination via limit and offset parameters.
Retrieve a specific error tracking autocapture control configuration by its ID. Use this to view detailed settings for a particular autocapture control including sample rates, URL triggers, and event filters.
Tool to retrieve error tracking fingerprints for a project. Use when you need to list tracked errors with their status, occurrence counts, and timing information. Returns paginated list of error fingerprints that group similar errors together for easier tracking and resolution.
Tool to retrieve error tracking grouping rules for a project. Use when you need to list the configured rules that control how error tracking issues are grouped together based on filters. Supports pagination via limit and offset parameters.
Retrieve one error tracking issue by ID for a PostHog project. Optionally use a fingerprint to resolve an issue moved by regrouping.
Retrieve details of a specific error tracking release by its UUID and project ID. Use when you need to fetch information about a particular release in error tracking.
Tool to retrieve an error tracking release by its hash identifier. Use when you need to fetch release details using a hash ID instead of the UUID. Requires 'error_tracking:read' scope.
Tool to retrieve paginated error tracking releases for a specific project in PostHog. Use when you need to list releases associated with error tracking to identify version-specific issues.
Tool to retrieve error tracking suppression rules for a project. Use when you need to list the configured rules that automatically suppress specific error tracking issues based on filters. Supports pagination via limit and offset parameters.
Retrieve a paginated list of error tracking symbol sets for a PostHog project, including references, release versions, and any failure reason.
Retrieve details of a specific evaluation by its UUID and project ID. Use this to fetch evaluation configuration, type, conditions, and associated model settings.
Tool to retrieve evaluations configured for a specific PostHog environment/project. Use when you need to list AI model evaluations, check their configurations, or filter evaluations by status or search terms. Returns paginated list of evaluations with their types, configurations, and metadata.
Look up an event definition by name within a PostHog project. Returns the event name, elements, and properties from the response.
Tool to retrieve event definitions in Golang format for a specific PostHog project. Use when you need Golang code generation or type definitions for events in the specified project.
Tool to retrieve Python-formatted event definitions for a specific project. Use when you need to access event definitions in Python format for code generation or SDK integration.
Tool to retrieve TypeScript event definitions for a specific project. Use when you need to generate type-safe event definitions for TypeScript applications.
Retrieve experiment activity in a PostHog project. Change history for this experiment. Returns one page; use the documented pagination parameters for additional pages.
Retrieve flag cleanup target in a PostHog project. Repository a flag-cleanup pull request for this experiment would be opened in.
Retrieve flag cleanup task in a PostHog project. Status of the flag-cleanup Desktop task opened for this experiment.
Retrieve experiment health in a PostHog project. Health check findings for this experiment: problems in its configuration and its feature flag that keep it from producing trustworthy results, each with a fix. `checks` gives the result of each check, so a check that found no problem can be told from one that did not apply or could not read an input.
Retrieve experiment health inputs in a PostHog project. Staff only. The inputs that the health checks read for this reader, to debug why a finding shows or not: the context of the checks in `health`, the exposure query's answer that the exposure checks read, and facts about the project from the setup context's providers (the team's experiment defaults and which SDKs call flags). The exposure answer comes from the cache. When it is missing or stale, a calculation starts in the background and `exposures.status` says so.
Retrieve details of a specific experiment holdout by ID within a project. Use this to get information about an experiment holdout including its name, description, filters, and creation details.
Tool to retrieve experiment holdouts for a specific PostHog project. Use when you need to view holdout groups for experiments. Returns paginated list of holdouts with their configurations and metadata.
Retrieve in-session exposure in a PostHog project. How the recordings tab's in-session exposure scope reads on this experiment.
Retrieve metric recalculation in a PostHog project.
Retrieve latest metric recalculation in a PostHog project.
Tool to retrieve a specific experiment saved metric by ID from a PostHog project. Use when you need to fetch details about a saved metric configuration for experiments.
Retrieve experimentation velocity statistics for a PostHog project, including recent launch counts, percentage change, active experiments, and recent completions.
Retrieve one external data schema and its sync configuration.
Tool to retrieve details of a specific external data source by its UUID and project ID. Use when you need to access external data source configuration, status, and metadata.
Tool to retrieve external data sources for a PostHog project with pagination support. Use when you need to list or search for configured external data connections like Stripe, Postgres, or Snowflake.
Retrieve remote configuration in a PostHog project.
Tool to retrieve the status of a specific feature flag in a PostHog project. Use when you need to check the operational status or state of a feature flag beyond its basic configuration details.
Retrieve feature flag version in a PostHog project.
Retrieve all active feature flags that depend on a specified flag. Use when you need to understand flag dependencies before modifying or deleting a flag. Helps prevent breaking dependent flags by showing which flags reference the target flag.
Retrieve matching feature flag IDs for a PostHog project, limited to flags the user has permission to edit. This action does not accept filter parameters.
Tool to retrieve a specific file system resource by UUID and project ID. Use when you need to access details about a file system in PostHog, including metadata and path information.
Retrieve a specific file system shortcut by UUID from a project. Requires 'file_system_shortcut:read' permission. Returns detailed information about the shortcut including path, type, and creation timestamp.
Tool to retrieve detailed information about a specific group usage metric by its ID. Use when you need to get the configuration, filters, display format, and calculation interval for a particular metric within a group type.
Tool to retrieve metrics for a specific group type in a PostHog project. Use when you need to list all metrics associated with a particular group type index. Returns paginated results with metric configurations including filters, display settings, and formats.
Tool to retrieve a specific hog function by UUID and project ID. Use when you need to access details about a hog function including its configuration, code, filters, and status.
Read aggregate execution metric totals for a PostHog Hog function.
Tool to retrieve hog functions for a specific PostHog project. Use when you need to list, search, or filter hog functions with pagination support.
Check saved insight data quality in a PostHog project. Run the data checks on a saved insight, found by its numeric id or its `short_id`. The checks read the query the insight stores, and work the same way as the checks on a query that is not saved. The `status` is `unsupported` for an insight that still stores legacy `filters` and no query. Nothing is stored.
Tool to retrieve a specific insight threshold by ID for a PostHog project. Use when you need to view threshold configuration, bounds, and associated alerts for monitoring insights.
Tool to retrieve thresholds configured for a specific insight within a project. Use when you need to view alert thresholds or monitoring criteria set up for an insight. Returns paginated list of thresholds with their configurations and associated alerts.
Tool to retrieve a specific insight variable by UUID and project ID. Use when you need to access details about an insight variable including its type, name, and values.
Tool to retrieve paginated list of insight variables for a project. Use when you need to discover available variables for insights or query their configurations. Returns variables with their types, default values, and metadata.
Tool to retrieve a specific live debugger breakpoint by UUID and project ID. Use when you need to fetch details about a breakpoint for live debugging.
Tool to retrieve live debugger breakpoints for a project. Returns a paginated list of breakpoints with their configuration including filename, line number, condition, and status. Use when you need to list or inspect existing breakpoints for live debugging.
Tool to retrieve the LLM analytics evaluation configuration for a specific PostHog project. Use when you need to check evaluation settings, trial limits, or usage statistics for LLM analytics features.
Tool to list available LLM models for a specific provider in PostHog LLM Analytics. Use when you need to discover which models are available for a given provider (e.g., openai, anthropic).
Tool to retrieve LLM analytics provider keys for a project. Use when you need to list API keys configured for LLM analytics providers. Returns paginated results with provider key details including masked keys, usage timestamps, and provider information.
Retrieve a PostHog LLM prompt by name, version, or label. Returns the latest version by default, with full content and resolved references. Use preview or none content modes for lightweight prompt metadata.
Resolve named LLM prompt in a PostHog project. Returns one page; use the documented pagination parameters for additional pages.
List one page of event history for a log alert in a PostHog project, including state transitions, errored checks, and user-initiated control-plane events. Quiet no-op checks are filtered out; checks for alerts evaluated by the alerts platform come from its check history.
Tool to retrieve unique values for a specific log field key in a PostHog project. Use when you need to discover available values for log fields like level, message, source, or other log properties.
Tool to retrieve available log attributes for a PostHog project. Use when you need to discover what log attribute fields are available for querying or filtering logs. Requires the logs:read scope and returns metadata about log attributes that can be used in log queries.
Tool to check if a project has logs available. Use when you need to verify log availability before querying logs. Returns a boolean indicator of log presence.
Read a bounded batch of notebook collaboration SSE events and return the last event ID for resuming. Stops after the configured time/event limit or five seconds of inactivity, rather than waiting for the stream to close. PostHog documents this notebook API as early access and subject to breaking changes.
Retrieve notebook kernel status in a PostHog project. Live-checked kernel runtime state for this notebook, its compute configuration, and the catalog of dataframes/tables a cell can currently reference (with column schemas). PostHog documents this notebook API as early access and subject to breaking changes.
Retrieve notebook run in a PostHog project. Read a whole-notebook run: its state, which cell it is on, and one line per planned cell. Carries no result rows — fetch a cell's result from the cell run result endpoint. Flag-gated (revamped-py-notebooks). PostHog documents this notebook API as early access and subject to breaking changes.
List notebook sharing settings in a PostHog project. PostHog documents this notebook API as early access and subject to breaking changes.
Retrieve notebook SQL run in a PostHog project. Read a run's durable state: its status, and — once done or interrupted — the result envelope (columns, first rows, stdout/stderr, media, error). Poll until terminal. Requires notebook and query read access, including after a notebook feature flag is disabled. PostHog documents this notebook API as early access and subject to breaking changes.
Retrieve notebook SQL state in a PostHog project. The full notebook view for agents: title, document source (markdown, or raw content for legacy rich-text notebooks), the notebook's declared variables, every cell with its dependency edges and derived run status (including staleness), and the kernel's runtime state and compute config. Flag-gated (revamped-py-notebooks). PostHog documents this notebook API as early access and subject to breaking changes.
Retrieve widget snapshot in a PostHog project. PostHog documents this notebook API as early access and subject to breaking changes.
Retrieve widget snapshot frame in a PostHog project. Returns one page; use the documented pagination parameters for additional pages. PostHog documents this notebook API as early access and subject to breaking changes.
Retrieve notebook widget frame in a PostHog project. Returns one page; use the documented pagination parameters for additional pages. PostHog documents this notebook API as early access and subject to breaking changes.
Retrieve notebook widget source in a PostHog project. PostHog documents this notebook API as early access and subject to breaking changes.
Retrieve notebook widget status in a PostHog project. PostHog documents this notebook API as early access and subject to breaking changes.
List notebook widget versions in a PostHog project. Returns one page; use the documented pagination parameters for additional pages. PostHog documents this notebook API as early access and subject to breaking changes.
Tool to list persisted folders for a PostHog project with pagination support. Use when you need to retrieve or browse persisted folder configurations within a project.
List a page of emails for a person in a PostHog project, with pagination parameters for additional pages.
List a page of push notifications for a person in a PostHog project, with pagination parameters for additional pages.
Tool to retrieve a specific product tour by UUID from a PostHog project. Use when you need to fetch details about a product tour configuration, including targeting and content settings.
Retrieve the cached analysis of a query's last slow run. Use the cache_key from a query response, not a query ID. This read does not execute the query or request analysis. Returns {} while analysis is pending. Returns 404 if no matching analysis exists or PostHog has not enabled scan visibility for the project. A normal fast query may never have a scan. PostHog does not generate new scans for API-key query executions.
Retrieve details of a specific role membership within an organization by its UUID. Use this to view information about a user's assignment to a particular role, including when they were assigned and their organization member details.
Tool to retrieve stored group session summaries for a project. Use when you need to list or access session grouping summaries. Supports pagination via limit and offset parameters.
List report agent actions in a PostHog project. List the actions on this report that start an agent run, read from the report's current state. `get_it_merged` is available only while the report has an open, approved pull request. `make_it_green` is available only while CI fails on the report's open pull request. `suggested_prompt` has one entry per prompt the report suggests. Start one with the run endpoint.
Retrieve the active error tracking spike detection configuration for a project. Use this to inspect the project's alert snooze duration, multiplier, and threshold.
Get survey response statistics for a specific survey. Returns event counts, unique respondents, and conversion rates. Use when analyzing survey performance and engagement metrics.
List survey responses in a PostHog project. List survey responses for a specific survey, with question text resolved server-side so callers do not have to map opaque `$survey_response_<id>` keys. Each row carries `distinct_id`, `session_id`, `submitted_at`, and an `extra` block (device, browser, OS, geoip, current_url, iteration) so agents can cross-pivot to recordings, persons, or paths in a single follow-up call. For person properties at event time, follow up with `persons-get` using the returned `distinct_id` — keeps scopes scoped. Use `question_id` + `score_lte` to fetch NPS detractors and similar score-filtered cohorts. Returns one page; use the documented pagination parameters for additional pages.
Tool to get list of archived response UUIDs for HogQL filtering. Returns list of UUIDs that the frontend can use to filter out archived responses in HogQL queries.
Tool to get aggregated response statistics across all surveys for a project. Use when you need to analyze overall survey performance, response rates, and dismissal rates. Optionally filter statistics by date range using ISO timestamps.
Tool to retrieve user home settings including homepage and tab configurations. Use when you need to fetch the personalized home page and tab settings for a user.
Tool to retrieve paginated list of user interviews for a specific project. Use when you need to access interview recordings, transcripts, and summaries.
List vision alert events in a PostHog project. Paginated event history for this alert, newest first. Quiet no-op check rows (no state change, no error) are filtered out. Optional `?kind=...` narrows to one kind. Returns one page; use the documented pagination parameters for additional pages.
Retrieve activity log details for a specific PostHog warehouse saved query, including recorded changes and the users who made them.
Retrieve a specific PostHog warehouse saved query, including its creator, query definition, execution status, and latest execution metadata.
Retrieve details of a specific data warehouse table by its UUID. Use this to inspect warehouse table configuration, credentials, schema, and format.
Tool to retrieve a paginated list of warehouse tables for a specific project. Use when you need to list, search, or discover warehouse tables. Supports pagination via limit/offset and filtering via search term.
Tool to retrieve a specific web experiment by ID from a PostHog project. Use when you need to fetch configuration details about a web experiment including variants and feature flag mapping.
Tool to retrieve web vitals metrics for a specific pathname in a PostHog project. Returns Core Web Vitals data including INP (Interaction to Next Paint), LCP (Largest Contentful Paint), CLS (Cumulative Layout Shift), and FCP (First Contentful Paint) as 90th percentile values over the past 7 days.
Initiates domain verification for SAML SSO authentication. This endpoint triggers the verification process for a previously created domain by checking if the required DNS TXT record has been added. **Requirements:** - Enterprise plan with SAML SSO feature - Domain must be created first via CREATE_DOMAIN_WITH_SAML_FOR_ORGANIZATION - DNS TXT record with verification_challenge value must be published **Verification Process:** 1. Create domain and receive verification_challenge value 2. Add TXT record to your domain's DNS: _posthog-challenge.yourdomain.com with the challenge value 3. Call this endpoint to verify - PostHog checks for the DNS record 4. If found, domain is_verified becomes true and SAML SSO is activated **Common Errors:** - 403: Organization lacks Enterprise plan or proper permissions - 404: Domain ID not found in organization - Verification may fail if DNS record not propagated yet (can take up to 48 hours) POST /api/organizations/{organization_id}/domains/{id}/verify/
Launch experiment in a PostHog project. Launch a draft experiment.
Launch survey in a PostHog project. Launch a survey by setting `start_date` to the current time. No-op if the survey is already launched (start_date set in the past) — returns the existing state unchanged. Does not affect archived surveys or surveys with an end_date in the past; unarchive or extend the end_date first.
List selector match changes in a PostHog project.
Fetch active live debugger breakpoints for a PostHog project, with optional enabled status, filename, or repository filters. Returns breakpoints from the response's results array; if that array is absent, the returned list is empty.
Tool to retrieve all alerts configured for a specific PostHog project. Use when you need to view alert configurations, check alert status, or monitor what alerts are set up. Returns paginated list of alerts with their configurations, thresholds, and current states.
List projects from the current organization in the authenticated user's profile, with organization context and counts.
This endpoint for listing/filtering events is deprecated and maintained only for compatibility. Users are discouraged from using it and should use the Query endpoint for ad-hoc lists/aggregations or CDP/Batch Exports for bulk exports.
List annotations in a PostHog project, with pagination and search options.
List all feature flags for a specific project with pagination support. Returns detailed information about each flag including its key, name, filters, rollout configuration, associated experiments/surveys, user access levels, and metadata. Use the project_id from LIST_ALL_PROJECTS_ACROSS_ORGANIZATIONS or similar actions.
List runs for a batch export by `batch_export_id` within a project. Supports pagination & ordering of the results. Requires `batch_export:read` permission. Returns status, errors, counts, and timestamps for each run.
List a page of conversation tickets for a project, with optional pagination. The returned person object does not retain person fields.
Retrieve the sharing configuration for a specified dashboard in a PostHog project using a personal API key. The response is modeled as a sharing configuration object.
Retrieve widget catalog in a PostHog project. List registered dashboard widget types and per-type config_schema documentation for agents.
List versions for a specific PostHog endpoint using the project ID and endpoint name. Limit and offset can be supplied to request a page of version history.
List endpoints in a PostHog project. Returns one page of results with pagination information.
Tool to list error tracking autocapture controls for a PostHog project. Returns paginated list of autocapture configurations including library settings, URL triggers, and sampling rates. Use when you need to view or audit error tracking autocapture settings.
List a project's error-tracking issues with offset pagination.
Retrieve matching experiment IDs in a PostHog project. Get IDs of all experiments matching the current list filters. Accepts the same query params as the list endpoint and returns only IDs of experiments the user has permission to edit.
Retrieve prompt templates in a PostHog project. List the LLM metric templates that can be passed to `create_from_prompt`.
Tool to list experiment saved metrics for a project with pagination support. Use when you need to retrieve saved metric configurations for experiments in a PostHog project.
Retrieve session context in a PostHog project. Resolve which experiments (and variants) a session recording saw. Variants come from the session's $feature_flag_called events and stamped $feature/<key> event properties — flag evaluation, which may differ from an experiment's exposure criteria.
List up to 50 newest synchronization jobs for one external data source, optionally filtered by creation time and schema name. Older jobs cannot be paged.
List current user's flags in a PostHog project.
This GET endpoint returns role access details for a feature flag in a project, needs 'project_id' & 'feature_flag_id', and offers optional 'limit' & 'offset' for pagination.
Tool to list file system resources for a PostHog project with pagination support. Use when you need to browse or search through available file system resources in a project.
Retrieve group activity in a PostHog project.
Retrieve heatmap events in a PostHog project. Drill into the individual session interactions behind one or more heatmap coordinates. Pass the 'points' you want to inspect (from the heatmaps list response) to get the underlying per-session events, so you can jump to the session recordings that produced a hotspot. Returns one page; use the documented pagination parameters for additional pages.
Retrieve trending insights in a PostHog project. Returns insights ranked by view count over the last N days (default 7), highest first. Each result includes the same metadata as the standard insights list, plus a `view_count` and up to 3 recent `viewers`. Useful for surfacing the most-used insights in a project. Returns one page; use the documented pagination parameters for additional pages.
Tool to retrieve breakpoint hit events from ClickHouse with optional filtering and pagination. Use when you need to view hit events containing stack traces, local variables, and execution context from your application's runtime. Breakpoint IDs are filtered to only include those belonging to the current team for security.
List one page of a project's LLM prompts with filtering and sorting. Use to discover prompts and their versions, labels, and content. Follow next using limit and offset to retrieve more pages; this action does not auto-page.
Retrieve notebook compute options in a PostHog project. Compute rates, presets, and the sizes the kernel config endpoint accepts. Static per region, so a client can fetch it once and price any shape a user picks. PostHog documents this notebook API as early access and subject to breaking changes.
List notebooks in a PostHog project, with optional filters and pagination. The notebook API is in early access and can have breaking changes without announcement.
List all session recording playlists for a PostHog project, including both user-created playlists and system-generated synthetic playlists (like "Watch history", "Recordings with comments", etc.). Session recording playlists organize recordings into collections or filter-based groups for easier analysis. Two playlist types exist: - 'filters': Dynamic playlists that automatically include recordings matching specified criteria - 'collection': Manual collections where recordings are explicitly added The response includes synthetic playlists (negative IDs) that are automatically maintained by PostHog, along with custom playlists created by users. Use pagination with limit/offset for large result sets. Requires 'session_recording_playlist:read' permission.
List persons in a PostHog project with optional filters and pagination.
Fetch a list of an organization's domains with pagination using `limit` and `offset`. Access requires `organization_id` and a PersonalAPIKeyAuth. Optional parameters available. Provides domain info, verification, and SAML setup.
Tool to list organization-level integrations with read-only access. Use when you need to view integrations scoped to an entire organization (e.g., Vercel, AWS Marketplace). Creation is handled by integration installation flows; deletion requires contacting support.
Retrieve a paginated list of all pending and active invites for an organization. This action lists all organization invites including: - Email address of invitees - Access level (1=member, 8=admin, 15=owner) - Invite status (expired/active) - Creator information - Optional custom messages Use pagination parameters (limit/offset) for large invite lists. The response includes total count and next/previous URLs for easy page navigation. Requires organization_member:read permission.
List all members of a specific organization with pagination support. Returns detailed member information including user profiles, membership levels, authentication status, and join dates. Use this to discover who has access to an organization, audit membership, or integrate with user management workflows. Supports pagination via limit and offset parameters for handling organizations with many members. Requires organization_member:read permission.
Retrieve the list of plugins for a specified organization. Supports pagination through 'limit' and 'offset' query parameters. Requires a valid organization UUID and PersonalAPIKeyAuth for access. Returns plugin details including types and status.
Retrieve a paginated list of custom domain proxy records for an organization. Proxy records enable routing PostHog analytics through your own domain to bypass ad blockers. Each record includes the domain, CNAME target, status ('waiting', 'issuing', 'live'), and metadata. Use 'limit' and 'offset' parameters for pagination. Requires organization read access.
List all roles in an organization with pagination support. Returns role details including ID, name, creation timestamp, creator information, assigned members, and default status. Use limit and offset parameters for pagination through large role lists. Requires authentication with PersonalAPIKeyAuth.
Retrieve paginated batch exports for an organization, including team, interval, and status details. Supports limit and offset pagination and uses Personal API key authentication.
Retrieve a paginated list of an organization's pipeline destinations by ID, with optional limit and offset parameters. Requires PersonalAPIKeyAuth (plugin:read).
Retrieve a paginated list of pipeline import applications for a specified organization by ID. Supports optional 'limit' and 'offset' query parameters for result pagination. Requires an organization UUID and a Personal API Key for authentication.
Retrieve a paginated list of an organization's pipeline transformations using limit and offset. Requires an organization ID and PersonalAPIKeyAuth.
Retrieve a paginated list of available pipeline frontend apps for a specific organization. Frontend apps are site apps that inject code into websites (e.g., notification bars, bug reporters, pineapple mode). Returns detailed information including app configuration schemas, versions, and metadata. Supports pagination via limit and offset parameters. Required: organization_id (UUID format) Optional: limit (number of results per page), offset (starting index)
Get paginated surveys for a project with its ID, using 'limit' and 'offset'. Needs PersonalAPIKeyAuth ('survey:read'). JSON output includes survey info, links, and metadata.
Retrieve cohorts for a person in a PostHog project.
List person deletion status in a PostHog project. List the status of queued event deletions for persons. When you delete a person with `delete_events=true`, an async deletion is queued. Use this endpoint to check whether those deletions are still pending or have been completed. Returns one page; use the documented pagination parameters for additional pages.
Retrieve person properties at a time in a PostHog project. Get person properties as they existed at a specific point in time.
List pipeline destination configurations for a given project by ID, with optional pagination through 'limit' and 'offset' query parameters. Returns details such as plugin info and delivery rates. Authentication required.
List all pipeline frontend app configurations for a project. Pipeline frontend apps are plugins that add UI extensions to PostHog (e.g., custom visualizations, dashboards, etc.). Returns a paginated list of configurations including enabled status, order, plugin details, and filters. Use 'limit' and 'offset' parameters for pagination.
Tool to retrieve a paginated list of product tours for a specific project. Use when you need to view all product tours configured in a project. Supports pagination with limit and offset, and search filtering.
Retrieve a paginated list of project actions, including IDs, names, descriptions, and metadata. Supports limit and offset pagination and a JSON or CSV format parameter; requires personal API key authentication.
Retrieve an indexed list of batch exports for a specified project with optional pagination. View export details, statuses, and pagination links. Requires project ID and supports PersonalAPIKeyAuth.
Retrieve logs for a specific plugin configuration within a project. Supports pagination with limit and offset query parameters. Requires project and plugin configuration IDs. Auth: PersonalAPIKeyAuth with plugin:read scope.
Retrieve the list of collaborators for a specific dashboard within a project. This endpoint returns all users who have been explicitly added as collaborators to the dashboard, along with their access levels and timestamps. Dashboard owners and project admins are not included in this list as they have inherent access. **Parameters:** - project_id: The project identifier (string). Get from POSTHOG_LIST_ALL_PROJECTS_ACROSS_ORGANIZATIONS. - dashboard_id: The dashboard identifier (integer). Get from POSTHOG_LIST_PROJECT_DASHBOARDS_WITH_PAGINATION. **Returns:** A list of collaborators with the following details for each: - user_uuid: Unique identifier of the collaborator - level: Access level (37 = can edit, 21 = can view) - added_at: Timestamp when the collaborator was added - updated_at: Timestamp of last update **Authentication:** Requires PersonalAPIKeyAuth with `dashboard:read` permission. **Note:** Returns an empty list if the dashboard has no explicit collaborators.
Retrieve available dashboard templates for a PostHog project. Dashboard templates are pre-configured dashboards that help users quickly set up analytics for common use cases like user research, pirate metrics (AARRR), web analytics, error tracking, and more. Each template includes ready-to-use insights and visualizations. Returns a paginated list of templates with their configuration, including tiles, filters, and preview images. Use the 'limit' and 'offset' parameters to paginate through results.
Get paginated dashboards for a project by ID, using 'limit' and 'offset'. Must authenticate with PersonalAPIKeyAuth. Includes count, pagination, and dashboard details.
Retrieve a paginated list of a project's early access features by ID with 'limit' and 'offset' parameters. An API key is needed. Includes feature info like creation date, stage, and documentation link.
Get a paginated list of experiments within a project using 'limit' and 'offset' parameters. Need a valid project ID and 'experiment:read' permission. Returns details like features and metrics.
Retrieve a paginated list of export items for a specific project by ID with optional 'limit' and 'offset' query parameters. Requires PersonalAPIKeyAuth for export:read permission. Supports multiple export formats.
List all group types configured for a PostHog project. Group types are used to organize entities (like companies, organizations, or teams) in PostHog analytics. Each project can have up to 5 group types (indexed 0-4). Returns an array of group type objects, each containing: - group_type: Unique identifier for the group type - group_type_index: Numeric index (0-4) - name_singular: Optional display name (singular form) - name_plural: Optional display name (plural form) Use this action before querying specific groups to discover available group types.
Retrieve a list of project membership details for a specified project by ID. Members and their roles, such as member or admin, are included along with their join and update timestamps. Note: This endpoint only works for projects with access control enabled (private projects). If the project does not have access control enabled, the API will return a 404 "Endpoint not found" error. Access control is an Enterprise feature that can be enabled in Project Settings > Access Control. To check if a project has access control enabled, use the POSTHOG_RETRIEVE_CURRENT_USER_PROFILE action and look for the "access_control" field in the team/project data.
List all pipeline transformation configurations for a specific project. Pipeline transformations enable you to modify, enrich, or filter events in realtime before they are ingested into PostHog. This endpoint returns a paginated list of all transformation configurations for the specified project. Use the `limit` and `offset` parameters to paginate through results.
List all plugin configurations for a specific project. Plugin configurations define which plugins (apps) are installed and enabled for a project, along with their settings and execution order. This endpoint returns a paginated list of all plugin configurations for the specified project. Use the `limit` and `offset` parameters to paginate through results.
Retrieve a paginated list of session recordings for a specific project, including viewing times and user interactions. Specify `project_id`, and use optional `limit` and `offset` query parameters to control result set size and starting point.
Retrieve a paginated list of subscriptions for a given project by its ID. Optional query params include 'limit' for results per page and 'offset' for results starting index. Authentication is required. Returns subscription details and navigation links.
List projects for a specified organization, with optional limit and offset pagination.
List all users assigned to a specific role within an organization. Role memberships represent the assignment of users to custom roles in PostHog. This endpoint returns a paginated list of users who have been assigned the specified role, allowing you to audit role assignments and manage access control. Use this action to: - View which users are assigned to a particular role - Audit role-based access control in your organization - Track role membership changes over time Pagination is controlled via 'limit' (page size) and 'offset' (starting position) query parameters. The 'organization_id' and 'role_id' are required path parameters that identify the specific role within a specific organization.
Retrieve a list of sharing configurations for a specific session recording in a project, including creation timestamps and access tokens. Requires project and recording IDs.
List signal reports for a PostHog project with filters and pagination.
List groups of a specific group type in a project, using a required search term and optional pagination cursor. Provide the group type index; valid group types can be listed via /api/:project_id/groups_types/.
Retrieve survey question labels in a PostHog project. Return a slim list of question labels for the team's surveys. Used by the frontend to resolve `$survey_response_<question_id>` property keys into human-readable question text without loading the full survey payload.
Retrieve a list of unused pipeline transformations for a specified organization, identified by UUID. Includes details like name, plugin type, and configuration. Supports JSON response format.
API endpoint fetches a user list with staff filter, pagination (limit, offset), and requires a personal API key. Data includes UUIDs, emails, and organizational details.
Tool to retrieve warehouse saved queries for a project. Use when you need to list or search saved queries from the data warehouse. Supports pagination via page parameter and filtering via search term.
Tool to retrieve a paginated list of web experiments for a specific project. Use when you need to discover available web experiments. Supports pagination via 'limit' and 'offset' parameters.
List pipeline import app configurations for a specified project, with pagination options 'limit' and 'offset'. Requires a project ID and supports PersonalAPIKeyAuth for security. Responds with JSON objects including configuration details.
Look up existing persons by distinct IDs in a PostHog project without changing them; only the first 200 IDs are processed, and each person includes at most 10 distinct IDs. JSON returns a map keyed by matched distinct ID; CSV returns raw text in data.
Look up existing persons by UUIDs without creating or changing them. Returns a map keyed by canonical UUID, omitting unmatched UUIDs. Only the first 200 inputs are processed; each person includes up to 10 distinct IDs. Empty input returns an empty results map. CSV format returns raw text in data.
Request usage-dashboard enrichment for a feature flag in a PostHog project.
Retrieve all feature flag definitions for a project to enable local evaluation. This endpoint returns flag configurations, cohort definitions, and group type mappings that allow SDKs and applications to evaluate feature flags locally without making additional API calls for each flag check. This improves performance and reduces latency when checking feature flags for users. Use this when implementing server-side local evaluation in your application or when you need to cache flag definitions.
Send a delete request for a dashboard template in a PostHog project.
Marks one or more insights as viewed by the current user for a specified project. This endpoint records user engagement with insights and is idempotent. Requires `project_id` and `insight_ids` (a list of insight IDs to mark as viewed). Supports optional `format` parameter ('csv' or 'json') to control response serialization. Use this to track which insights a user has viewed, helping to surface new or unviewed insights in the UI or analytics.
Tool to mark a specific product onboarding as complete for a PostHog project. Use when a user has finished onboarding for features like product_analytics, session_replay, feature_flags, surveys, error_tracking, or data_warehouse. Updates the project's onboarding completion status.
Migrate experiment in a PostHog project. Move a legacy experiment onto the new experiments engine.
PUT /api/organizations/{id}/: Update organization details by providing a UUID as 'id'. Supports JSON, form-urlencoded, multipart/form-data. Requires 'organization:write' permission. Returns updated organization data.
Move a tile from one dashboard to another in a PostHog project.
Move a PostHog file-system item or folder to a new path.
Partially update an experiment in a project using the project ID and experiment ID. Returns updated details and requires authentication.
The PATCH endpoint supports partial insight updates in a project, allows format specification (CSV/JSON), and requires `PersonalAPIKeyAuth` and `insight:write` scope for access.
Endpoint PATCH /api/projects/{project_id}/dashboards/{id}: Allows partial update of a project's dashboard with specified ID. Accepts JSON, form data, and provides a detailed response schema based on user license. Requires dashboard write access.
Partially update a feature flag in a PostHog project by its ID.
Partially update a notebook in a PostHog project by its short ID. The notebook API is in early access and can have breaking changes without announcement.
Partially update an annotation in a PostHog project by its ID.
Partially update a project property definition by UUID, including its property type or tags.
Update an existing batch export configuration in PostHog by partially modifying fields like name, paused status, destination, or schedule. Use when you need to modify batch export settings without replacing the entire configuration.
Update a customer profile configuration by partially modifying fields like content, scope, or sidebar. Use when you need to modify specific fields of an existing customer profile config without replacing the entire object.
Partially update a dataset in a PostHog project, including its name, description, or soft-delete status. Only supplied fields are sent.
Partially update a dataset item by ID in a PostHog project, including its input, output, metadata, reference fields, or deleted status.
Tool to partially update an endpoint for a project. Use when you need to modify specific fields of an existing endpoint without replacing the entire configuration.
Partially update an error tracking autocapture control configuration. Use this to modify settings like sample rate, URL triggers, event triggers, and match type for a specific autocapture control.
Update an evaluation by patching specific fields. Use when you need to modify evaluation settings like description, enabled status, or configuration.
Tool to partially update an experiment saved metric by ID in a PostHog project. Use when you need to modify specific fields of a saved metric configuration for experiments.
Tool to update an external data source in PostHog by patching specific fields like description or configuration. Use when you need to modify an existing data source without replacing all fields.
Tool to partially update a file system resource by UUID and project ID. Use when you need to update specific fields like last_viewed_at, metadata, or other file system attributes without replacing the entire resource.
Tool to partially update a file system shortcut in PostHog by its UUID. Use when you need to modify specific fields of an existing shortcut without replacing all data.
Tool to partially update a hog function by UUID and project ID. Use when you need to modify specific fields of a hog function such as description, enabled status, filters, or configuration without replacing the entire resource.
Update an insight variable by partially modifying its properties (name, type, default value, etc.). Use when you need to modify specific fields of an existing insight variable without replacing the entire object.
Tool to update a live debugger breakpoint by UUID and project ID. Use when you need to modify breakpoint properties like line number, enabled state, or condition without recreating it.
Tool to partially update a persisted folder by ID for a PostHog project. Use when you need to modify specific attributes of an existing persisted folder configuration.
Tool to partially update a product tour in PostHog. Use when you need to modify specific fields of an existing tour like description, archived status, dates, or content.
Tool to partially update a warehouse saved query in PostHog. Use when you need to modify properties like name, query definition, or sync frequency. Only the fields provided in the request will be updated; other fields remain unchanged.
Tool to partially update a warehouse table by patching specific fields like name, format, or schema. Use when you need to modify an existing warehouse table without replacing all fields.
Tool to partially update a web experiment in PostHog. Use when you need to modify specific fields of an existing web experiment without replacing the entire configuration.
Pause a batch export in PostHog to temporarily stop scheduled data exports. Use when you need to halt data exports without deleting the batch export configuration.
Pause experiment in a PostHog project. Pause a running experiment.
Pause an organization-level batch export in PostHog. Use when you need to temporarily stop scheduled data exports at the organization level without deleting the batch export configuration.
Request a partial update to a person in a PostHog project, including person properties.
The `/api/projects/{project_id}/insights/trend/` endpoint provides project trends in CSV/JSON, requires `project_id` and optional parameters, and needs 'PersonalAPIKeyAuth'. It outputs event data and cache status.
Send a delete request for a notebook identified by project ID and short ID. A 405 response is reported as hard deletion not allowed; a 404 is reported as notebook not found.
Create comprehensive funnel analysis for a PostHog project with advanced configuration options. Analyze user conversion through multi-step funnels with customizable time windows, ordering rules, visualization types, breakdowns, and exclusions. Requires at least 2 funnel steps defined via 'events' or 'actions'. Returns conversion rates, drop-off points, and completion metrics in JSON or CSV format. Supports strict/ordered/unordered step sequences, property-based segmentation, and group-level aggregation.
Query project logs using typed filters and cursor pagination.
Rearrange (reorder) the configuration of frontend apps in a project's data pipeline. Pipeline frontend apps are plugins that add UI extensions to PostHog such as custom visualizations, dashboards, and interactive components. This endpoint allows you to change the order in which these frontend apps are loaded or displayed, and update their configuration settings. **Usage**: Provide the project_id and the configuration details you want to update, including the order parameter to control sequencing. The order parameter determines the priority/sequence of frontend app execution. **Permissions**: Requires 'plugin:write' permission for the specified project. **Note**: This endpoint modifies existing frontend app configurations. Use the list_pipeline_frontend_app_configs action first to see current configurations before rearranging them.
Rearrange pipeline transformation configurations for a project, including order, enabled status, and configuration settings. The configured connection uses a personal API key.
Rearrange app import settings in a project using PATCH /api/projects/{project_id}/... by updating plug-in order and status. Requires `project_id` and a JSON with configurations.
Rearrange pipeline destination configurations for a project, including order, enabled status, and configuration settings. The configured connection uses a personal API key.
Reconfigure the order, enabled status, and settings of plugin configurations in a project. The configured connection uses a personal API key.
Delete a specific domain by its UUID within an organization, given valid organization and domain IDs. Requires 'organization:write' permission; no response body on success (204).
Delete an early access feature by ID from a specified project. Requires a UUID for the feature and the project's ID. Authentication via PersonalAPIKeyAuth is necessary. No response body upon success.
Delete a specific user (by UUID) from the explicit members of a given project. Requires 'project_id' and member's 'parent_membership__user__uuid'. Returns 204 on success with no response body. Note: This endpoint only works for projects with access control enabled (private projects). Access control is an Enterprise feature. If the project does not have access control enabled, the API will return a 404 "Endpoint not found" error.
DELETE /api/projects/{project_id}/feature_flags/{feature_flag_id}/role_access/{id}: Remove role access from a feature flag in a project by ID, requiring authorization. Expect no response body upon success (204).
Remove a member from a PostHog organization using the user's UUID, rather than the membership ID. A member who is not found is treated as successfully removed. Requires organization_member:write permission; you cannot remove yourself with this action.
Delete a specific pipeline import app plugin associated with an organization by ID. Requires a personal API key with write permissions for plugins. Responds with no content on success (204).
Delete a specific batch export by its UUID in an organization. Requires PersonalAPIKeyAuth with batch_export:write permission. Returns 204 on success with no response body.
Delete a specific pipeline destination in an organization by ID. Requires an integer 'id' of the destination, and the organization's 'uuid'. Auth: PersonalAPIKey with plugin:write. No return body on success (204).
Delete a specific pipeline transformation plugin for an organization by ID. Requires a UUID for the organization and an integer for the plugin. Auth: PersonalAPIKey with write access. No response body on success (204).
Delete a specific plugin (by its integer ID) from the organization (identified by UUID) with no response body on success. Requires plugin:write authorization via PersonalAPIKeyAuth.
Delete a proxy record by ID for a specific organization. Requires an authenticated user with 'organization:write' permission. On success, it responds with a 204 status and no content.
Delete a role with a specific UUID in an organization. Requires 'organization:write' permission. No response body on success (204). Path parameters include 'id' and 'organization_id'.
Remove a collaborator from a project dashboard. Provide the project_id, dashboard_id, and user's UUID. Requires 'dashboard:write' permissions. Expect no response body on success (204). Project ID guidance at '/api/projects/'.
Delete an event definition by providing its UUID and the associated project ID. Requires `event_definition:write` permission. Successful deletion returns no content (204 status).
Update the deleted flag of an experiment by its integer ID within a project, using a personal API key with experiment write permission. The flag defaults to true for soft deletion and can be set to false.
DELETE /api/projects/{project_id}/plugin_configs/{id}/: Removes a specific plugin configuration by ID from a given project. Requires 'plugin:write' permissions and project ID. Returns 204 with no body on success.
Delete a property definition by providing its UUID and the associated project ID. Requires 'property_definition:write' permission. On success, no response body is returned (204).
Remove a user from a custom organization role by deleting their role membership. This action permanently removes the specified user's membership in the role, revoking any permissions associated with that role. The operation is idempotent - attempting to remove a non-existent membership returns success. Use this action to: - Remove a user's access to a custom role - Revoke role-based permissions from a user - Clean up role memberships when users change responsibilities - Manage access control in your PostHog organization Requirements: - The organization must have access control enabled - You must have write permissions for the organization - The role must exist in the specified organization The action returns 204 No Content on successful deletion. Note that this removes the role membership but does not delete the user from the organization or the role itself.
Remove a session recording from a playlist in a PostHog project. This action only removes the recording from the playlist - it does not delete the recording itself. The recording remains available in the project and can be re-added to playlists later. Requires project_id (get via /api/projects/), short_id (playlist identifier), and session_recording_id. Returns HTTP 204 on success. The operation is idempotent - removing a non-existent recording succeeds. Useful for curating playlists by removing irrelevant or accidentally added recordings. Works with 'collection' type playlists.
Delete a specific batch export by providing the UUID and project ID. Requires a personal API key with 'batch_export:write' permissions. Responds with no body upon successful deletion (HTTP 204).
Cancel a specific project query by its ID. This operation is experimental.
Replace a desktop meeting recording in PostHog using PUT. Use when you need to completely replace all recording data including metadata, transcript, participants, and status. Unlike PATCH, this requires all mandatory fields and replaces the entire resource.
Reset experiment in a PostHog project. Reset an experiment back to draft state.
Reset a distinct_id for a deleted person. This allows the distinct_id to be used again. Use when you need to recycle a distinct_id from a previously deleted person for reuse.
Resume experiment in a PostHog project. Resume a paused experiment.
Retrieve person trends for a PostHog project.
Retrieve performance and error metrics for a specific plugin configuration (app) in a PostHog project. This action returns time-series data showing the success rate, failures, and retry statistics for a plugin configuration over the last 31 days. Use this to monitor the health and performance of installed apps/plugins in your PostHog project. The metrics include: - Daily counts of successful executions - Daily counts of executions that succeeded after retrying - Daily counts of failed executions - Aggregated totals across the time period - Error details (if any errors occurred) To find available plugin configuration IDs, first call the list_project_plugin_configurations action. Requires a personal API key with plugin:read access.
Retrieve detailed error information for a plugin configuration in a PostHog project, to investigate failures experienced by the app or plugin.
Retrieve the status of an asynchronous query by project and query ID. Experimental.
Retrieve details of a specific batch export by its UUID in a project. Requires project_id and batch export ID. Supports PersonalAPIKeyAuth and responds with export details including destination, interval, and status.
Retrieve activity log entries for a specific cohort in a project, including activity details and pagination information.
Retrieve details of persons within a cohort by its unique ID in the specified project. The endpoint supports JSON and CSV formats and requires authorization. Project and cohort IDs must be provided.
Fetch specific dashboard template details by UUID in a project with 'dashboard_template:read' rights using a PersonalAPIKeyAuth. Returns name, description, filters, and creation info.
Retrieve the JSON schema for dashboard templates of a specific project. Pass the project_id in the path and receive details such as template name, description, filters, and more. Supports GET requests.
Retrieve an event definition by its UUID within a specified project. Requires a project_id and an event definition ID, with access secured by PersonalAPIKeyAuth. (GET /api/projects/{project_id}/event_definitions/{id})
Retrieve a page of event definitions for a specified project. Requires Personal API key access with event_definition:read privileges.
Access detailed experiment info within a project using unique `experiment ID` & `project ID`, with 'experiment:read' rights. Response includes dates, feature flag key, metrics, creator details.
Retrieve details for experiments that require feature flag implementation in a specific project. Requires a valid 'project_id' and user must have 'experiment:read' permission. Returns information like experiment names, dates, flags, and creation data.
Retrieves export unsubscribe configurations for pipeline import apps in an organization. This endpoint returns a list of configurations that define how users can unsubscribe from various pipeline import app exports. Each configuration includes an ID, plugin type identifier, and configuration settings. Use case: Check which export import apps support unsubscribe functionality and their configuration details. This is useful for managing data export preferences and compliance requirements. Note: This endpoint may require specific organization permissions or enterprise features. If you receive a 403 Forbidden error, the organization may not have access to pipeline import apps or this specific feature may not be enabled.
Retrieve activity details for a specific feature flag in a PostHog project.
Retrieve detailed information about a specific feature flag in a PostHog project. This action fetches comprehensive details including: - Basic information (id, name, key) - Filter configuration and rollout percentages - Status (active, deleted) - Creator and modification history - Associated experiments, surveys, and features - Analytics and dashboard configurations - Access control and permissions - Tags and metadata Use this to inspect feature flag configuration, check status, or gather information before making updates. Requires a valid project_id and feature flag id.
Retrieve details for a specific role's access to a feature flag within a project. Requires 'feature_flag_id', 'id' for role access, and 'project_id'. Returns a JSON object with access details.
Retrieve the feature flag activity log for a PostHog project.
Retrieve feature flag evaluation results and reasons for a specified user in a PostHog project.
Get property definitions for a project using project_id, with filters for event names, property types, exclusions, and numerical or feature flags. Also, view properties relevant to specific events.
Execute a funnel analysis for a project using event or action steps. Returns conversion data showing how users progress through the funnel.
Retrieve a paginated list of group property definitions for a PostHog project, including group type index and other available metadata.
Retrieve group property values for a property key and group type in a PostHog project. The response is a list of strings.
Retrieve user's hedgehog configuration details by their UUID. This endpoint returns hedgehog-related settings (PostHog's mascot customization) for a user. Use '@me' as the uuid parameter to reference the current user. IMPORTANT: This endpoint does NOT support Personal API Key authentication. It requires session-based authentication (browser login) and will return a 403 "permission_denied" error with message "This action does not support Personal API Key access" when called with an API key. This is a limitation of the PostHog API, not the action implementation.
Retrieve historical export data for app metrics by supplying the `project_id` and `plugin_config_id`. Requires `plugin:read` permission. No response body provided upon a successful request.
Retrieve a log of important activities and changes for a specified project. This endpoint returns significant project events including creation, updates, and deletions of resources like dashboards, feature flags, insights, session recording playlists, tags, and other key entities. Each entry includes the activity type, affected item details, user information (if user-initiated), timestamps, and a detailed change log. System-generated activities are also included. Results are paginated and ordered by most recent first. Requires a `project_id`. Use the LIST_ALL_PROJECTS_ACROSS_ORGANIZATIONS action to obtain available project IDs.
Retrieve sharing configurations for a specific insight within a project, requiring project and insight IDs. Validates access via PersonalAPIKeyAuth. Returns data such as creation time and access tokens.
Returns basic details about the last 5 insights viewed by this user. Most recently viewed first.
Request matching events for session recordings in a PostHog project. The action does not expose a session ID or event/action filter and uses the configured personal API key.
Retrieve notebook activity for a PostHog project. The notebook API is in early access and may change without announcement.
Retrieve the activity log for a specific notebook in a PostHog project. The notebook API is in early access and may change without announcement.
Retrieve details of a specific notebook in a PostHog project. The notebook API is in early access and may change without announcement.
Retrieve person retention data for a PostHog project.
Retrieves persons who entered or progressed through a funnel in the specified project. Note: This endpoint requires that a funnel has been previously created and analyzed in PostHog. The endpoint returns person-level data for funnel analysis. For creating or analyzing new funnels, use the insights API endpoint at /api/projects/{project_id}/insights/funnel/. This is a read-only endpoint. To create or update persons, use the capture API with $set and $unset properties, or use PostHog SDKs.
Retrieve details for repository pipeline destinations within a specific organization by its UUID. Returns objects like ID, name, and URLs with support for various plugin types (local, custom, etc.).
Retrieve org pipeline transformation activity
Retrieve pipeline frontend app details for an organization using its 'organization_id' (UUID). Response includes ID, plugin type, name, URL in JSON format, covering various plugin types.
Retrieve export unsubscribe configurations for an organization's pipeline frontend apps. Returns a list of unsubscribe configurations defining how users can opt out of frontend app exports (e.g., notification bars, bug reporters). Each config includes an ID, plugin type, and settings. Required: organization_id (UUID). Use POSTHOG_RETRIEVE_CURRENT_USER_PROFILE to get it. **IMPORTANT**: This endpoint requires session-based authentication and does NOT support Personal API Key access. It may return a 403 error stating "This action does not support Personal API Key access" when used with API keys.
Retrieve plugin activity log entries for a specified organization by its UUID. Entries include activity, user, scope, timestamp, and related item details.
Retrieve a specific plugin's details for an organization. Requires the plugin's integer ID and the organization's UUID. Only returns plugin info if authenticated with 'plugin:read' permission. Responds with plugin data in JSON format.
Retrieve plugin repository details for a specific organization by its UUID, including plugin type, name, URL, and more. Accessible via GET request to '/api/organizations/{organization_id}/plugins/repository/'.
Retrieve export unsubscribe configurations for plugins in an organization. Returns a list of unsubscribe configurations for various plugin types (local, custom, repository, source, inline) that define how users can opt out of plugin-based exports. Each config includes details like plugin ID, type, name, description, URL, icon, and settings. Required: organization_id (UUID). Use POSTHOG_RETRIEVE_PAGINATED_ORGANIZATION_LIST to get it. **IMPORTANT**: This endpoint requires session-based authentication and may NOT support Personal API Key access. It may return a 403 Forbidden error when used with API keys. The endpoint may not be available on all PostHog instances or plans, or may require specific organizational permissions. If you receive a 403 error, the organization may not have access to this feature or the endpoint may be deprecated/removed from the PostHog API.
Retrieve details of a specific project in an organization using the organization ID and project ID.
Retrieve the details of a specific role within an organization using its UUID. Requires the organization's UUID and role's UUID in the path and is protected by PersonalAPIKeyAuth with 'organization:read' scope. Returns role data in JSON.
Retrieve unused pipeline import apps for a specified organization. Endpoint requires an organization_id (UUID) and returns details like plugin type, name, description, and more in JSON format.
Retrieve a paginated list of organizations with optional 'limit' and 'offset' query parameters. The response includes organization details like ID, name, and membership level, with secure access controlled via PersonalAPIKeyAuth.
Tool to retrieve a specific persisted folder by its UUID and project ID. Use when you need to get details about a persisted folder including its type, path, and timestamps.
Retrieve details for a person by ID in a PostHog project.
Retrieve unique values for a specific person property across all persons in a project. Returns a list of distinct values for the specified property key, along with the count of persons who have that value. Useful for understanding the distribution of person properties like cities, countries, email domains, or any custom person property. Example use cases: - Get all unique cities where users are located ($geoip_city_name) - Get all unique email domains in your user base (extract from email property) - Get distribution of any custom person property Note: For person creation or updates, use the capture API or SDKs.
Retrieve activity for a person in a PostHog project.
**Note**: This endpoint path appears to be incorrectly defined or deprecated in the PostHog API. The documented endpoint `/api/projects/{project_id}/persons/funnel/correlation/` returns 403 Forbidden, suggesting it either: 1. Does not exist as a standalone endpoint (correlation data may be accessed via `/api/projects/{project_id}/persons/funnel/` with query parameters) 2. Is an Enterprise Edition feature requiring a paid plan 3. Has been deprecated in favor of other funnel correlation endpoints For funnel correlation analysis, consider using: - `GENERATE_PROJECT_FUNNEL_CORRELATION_INSIGHT` to create correlation insights - `RETRIEVE_PROJECT_FUNNEL_CORRELATION_INSIGHTS` to retrieve correlation insights - `RETRIEVE_OR_DELETE_PROJECT_PERSONS_FUNNEL_DATA` for general funnel persons data This action requires additional query parameters beyond project_id to specify the funnel configuration (events, date ranges, correlation type, etc.) which are not currently defined in the request schema.
Retrieve pipeline destination activity for an organization, with optional limit and offset pagination. Results contain activity entries with associated users, item IDs, timestamps, and details.
Retrieve details of a specific pipeline destination config for a project by its ID. Requires project ID and destination config ID. Supports PersonalAPIKeyAuth for read access. Responds with config details including plugin info, status, and timestamps.
Fetch a pipeline destination's details by ID and organization UUID, using a PersonalAPIKeyAuth with read access to plugins. Returns JSON with plugin info.
Retrieve source files for a pipeline destination plugin by ID within an organization. The response maps filenames to source content.
Retrieve activity details for pipeline frontend apps within an organization by organization ID. Activity entries include the user, activity, affected item, and timestamp.
Retrieve detailed information about a specific pipeline frontend app within an organization. Pipeline frontend apps are site apps that inject code into websites to provide features like notification bars, bug reporters, pineapple mode, and early access features. This action returns comprehensive details including the app's configuration schema, version information, capabilities, and metadata. Use LIST_ORGANIZATION_S_PIPELINE_FRONTEND_APPS to discover available app IDs first, then use this action to get detailed information about a specific app. Required parameters: - organization_id (UUID): Use RETRIEVE_CURRENT_USER_PROFILE to get your organization ID - id (integer): The unique app ID from the list action
Retrieve details for a specific pipeline frontend app's source by its ID within an organization. Requires an integer ID of the app and UUID of the organization. Returns JSON object with app properties.
Retrieve the frontend configuration for a pipeline frontend app by project ID and config ID. The response can include configuration data, enabled status, order, plugin information, and timestamps.
Retrieve activity details for pipeline import apps in an organization, with optional limit and offset pagination. Results contain activity entries with users, affected item IDs, timestamps, and change details.
Retrieve detailed information about a specific pipeline transformation plugin by ID. Returns comprehensive plugin details including: - Plugin type (inline/custom), name, and description - Configuration schema for setting up the plugin - Capabilities (supported methods like processEvent, setupPlugin) - Version information (tag, latest_tag) - Organization ownership details - Availability for Hog function migration Use this to understand how to configure a pipeline transformation before creating a configuration for it. Requires organization-level access.
Retrieve source details for a pipeline transformation plugin by ID within an organization. The response model includes type, configuration inputs, and optional Hog source code.
Retrieve the frontend configuration details for a specific pipeline transformation by ID within a given project. This endpoint requires the project ID and transformation config ID in the path.
Retrieve plugin source files by organization UUID and integer plugin ID. The response is a mapping of source filenames to strings.
This endpoint retrieves update information for a specific plugin within an organization's pipeline frontend app by its integer ID and the organization's UUID. It returns details such as plugin type, name, and latest version.
Retrieve the latest update status for a specific plugin, identified by its integer ID, within an organization specified by UUID. Check compatibility and change logs.
Get details on a project action by ID. Supports JSON/CSV format via query. Needs 'project_id' and 'id' path parameters. Secured by PersonalAPIKeyAuth.
Retrieve the activity log for a specified project, showing recent changes and events. Returns a paginated list of activity entries including user actions, system events, and changes to resources like dashboards, feature flags, insights, cohorts, and other entities. Each entry includes details about what changed, who made the change, timestamps, and whether it was a user or system action. Useful for auditing project changes, tracking team activity, and understanding the history of modifications to your PostHog project resources. Requires a `project_id`. Use the LIST_ALL_PROJECTS_ACROSS_ORGANIZATIONS action to obtain available project IDs.
Retrieve the activity log history for insights in a specific project. Returns a paginated list of all insight-related activities (created, updated, deleted) with details about who performed each action and when. Useful for auditing changes, tracking insight modifications, and understanding insight usage patterns. Supports both JSON (default, structured data) and CSV formats for export. Requires an API key with activity_log:read permission.
Retrieve a project's activity log with cursor-based pagination. Returns activities like resource creation, updates, and deletions with details about the user who performed the action, timestamps, and change history. Use the cursor parameter from the 'next' field to fetch subsequent pages of results.
Retrieve details of a specific annotation in a project using the project ID and annotation ID.
Retrieve detailed information about a specific cohort within a project using its ID. Requires project ID and cohort ID; returns cohort details including name, creator info, and status. Auth: PersonalAPIKeyAuth with cohort:read permission.
Retrieve activity log entries for a project's cohorts, including activity details, the user who performed the action, and timestamps. Requires a project ID and personal API key authentication with activity_log:read permission.
Retrieve a paginated list of cohorts for a specific project using `project_id`. Supports `limit` and `offset` query params to customize the response. Requires `PersonalAPIKeyAuth` with `cohort:read` permissions.
Retrieve details of a specific early access feature in a project by ID. Requires project_id and feature UUID. Must have 'early_access_feature:read' permission. Returns feature details including status, flag info, and timestamps.
Retrieve details for a specific event by ID within a project. Supports CSV or JSON format. Requires project_id in path and adheres to PersonalAPIKeyAuth for security.
Request values for an event property key in a project, with CSV or JSON format selection. PostHog requires an event name for this endpoint when using a personal API key, but this tool does not expose that parameter.
Retrieve experiment timeseries results within a project by project and experiment ID. Aggregates daily results into a timeseries format for frontend compatibility. Requires project_id and experiment id in the path, plus metric_uuid and fingerprint query parameters. Returns experiment timeseries details in JSON, with authentication via PersonalAPIKeyAuth.
Retrieve detailed info on a specific export of a project using its unique ID. Requires project ID and supports various export formats like PNG, PDF, CSV, and XLSX. Auth: PersonalAPIKeyAuth with export:read scope.
Retrieve funnel correlation insights for a specific project. Analyzes which events or properties correlate with conversion success or failure in a funnel. Requires defining a funnel with at least 2 steps via 'events' or 'actions'. Returns correlation data showing which factors positively or negatively impact funnel conversion rates. Supports JSON/CSV output formats.
Retrieves specified group details within a project by group key and type index. Requires 'group_key', 'group_type_index', and 'project_id'. Responds with group details, including creation timestamp.
Retrieve insights activity for a specific project and insight ID, offering data in JSON or CSV format. Requires project_id and insight id in the path, with optional data format query. Secure access via PersonalAPIKeyAuth.
Retrieve details for a specific project insight by ID, with options to format as JSON/CSV, request refresh, and specify dashboard context. Supports PersonalAPIKeyAuth with insight read access. Responses include metadata, results, and caching info.
Retrieve a paginated list of insights for a project, with creator and short ID filters and JSON/CSV format options. Use limit and offset to page through results; the limit defaults to one, and insight read permission is required.
Retrieve detailed information about a specific user's membership level and status within a project by their UUID. Access project members' data, roles, and timestamps. (GET /api/projects/{project_id}/explicit_members/{uuid}) Note: This endpoint only works for projects with access control enabled (private projects). If the project does not have access control enabled, the API will return a 404 "Endpoint not found" error. Access control is an Enterprise feature that can be enabled in Project Settings > Access Control.
Retrieve paginated person activity for a project, with optional JSON or CSV format, page, and limit parameters.
Retrieve session property values for a project and a specified property key. Returns a list of values with pagination information.
Retrieve a specific subscription for a project, identified by 'project_id' and 'id'. Requires valid API key with read access. Supports GET method, returns subscription details including frequency, type, and creator info.
Retrieve saved insights from a PostHog project, optionally selecting an insight by short ID. Use limit and offset for pagination and choose CSV or JSON output to access previously created analysis reports.
Allows a caller to provide a list of event names and a single property name Returns a map of the event names to a boolean representing whether that property has ever been seen with that event_name
Retrieve details of a specific property definition by UUID within a project using personal API key authentication with read access.
Retrieve the list of session recordings within a playlist. Returns paginated results containing recording details like duration, activity counts, and timestamps. Use this to access recordings that have been added to a specific playlist in a project.
Retrieve related groups for a specific project and user. Requires 'project_id' (path), 'group_type_index', and user 'id' (query). Returns group details with type, key, and creation date.
DEPRECATED: Use POSTHOG_CREATE_RETRIEVE_RETENTION_INSIGHTS_FOR_PROJECT instead. Retrieve retention insights for a specified project using PostHog's Query API. Analyzes how users return over time based on specified events or actions. Uses the /api/projects/{project_id}/query/ endpoint with a RetentionQuery. Requires a project ID and authenticated access with 'insight:read' permission. If no query is provided, returns default retention data for $pageview events over 7 days.
Retrieve session property definitions for a specified project. Returns a page of definitions with pagination metadata.
Retrieve detailed information about a specific session recording by providing the session's UUID and associated project ID. The response includes metrics such as duration, activity, timestamps, and user data. Authentication is required.
Retrieve session recording error clusters for a project. A 404 is returned as a not-found result with an empty error-clusters list, which does not by itself establish that no clusters exist.
Retrieve session recording properties for a project, with limit and offset pagination. Non-success responses are returned as error information; a 404 is marked not found and a 403 is marked permission denied.
Retrieve the available snapshot sources for a session recording in a project. The request identifies the project and recording but does not select a source for fetching its snapshots.
Retrieve details of a specific batch export for an organization by its UUID. Requires a PersonalAPIKeyAuth with 'batch_export:read' permission. Responses include export details like name, model, destination, interval, and more.
Retrieve details for a specific batch export run within a project by ID. Requires a UUID for batch_export_id and run ID. Provides run status, record count, timestamps, latest error, and intervals. Security: PersonalAPIKeyAuth.
Retrieve complete details of a specific authentication domain within an organization by its UUID. Returns domain verification status, SAML SSO configuration, JIT provisioning settings, and SSO enforcement policies. Use this to check if a domain has been verified via DNS, view SAML configuration details, or audit authentication settings for a specific domain. Returns 200 with domain details on success, 404 if the domain doesn't exist or you don't have access. Requires authentication with `organization:read` scope.
Retrieve the content of a specific exported asset by ID within a project as a downloadable file. Requires 'export:read' permission.
Retrieve historical export data for a specific plugin configuration within a project. Requires project, plugin configuration, and export item IDs and personal API key authentication.
Retrieve the configuration details of a specific pipeline frontend app by providing its unique ID and the associated project ID. Pipeline frontend apps are plugins that extend PostHog's UI with custom visualizations, dashboards, and other frontend components. Returns config details including: - id: Unique identifier for the config - enabled: Whether the app is active - order: Display order in the UI - plugin: Plugin ID and metadata - config: Plugin-specific configuration - filters: Event filters applied - created_at, updated_at: Timestamps Note: Returns 404 error if the config ID doesn't exist in the specified project. Permissions required: 'plugin:read'.
Retrieve details of a specific dashboard within a project. Requires a dashboard ID & project ID, and returns information such as dashboard properties, owner, and access levels. Auth: PersonalAPIKeyAuth[dashboard:read].
Retrieve activity logs for specific survey in a project, identified by UUIDs. Requires valid API key with 'activity_log:read' permissions. Supports JSON response detailing survey's properties, types, and creator info.
Retrieve survey details using survey UUID and associated project ID. Supports secure access with 'PersonalAPIKeyAuth'. Returns survey name, type, linking, targeting flags, creator info, and questions with branching logic descriptions.
Retrieve survey response counts for a PostHog project, as a mapping from survey IDs to counts.
Retrieve export unsubscribe configurations for an organization's pipeline destinations. Returns a list of unsubscribe configurations defining how users can opt out of data exports to destinations (e.g., S3, BigQuery, Snowflake, Redshift). Each config includes an ID, plugin type, and settings. Required: organization_id (UUID). Use POSTHOG_RETRIEVE_CURRENT_USER_PROFILE or POSTHOG_LIST_ALL_PROJECTS_ACROSS_ORGANIZATIONS to get it. **IMPORTANT**: This endpoint requires session-based authentication and does NOT support Personal API Key access. It may return a 403 error stating "This action does not support Personal API Key access" when used with API keys.
Retrieve a list of pipeline frontend apps that are available but not currently in use within a specific organization. This is useful for discovering apps that could be enabled or removed. Returns details including app IDs, types, names, descriptions, and URLs. **IMPORTANT AUTHENTICATION NOTE**: This endpoint requires session-based authentication (cookie-based auth from browser sessions) and does NOT support Personal API Key authentication. When using Personal API Keys, this endpoint will return a 403 Forbidden error. To use this endpoint, authentication must be done through a browser session with proper organization access. Args: organization_id: The UUID of the organization to query Returns: A list of unused pipeline frontend apps with their metadata
Fetch user profile info including team, organization, and notifications. Non-staff users can only retrieve their own profile using '@me' as the uuid parameter. Staff users can retrieve any user's profile using their actual UUID. Returns JSON with name, email, teams, organizations, and status.
Tool to retry a failed or incomplete batch export run. Uses the same backfill mechanism as batch export backfills. Use when you need to re-execute a specific batch export run that failed or needs to be re-processed.
Delete an organization invite by its UUID. Requires a valid PersonalAPIKeyAuth with organization member write permission. No response body returned on success (HTTP 204).
Execute a predefined PostHog endpoint, including HogQL queries or insights, with optional variables and filter overrides. Supports selecting a version, result limit, refresh mode and debug information.
Save a full collaborative markdown notebook at its current version. Retrieve the notebook first for its short_id and version. Returns the persisted notebook with its new version. HTTP 409 means conflict; HTTP 410 means reload the notebook because the missing updates cannot be replayed. Does not execute cells or provision a kernel. This PostHog API is early access and may change.
Update LLM prompt label in a PostHog project.
Split distinct IDs from a person in a project. Optionally specify which distinct IDs to split off.
Stop survey in a PostHog project. Stop a survey by setting `end_date` to the current time. No new responses are accepted after this; existing responses remain available. No-op if the survey already has an end_date in the past.
Tool to generate an AI-powered summary of survey responses for a specific question. Use when you need to analyze and summarize feedback from survey respondents for a particular question.
Test an unsaved Hog function with controlled inputs. Async functions such as fetch are always mocked so the test cannot perform their real external side effects.
Test a saved Hog function using a supplied configuration or its staged draft. Async functions are always mocked to prevent real external side effects.
Tool to translate text to a target language using PostHog's LLM analytics translation endpoint. Use when you need to translate content for analytics or internationalization purposes.
Trigger an export of a dashboard or insight in a PostHog project using a specified export format, returning export information.
Unarchive experiment in a PostHog project. Unarchive an archived experiment.
Unarchive feature flag in a PostHog project. Restore an archived feature flag to the default flag list.
Unarchive named LLM prompt in a PostHog project.
Tool to unarchive a single survey response. Use when you need to restore a previously archived survey response to make it visible again in survey analytics.
Tool to unpause a paused batch export in PostHog. Use when you need to resume a previously paused batch export to restart data exports.
Tool to unpause a paused batch export at the organization level. Use when you need to resume a previously paused organization-level batch export to restart data exports.
Tool to fully update an existing alert configuration in PostHog using PUT method. Use when you need to completely replace alert settings including name, enabled status, insight, thresholds, and subscribed users. Unlike PATCH, this performs a full replacement of the alert configuration.
Tool to update an existing alert configuration in PostHog. Use when you need to modify alert settings such as name, enabled status, thresholds, or subscribed users. Performs a partial update (PATCH) - only fields provided in the request will be updated.
Update an existing annotation in a PostHog project by ID, including its content, date, scope, and deletion status.
Update an existing organization-level batch export configuration in PostHog, including settings such as name, schedule, destination, or filtering options.
Remove person from static cohort in a PostHog project.
Update a customer profile configuration by completely replacing it with new data via PUT request. Use when you need to update the entire customer profile config object including all fields.
Batch update widgets in a PostHog project. Update the settings of existing widgets in place, atomically — config, name, and description.
Tool to fully update a dataset item by its ID in a PostHog project using PUT method. Use when you need to replace all fields of a dataset item including dataset, input, output, and metadata.
Tool to update a dataset in PostHog by its ID and project ID. Use when you need to modify the name or description of an existing dataset.
Update desktop meeting recording details via PATCH. Use to modify meeting title, notes, status, transcripts, or AI-extracted tasks and summaries. Requires desktop_recording:write scope.
This PATCH endpoint updates a specific early access project feature. It requires `project_id` and `id` (UUID) as path parameters. The body can include feature details like `name`, `description`, and `stage`. Security: `PersonalAPIKeyAuth`.
Update an existing endpoint configuration in a PostHog project. Provide the project ID and endpoint name, optional configuration values, and optionally a version to target.
Tool to fully update an error tracking autocapture control configuration for a PostHog project. Use when you need to replace all settings of an existing autocapture control, including library, sample rate, URL triggers, event triggers, and match type.
Update only the description of one PostHog error tracking issue.
Tool to update an existing evaluation in PostHog using PUT request. Use when you need to fully replace an evaluation configuration. For partial updates, consider using the patch_evaluation action instead.
Update an event definition by sending a PUT request to '/api/projects/{project_id}/event_definitions/{id}/' using the UUID and project ID, provided you have 'event_definition:write' authorization.
Update an experiment by sending a PUT request with `project_id` and `id`, including new details as JSON/form data. Changes to name, description, dates, etc., allowed. `experiment:write` permission needed.
Tool to partially update an experiment holdout in a PostHog project. Use when you need to modify a holdout's name, description, or filter configuration. Updates only the fields provided in the request.
Tool to fully update an experiment holdout in PostHog using PUT method. Use when you need to replace all holdout configuration including name, description, and filters. All required fields must be provided.
Update an existing experiment saved metric by project and metric ID. The update requires its name and query, and can also include a description and tags.
Partially update an external data schema's sync configuration.
Update an existing external data source's credentials, description, or configuration in PostHog. Requires the project ID, data source UUID, account ID, and client secret.
Update the configuration of a specific feature flag in a PostHog project using its ID and key.
Update a PostHog file system resource by UUID and project ID using PUT, including its path, type, depth, or metadata. Omitted depth and last-viewed time are sent as null.
Update a specific group usage metric within a project and group type using a full PUT request. Supply its name and filters, with optional display format and calculation interval.
Tool to update a group usage metric configuration in PostHog. Use when you need to modify metric settings such as display format, filters, or interval. Performs a partial update (PATCH) - only fields provided in the request will be updated.
Tool to update a hog function by UUID and project ID using PUT method. Use when you need to modify a hog function with full replacement semantics.
Update an insight variable in a project by UUID using a PUT request. Provide its name, code name and type, with optional default value, values and creator metadata.
Tool to update a live debugger breakpoint for a project. Use when you need to modify breakpoint configuration such as filename, line number, enabled status, or condition.
Publish a new version of an existing PostHog LLM prompt by name. Supply a full prompt or sequential text edits, optionally with config and a version note. Use base_version to detect concurrent changes. This does not create a new named prompt or move version labels.
Tool to update an existing organization-level batch export configuration in PostHog. Use when you need to modify batch export settings like name, schedule, destination, or filtering options at the organization level.
Update specific details of an organization using its UUID. Requires organization:write permission and returns updated organization information.
Update an organization's authentication domain settings, including SAML SSO configuration and user provisioning policies. This action allows you to modify: - Domain name for authentication - Just-in-time (JIT) user provisioning settings - SSO enforcement policies - SAML identity provider configuration (Entity ID, ACS URL, X.509 certificate) Prerequisites: - The domain must be verified (DNS TXT record validation on PostHog Cloud) - SAML features require a PostHog Enterprise plan - User must have admin permissions for the organization Use cases: - Configure SAML SSO for enterprise authentication - Enable automatic user provisioning for verified domains - Enforce SSO login for specific email domains - Update SAML IdP certificates during rotation
Updates selected properties of a domain in an organization via PATCH request, supports various data formats but SAML fields are immutable. Authentication needed.
Update an organization member's access level and permissions. Use this to promote members to admin/owner or demote them to basic member access. Supports partial updates - only send the fields you want to change (typically just 'level'). Returns the complete updated membership record including user details, access level, authentication status, and timestamps. Requires organization_member:write permission. Common use cases: promoting a member to admin (level=8), granting owner access (level=15), or downgrading permissions (level=1). Note: You cannot modify your own membership level as a security restriction - use a different owner/admin to change your permissions.
Update member details in an organization by organization ID and user UUID. Requires organization member write permission and returns member information, including role and security settings.
Update an organization's proxy record configuration. Proxy records enable custom domain routing for PostHog analytics to bypass ad blockers. **WARNING**: This endpoint may have server-side issues and return 500 errors. The PostHog API for updating proxy records appears to have stability issues. Consider creating a new proxy record instead if updates fail. **Typical Use Cases**: - Update proxy record metadata or messages - Modify domain configuration (requires DNS reconfiguration) **Important Notes**: - Most proxy record fields (target_cname, status, timestamps) are managed by PostHog and should not be manually updated - Changing the domain requires updating your DNS CNAME records accordingly - Requires organization write access (organization:write permission) **Authentication**: Requires a valid API token with organization write permissions.
Update partial cohort details for a specific project. Requires a cohort ID and project ID, supports JSON, form data, and accepts patch changes like name or description. Returns updated cohort data. Auth required.
Partially update a role by ID within an organization, including its name.
PATCH /api/projects/{project_id}/subscriptions/{id}/: Update partial details of a specific project subscription by ID. Modify target, frequency, and more. Requires subscription:write permission.
Update partial survey details by PATCH to /api/projects/{project_id}/surveys/{id}/ with UUID. Edit attributes like name, type, questions, targeting, and flags. Needs PersonalAPIKeyAuth for write access.
Tool to update an existing persisted folder in PostHog. Use when you need to modify folder properties like path, protocol, or type.
Request data's "properties" will be updated on a person using "$set" event, affecting only listed properties without deletion or other changes. For property removal, use 'delete_property' endpoint.
Request an update to a specific property of a person in a PostHog project using a property key and value.
Update an existing PostHog product tour using PUT, including its name, description, targeting, content, and schedule. Requires the project ID, tour UUID, and tour name.
PUT endpoint '/api/projects/{project_id}/actions/{id}/' updates actions in a project by ID, accepts JSON/form data, supports 'format' query, and needs 'action:write' authentication.
Partially update a project action by project ID and action ID. Supports a CSV or JSON format parameter and requires action:write permission.
Update a project's batch export configuration using PUT. Requires the export's name, destination, interval, and pause status, with optional settings such as model, schedule, query, and filters.
Update cohort details of a specific project by ID. Requires project and cohort ID in the path and a JSON, form-encoded, or multipart form body. Permissions: cohort:write. Returns updated cohort data.
Endpoint to update an existing dashboard within a project. Provide `project_id` and `dashboard_id` in path, send JSON or form data with dashboard details. Requires `dashboard:write` permission; responds with updated dashboard data.
Update a specific early access feature of a project by providing the `project_id` and feature `id` (UUID). Requires a JSON body with feature details and responds with the updated status. Authentication via PersonalAPIKeyAuth is mandatory.
Update an event definition in a specified project by UUID, including its name, Slack posting setting, or tags. Requires event definition write permissions; the response is modeled as event definition details.
PATCH /api/projects/{project_id}/groups_types/update_metadata: Update group type metadata for a specific project using its project_id. Can modify name_singular and name_plural fields up to 400 characters each.
Endpoint "/api/projects/{project_id}/insights/{id}/" allows for updating an insight's details for a given project and insight ID, supporting JSON and CSV formats, with fields like name, query, and various timestamps. Requires insight write permission.
Update a project member's role using their UUID in a specific project. Accepts partial data to modify membership details such as role level, provided the member's UUID and project ID. Note: This endpoint only works for projects with access control enabled (private projects). Access control is an Enterprise feature that can be enabled in Project Settings > Access Control. If the project does not have access control enabled, the API will return a 404 "Endpoint not found" error. To use this endpoint: 1. Ensure the project has access_control: true (Enterprise feature) 2. Use list explicit_members endpoint to get existing member UUIDs 3. Provide the parent_membership_user_uuid (the user's UUID from membership)
Update explicit project membership using UUIDs. This PUT endpoint modifies a project member's role, where '1' stands for member and '8' for administrator. Requires `project_id` and `parent_membership__user__uuid`. Note: This endpoint only works for projects with access control enabled (private projects). If the project does not have access control enabled, the API will return a 404 "Endpoint not found" error. Access control is an Enterprise feature that can be enabled in Project Settings > Access Control.
Update a project notebook by its short ID, including its title, content, version, or deleted status. The notebook API is in early access and may have breaking changes without announcement.
Update a project property definition by its UUID, with a name and optional property type and tags. Requires a project ID and definition ID, and personal API key write access; returns property definition details.
Update an existing session recording playlist for a project with the specified project_id and playlist short_id. Requires JSON or form data input to modify the playlist's properties like name, description, and status.
Tool to update project settings and configuration within a PostHog organization. Use when you need to modify project properties such as timezone, feature toggles, or recording settings.
Update a subscription for a specific project. Provide project_id and subscription id in the path and use MIME types like application/json with fields like frequency, target_type, etc. Requires `subscription:write` permission.
The `/api/projects/{project_id}/surveys/{id}/` PUT endpoint updates survey details in a project using survey UUID and project ID, accepts JSON/form/multipart data, needs `survey:write` permission, and returns the updated survey.
Update an organization role's name and optionally its feature flag access level by specifying the organization and role IDs. Returns updated role data and requires organization write access.
Update session recording playlists using PATCH on the endpoint with `project_id` and `short_id`. Accepts JSON and forms data for detail amendments. Partial updates allowed. `PersonalAPIKeyAuth` needed.
Tool to update user home settings including homepage and tab configurations. Use when you need to modify the personalized home page and tab settings for a user.
Tool to update user profile settings in PostHog. Use when you need to modify user information such as name, email, role, theme preferences, or notification settings. Performs a partial update (PATCH) - only fields provided in the request will be updated. Use uuid '@me' to update the authenticated user.
Update a warehouse saved query in PostHog by completely replacing it with new data. Use when you need to update the name, query definition, or edit history of an existing saved query. This performs a complete update (PUT) operation requiring the edited_history_id for tracking changes.
Tool to completely update a web experiment in PostHog using PUT method. Use when you need to replace the entire web experiment configuration with new values. Unlike PATCH, this requires all fields to be provided.
Update workflow email action in a PostHog project.
Tool to validate LLM provider API keys without persisting them to PostHog. Use when you need to verify if an API key for an LLM provider is valid before saving it.
The PostHog integration connects your Dench AI CRM directly to PostHog, so agents can read and act on your PostHog data as part of everyday work — answering questions in chat, keeping your CRM in sync, and running automations without anyone copying data between tools.
690 actions are available for agents to invoke on your behalf, and 11 triggers can start a Dench automation the moment something changes in PostHog. Every call runs through PostHog's own authorization, scoped to the account you connect.
Sign in to your Dench workspace and open Integrations.
Find PostHog and click Connect — you'll authorize access through PostHog's own sign-in flow. No API keys or code required.
Ask an agent to use PostHog in chat, or wire a PostHog trigger into an automation.
Manage or disconnect the connection any time from workspace settings.
The Dench PostHog integration connects your AI CRM to PostHog, so AI agents can work with your PostHog data as part of chats, automations, and CRM workflows. You connect your account once, and every agent in your workspace can use it — governed by your workspace permissions.
The PostHog integration currently exposes 690 actions, including Accounts Notebooks Get, Add dashboard collaborators with access level, Add member to organization role, Add persons to static cohort, Add product intent to project, and Add project specific member roles. Agents invoke them on your behalf from chat or from automations.
Yes. The PostHog integration provides 11 triggers — such as Action Performed, Activity Log Entry Created, Early Access Feature Updated, and Error Tracking Issue Assigned — that can start a Dench automation the moment something happens in PostHog.
No. You connect PostHog from your Dench workspace using PostHog's own sign-in and authorization flow — no API keys to copy, no glue code to maintain.
Connections are authorized through PostHog's own authentication flow, and Dench stores only the authorization needed to act on your behalf. You can review and disconnect the PostHog connection from your workspace settings at any time.