Python

Last updated:

|Edit this page
Which features are available in this library?
  • Event capture
  • Autocapture
  • User identification
  • Session recording
  • Feature flags
  • Group analytics

This is an optional library you can install if you're working with Python. It uses an internal queue to make calls fast and non-blocking. It also batches requests and flushes asynchronously, making it perfect to use in any part of your web app or other server side application that needs performance.

Installation

Terminal
pip install posthog

In your app, import the posthog library and set your project API key and host before making any calls.

Python
from posthog import Posthog
posthog = Posthog('<ph_project_api_key>', host='<ph_instance_address>')

Note: As a rule of thumb, we do not recommend having API keys in plaintext. Setting it as an environment variable is best.

You can find your project API key and instance address in the project settings page in PostHog.

To debug, you can toggle debug mode:

Python
posthog.debug = True

To make sure no calls happen during tests, you can disable PostHog, like so:

Python
if settings.TEST:
posthog.disabled = True

Capturing events

You can send custom events using capture:

Python
posthog.capture('distinct_id_of_the_user',
'user signed up')

Tip: We recommend using a '[object][verb]' format for your event names, where '[object]' is the entity that the behavior relates to, and '[verb]' is the behavior itself. For example, project created, user signed up, or invite sent.

Setting event properties

Optionally, you can also include additional information in the event by setting the properties value:

posthog.capture(
"distinct_id_of_the_user",
"user signed up",
{
"login_type": "email",
"is_free_trial": "true"
}
)

Sending page views

If you're aiming for a backend-only implementation of PostHog and won't be capturing events from your frontend, you can send pageviews from your backend like so:

Python
posthog.capture('distinct id', '$pageview', {'$current_url': 'https://example.com'})

Setting user properties

To set user properties, include the properties you'd like to set when capturing an event:

Python
posthog.capture(
'distinct_id',
event='event_name',
properties={
'$set': {'name': 'Max Hedgehog'},
'$set_once': {'initial_url': '/blog'}
}
)

For more details on the difference between $set and $set_once, see our user properties docs.

Alias

Sometimes, you may want to assign multiple distinct IDs to a single user. This is helpful in scenarios where your primary distinct ID may be inaccessible. For example, if a distinct ID which is typically used on the frontend is not available in certain parts of your backend code. In this case, you can use alias to assign another distinct ID to the same user.

We strongly recommend reading our docs on alias to best understand how to correctly use this method.

Feature flags

PostHog's feature flags enable you to safely deploy and roll back new features.

There are 2 steps to implement feature flags in Python:

Step 1: Evaluate the feature flag value

Boolean feature flags

Python
is_my_flag_enabled = posthog.feature_enabled('flag-key', 'distinct_id_of_your_user')
if is_my_flag_enabled:
# Do something differently for this user
# Optional: fetch the payload
matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')

Multivariate feature flags

Python
enabled_variant = posthog.get_feature_flag('flag-key', 'distinct_id_of_your_user')
if enabled_variant == 'variant-key': # replace 'variant-key' with the key of your variant
# Do something differently for this user
# Optional: fetch the payload
matched_flag_payload = posthog.get_feature_flag_payload('flag-key', 'distinct_id_of_your_user')

Step 2: Include feature flag information when capturing events

If you want use your feature flag to breakdown or filter events in your insights, you'll need to include feature flag information in those events.

This ensures that the feature flag value is attributed correctly to the event.

Note: this step is only required for events captured using our server-side SDKs or API.

There are two methods you can use to include feature flag information in your events:

Method 1: Include the $feature/feature_flag_name property

In the event properties, include $feature/feature_flag_name: variant_key:

Python
posthog.capture(
'distinct_id_of_your_user',
'event_name',
{
'$feature/feature-flag-key': 'variant-key' # replace feature-flag-key with your flag key. Replace 'variant-key' with the key of your variant
}
)

Method 2: Set send_feature_flags to true

The capture() method has an optional argument send_feature_flags, which is set to false by default. By setting this to true, feature flag information will automatically be sent with the event.

Note that by doing this, PostHog will make an additional request to fetch feature flag information before capturing the event. So this method is only recommended if you don't mind the extra API call and delay.

Python
posthog.capture(
'distinct_id_of_your_user',
'event_name',
send_feature_flags=True
)

Fetching all flags for a user

You can fetch all flag values for a single user by calling get_all_flags() or get_all_flags_and_payloads().

This is useful when you need to fetch multiple flag values and don't want to make multiple requests.

Python
posthog.get_all_flags('distinct_id_of_your_user')
posthog.get_all_flags_and_payloads('distinct_id_of_your_user')

Advanced: Overriding server properties

Sometimes, you may want to evaluate feature flags using person properties, groups, or group properties that haven't been ingested yet, or were set incorrectly earlier.

You can provide properties to evaluate the flag with by using the person properties, groups, and group properties arguments. PostHog will then use these values to evaluate the flag, instead of any properties currently stored on your PostHog server.

For example:

Python
posthog.get_feature_flag(
'flag-key',
'distinct_id_of_the_user',
person_properties={'property_name': 'value'},
groups={
'your_group_type': 'your_group_id',
'another_group_type': 'your_group_id'},
group_properties={
'your_group_type': {'group_property_name': 'value'},
'another_group_type': {'group_property_name': 'value'}
},
)

Local Evaluation

Evaluating feature flags requires making a request to PostHog for each flag. However, you can improve performance by evaluating flags locally. Instead of making a request for each flag, PostHog will periodically request and store feature flag definitions locally, enabling you to evaluate flags without making additional requests.

It is best practice to use local evaluation flags when possible, since this enables you to resolve flags faster and with fewer API calls.

For details on how to implement local evaluation, see our local evaluation guide.

Experiments (A/B tests)

Since experiments use feature flags, the code for running an experiment is very similar to the feature flags code:

Python
variant = posthog.get_feature_flag('experiment-feature-flag-key', 'user_distinct_id')
if variant == 'variant-name':
# Do something

It's also possible to run experiments without using feature flags.

Group analytics

Group analytics allows you to associate an event with a group (e.g. teams, organizations, etc.). Read the Group Analytics guide for more information.

Note: This is a paid feature and is not available on the open-source or free cloud plan. Learn more here.

  • Capture an event and associate it with a group
Python
posthog.capture('[user distinct id]', 'some event', groups={'company': 'company_id_in_your_db'})
  • Update properties on a group
Python
posthog.group_identify('company', 'company_id_in_your_db', {
'name': 'Awesome Inc.',
'employees': 11
})

The name is a special property which is used in the PostHog UI for the name of the Group. If you don't specify a name property, the group ID will be used instead.

GeoIP properties

Before posthog-python v3.0, we added GeoIP properties to all incoming events by default. We also used these properties for feature flag evaluation, based on the IP address of the request. This isn't ideal since they are created based on your server IP address, rather than the user's, leading to incorrect location resolution.

As of posthog-python v3.0, the default now is to disregard the server IP, not add the GeoIP properties, and not use the values for feature flag evaluations.

You can go back to previous behaviour by doing setting the disable_geoip argument in your initialization to False:

Python
posthog = Posthog('api_key', disable_geoip=False)

The list of properties that this overrides:

  1. $geoip_city_name
  2. $geoip_country_name
  3. $geoip_country_code
  4. $geoip_continent_name
  5. $geoip_continent_code
  6. $geoip_postal_code
  7. $geoip_time_zone

You can also explicitly chose to enable or disable GeoIP for a single capture request like so:

Python
posthog.capture('test id', 'test event', disable_geoip=True|False)

Serverless environments (Render/Lambda/...)

By default, the library buffers events before sending them to the capture endpoint, for better performance. This can lead to lost events in serverless environments, if the python process is terminated by the platform before the buffer is fully flushed. To avoid this, you can either:

  • ensure that posthog.flush() is called after processing every request, by adding a middleware to your server: this allows posthog.capture() to remain asynchronous for better performance.
  • enable the sync_mode option when initializing the client, so that all calls to posthog.capture() become synchronous.

Django

For Django, you can do the initialisation of the key in the AppConfig, so that it's available everywhere.

in yourapp/apps.py

Python
from django.apps import AppConfig
import posthog
class YourAppConfig(AppConfig):
def ready(self):
posthog.api_key = '<ph_project_api_key>'
posthog.host = '<ph_instance_address>' # You can remove this line if you're using app.posthog.com

Then, anywhere else in your app you can do:

Python
import posthog
def purchase(request):
# example capture
posthog.capture(request.user.pk, 'purchase', ...)

Integrations

Sentry

When using Sentry in Python, you can connect to PostHog in order to link Sentry errors to PostHog user profiles.

Example implementation

See the sentry_django_example project for a complete example.

Python
import sentry_sdk
from sentry_sdk.integrations.django import DjangoIntegration
from posthog.sentry.posthog_integration import PostHogIntegration
PostHogIntegration.organization = "orgname"
sentry_sdk.init(
dsn="https://examplePublicKey@o0.ingest.sentry.io/0",
integrations=[DjangoIntegration(), PostHogIntegration()],
)
# Also set `posthog_distinct_id` tag
from sentry_sdk import configure_scope
with configure_scope() as scope:
scope.set_tag('posthog_distinct_id', 'some distinct id')

Example implementation with Django

This can be made automatic in Django, by adding the following middleware and settings to settings.py:

Python
MIDDLEWARE = [
"posthog.sentry.django.PosthogDistinctIdMiddleware"
]
POSTHOG_DJANGO = {
"distinct_id": lambda request: request.user and request.user.distinct_id
}

Alternative name

As our open source project PostHog shares the same module name, we created a special posthoganalytics package, mostly for internal use to avoid module collision. It is the exact same.

Thank you

This library is largely based on the analytics-python package.

Questions?

Was this page useful?

Next article

React

PostHog makes it easy to get data about traffic and usage of your React app. Integrating PostHog into your site enables analytics about user behavior, custom events capture, session recordings, feature flags, and more. This guide will walk you through an example integration of PostHog using React and the posthog-js library . Installation Usage PostHog Provider The React context provider makes it easy to access the posthog-js library in your app. The provider can either take an initialized…

Read next article