Tools And Features Hogql
PostHogOfficialCreated by PostHog
- Skill
- Tool integration
- Data and AI
- MIT
- No issues found
AutoGineer summary
Written by AutoGineer from the skill’s own files, not by the author
HogQL is PostHog's SQL dialect, designed as a wrapper around ClickHouse SQL to simplify data access and analytics within the PostHog platform. This skill provides the essential reference material for constructing queries, including how to access event and person properties, utilize PostHog-specific functions, and integrate UI-based filters into your SQL insights. It emphasizes performance and efficiency, offering guidelines on aggregation, time-range filtering, and query structure to help users build effective analytics dashboards.
What it does
- Provides syntax patterns for querying events, persons, and sessions.
- Explains how to access event and person properties using specific dot notation.
- Details the use of the {filters} placeholder for dynamic dashboard filtering.
- Lists supported ClickHouse functions and aggregation methods for data analysis.
- Offers performance optimization tips like using uniq() over count(distinct).
- Provides guidance on using cohort and action-based filtering in SQL.
When to use it
- When you need to create custom SQL insights in PostHog.
- When you want to perform complex data analysis beyond standard UI-based reports.
- When you need to optimize existing queries for better performance.
- When you are building dashboards that require dynamic date ranges or user-defined filters.
Advantages
- Simplifies complex ClickHouse SQL for common analytics tasks.
- Enables seamless integration with PostHog's UI-based filtering system.
- Provides access to specialized PostHog functions like windowFunnel and sequenceMatch.
- Promotes efficient query patterns to reduce load on the underlying database.
Usage examples
- “Write a HogQL query to count pageviews by browser.”
- SELECT properties.$browser AS browser, count() FROM events WHERE event = '$pageview' AND {filters} GROUP BY browser
- “How do I count unique users in a HogQL query?”
- Use the uniq() function instead of count(distinct) for better performance, for example: SELECT uniq(person_id) FROM events WHERE {filters}
Install
Download the skill as a ZIP:
https://autogineer.com/agent-skills/posthog/tools-and-features-hogql/downloadUnzip it into the cross-client skills folder of your project:
mkdir -p .agents/skills && unzip tools-and-features-hogql.zip -d .agents/skills
Documentation by PostHog
HogQL queries for PostHog
This skill helps you write HogQL queries for PostHog analytics. HogQL is PostHog's SQL dialect, a wrapper around ClickHouse SQL with simplified property access and PostHog-specific functions.
Reference files
references/expressions.md- Sql expressions - docsreferences/aggregations.md- Supported aggregations - docsreferences/clickhouse-functions.md- Supported clickhouse functions - docsreferences/data-access.md- Accessing data using sql - docsreferences/variables.md- Sql variables - docsreferences/useful-functions.md- Useful sql functions - docsreferences/posthog.md- PostHog table schemas (events, persons, groups, sessions)references/sessions.md- Sessions - docs
Consult the documentation for SQL syntax, available functions, and query patterns.
Key principles
Property access: Use
properties.$property_namefor event properties andperson.properties.$property_namefor person propertiesNull handling: HogQL has simplified null handling compared to raw ClickHouse SQL
Filters placeholder: Use
{filters}in queries to allow UI-based filtering in PostHog dashboardsAggregations: Prefer ClickHouse aggregation functions like
count(),uniq(),avg(),sum()
Common patterns
Event queries
SELECT event, count()
FROM events
WHERE {filters}
GROUP BY event
ORDER BY count() DESCProperty breakdowns
SELECT properties.$browser AS browser, count()
FROM events
WHERE event = '$pageview' AND {filters}
GROUP BY browserPerson properties
SELECT person.properties.email, count()
FROM events
WHERE {filters}
GROUP BY person.properties.emailFramework guidelines
Use properties.$name syntax for event properties, person.properties.$name for person properties
Use bracket notation for special characters like properties['$feature/cool-flag']
For cohorts, filter with person_id IN COHORT 'cohort-name'
For actions, use matchesAction('action-name') in WHERE clauses
Include {filters} placeholder in WHERE clauses to enable UI-based filtering in dashboards
Use {variables.name} for reusable SQL variables across dashboards
Access dashboard date range with {filters.dateRange.from} and {filters.dateRange.to}
ALWAYS include a time range filter - shorter is faster (e.g., timestamp >= now() - INTERVAL 7 DAY)
Prefer uniq() over count(distinct) for counting unique values - it's more efficient
Don't scan the same table multiple times - use materialized views for reusable subsets
Use timestamp-based pagination instead of OFFSET for large datasets
Name queries descriptively for easier debugging in query_log
Use dateTrunc() for time-based grouping (e.g., dateTrunc('day', timestamp))
For funnel queries, use windowFunnel() or sequenceMatch() functions
Test queries in the PostHog SQL editor before using them in insights or the API
Files
- ATTRIBUTION.mdAdded by AutoGineer972 B
- LICENSELicence file added by AutoGineer1.0 KiB
- SKILL.md3.0 KiB
- references/aggregations.md3.8 KiB
- references/clickhouse-functions.md12.3 KiB
- references/data-access.md4.4 KiB
- references/expressions.md7.8 KiB
- references/posthog.md13.3 KiB
- references/sessions.md12.5 KiB
- references/useful-functions.md13.1 KiB
- references/variables.md2.8 KiB
references/data-access.md
Accessing data using SQL - Docs
Strings and quotes
Quotation symbols work the same way they would work with ClickHouse, which inherits from ANSI SQL:
Single quotes (
') for Strings literals.Double quotes (
") and Backticks (`) for DataBase identifiers.
For example:
SQL
PostHog AI
SELECT * FROM events WHERE properties.`$browser` = 'Chrome'Types
Types (and names) for the accessible data can be found in the database, properties tabs in data management as well as in the SQL tab for external sources. They include:
STRING(default)JSON(accessible with dot or bracket notation)DATETIME(inISO 8601, read more in our data docs)INTEGERFLOATBOOLEAN
For example:
SQL
PostHog AI
SELECT round(properties.$screen_width * properties.$screen_height / 1000000, 2) as `Screen MegaPixels` FROM events LIMIT 100This works because $screen_width and $screen_height are both defined as numeric properties. Thus you can multiply them.
To cast a string property into a different type, use type conversion functions, such astoString, toDate, toFloat, JSONExtractString, JSONExtractInt, and more.
Property access
To access a property stored on an event or person, just use dot notation. For example properties.$browser or person.properties.$initial_browser. You can also use bracket notation like properties['$feature/cool-flag'].
Nested property or JSON access, such as properties.$some.nested.property, works as well.
PostHog's properties include always include
$as a prefix, while custom properties do not (unless you add it).
Property identifiers must be known at query time. For dynamic access, use the JSON manipulation functions from below on the properties field directly.
Some queries can error when accessing null values. To avoid this, use the COALESCE function to replace null values with a default value or filter NULL values with IS NOT NULL and use assumeNotNull to cast a column to a non-null type.
Actions
To use actions in SQL insights, use the matchesAction() function. For example, to get a count of the action clicked homepage button, you can do:
SQL
PostHog AI
SELECT count()
FROM events
WHERE matchesAction('clicked homepage button')For more customization when using actions, start by selecting you action in the actions tab under data management.
In the action details under "Matching events," click the export dropdown and select "Edit SQL directly."
Image: Action SQLImage: Action SQL
This opens an SQL insight using the action. You can then copy parts of the SQL, like the WHERE filter or columns under SELECT, to use in your own insights.
Cohorts
To use cohorts in SQL insights, simply filter where person_id IN COHORT '{name}'.
For example, to get a count of users in the Power user cohort:
SQL
PostHog AI
select count()
from persons
where id IN COHORT 'Power users'To get a count of events for users in the Power user cohort:
SQL
PostHog AI
select count()
from events
where person_id IN COHORT 'Power user'Community questions
Ask a question
Was this page useful?
HelpfulCould be better
Requirements and compatibility
Works with: Claude Code, Claude apps, OpenAI Codex, GitHub Copilot, Cursor, Gemini CLI, Kiro, OpenCode, Goose, Amp, Roo Code, JetBrains Junie, Factory Droid, Devin (ex-Windsurf), Mistral Vibe, OpenHands, Letta
“Works with” means the tool reads the open Agent Skills format; a skill written for one tool may use features others lack.
Security
No issues found by our static scan· No issues found
A static scan is not a guarantee. Skills are third-party content: review a skill before you let an agent use it.
Attribution and licence
- Created by
- PostHog
- Publisher
- PostHog (Official)
- Source
- PostHog/skills · skills/posthog/tools-and-features/skills/hogql · commit a5d30e7
- Licence
- MIT License (redistribution allowed)
- LICENSE (added by AutoGineer from LICENSE)
- ATTRIBUTION.md (written by AutoGineer)
- Synced
- Also distributed in
- PostHog/skills
AutoGineer is not affiliated with or endorsed by PostHog or PostHog.
Download ZIP
The ZIP holds the skill’s files, its licence files and an ATTRIBUTION.md. Download tools-and-features-hogql.zip