Open source feature flagging and experimentation platform for stress free deployments, measured impact, and smarter decisions.

GrowthBook Users

set the channel topic: Ask questions here related to the Python SDK.

set the channel description: Ask questions here related to the Python SDK.

Hello Team. I’m confused with this line <https://github.com/growthbook/growthbook-python/blob/main/growthbook.py#L879>  it is joining base url with client_key like `<https://cdn.growthbook.io/api/features/client_key>. but from the <https://docs.growthbook.io/api/#tag/features/operation/getFeature|api doc,> the string after `features` can be a feature name. why here a client_key is added at the end of url ? isn’t client_key is used for authentication?

Hi Chylli,

Good morning and thank you for writing in.

Natasha here from the Support Engineering team assisting you today- nice to e-meet you!!

In regards to your query, it looks like you are querying about 2 different end points.

<https://github.com/growthbook/growthbook-python/blob/main/growthbook.py#L879|This line> is for the ​`api/features`​ which gets all features, which is why you will need the ​`client­_key`​, as with that key you may access all the <https://docs.growthbook.io/api/#tag/features/operation/listFeatures|features>.

However, the API doc you linked <https://docs.growthbook.io/api/#tag/features/operation/getFeature|here> is for ​`getFeature`​ singular (not all features but a singular feature).

Please, can you confirm which specific feature you wish to get?

Hope this helps to provide context into the distinction and looking forward to your response on the feature you wish to get :slightly_smiling_face:

Warm regards,

Natasha

Hi!

Our team is having issues with SDK Webhooks. We cannot get our "test" call to successfully be verified.
• We tried creating our verification in Python using hmac (same as the example in the documentation that is in Javascript)
• We tried using the "standard webhooks" package
• Last resort we tried the example in Javascript that was in the documentation, and that does not match either
Is it possible the "shared secret" field for the SDK Webhook is wrong or there is a bug?

<@U077LKXUEFQ> not sure if you’re the one to ping. ^

does anyone else have this issue on the python sdk currently :confused: <https://github.com/growthbook/growthbook-python/issues/33>

Hello,

I have been trying to use growthbook's OpenFeature python SDK provider to integrate with our application. I'm seeing strange behavior where it infinitely hangs, even if I follow the simple setup to a T.

I am able to get feature flag values by directly referencing the `GrowthBookClient` , but not when using the `OpenFeatureClient` as documented. Does anyone in these chats have context on setting this python SDK up?

Full details are listed in the issue: <https://github.com/growthbook/growthbook-openfeature-provider-python/issues/5> (edited)

Thanks for reporting this, <@U08P3AMJ1N1> ! I've shared with our SDK engineer. I'll also see if I can replicate/understand what's happening here.

This is a weird behavior and works fine for me with mocked features though.

I'm checking on it.

Please let me know if I can provide more info, either in slack or on the issue. I might be able to strip down to a barebones FastAPI project to isolate it further.

Okay, I was able to verify the above issue was fixed. Thanks so much for the timely response! I closed out the issue.

Unfortunately, I'm coming across another issue in the async integration of `growthbook-openfeature-provider-python`. The good news is I believe this would be a very easy fix if you are okay with upgrading the requirement for `openfeature-sdk` from 0.7.4 to 0.8.1, with a minor corresponding change.

Please let me know thoughts in this issue, or if I'm way off mark.

<https://github.com/growthbook/growthbook-openfeature-provider-python/issues/13>

Glad you got sorted! <@U07LDUS5Z8Q> might be able to help

Hey <@U077LKXUEFQ> <@U07LDUS5Z8Q>, happy Friday. No big rush but have you had a chance to look into the above yet?

<@U08P3AMJ1N1> This was resolved. Let me share the tag with you. --> `0.0.5`

<@U08P3AMJ1N1>, Just FYI..  `0.0.5` it addresses the issue with `run_async` returning a task instead of the expected result, but it executes a blocking operation in async contexts.

`0.0.6` will be released soon(_probably tomorrow. Still testing it_) that will have the complete async methods using the latest open feature provider.

This is huge, thanks so much for the update Madhu! I'll wait on 0.0.6 since we are working around it with hooks directly into some of the growthbook client implementation, and it's working fine so far. Will watch out for 0.0.6!

Hi team,

I'm wondering how to improve this code for batch processing:

```global experiment_df
experiment_df = []

def on_experiment_viewed(experiment, result):
    experiment_df.append({
        "experiment_id": experiment.key,
        "variation_id": result.key,
    })```
I want to insert data in the feature flags table, but the only way to get an experiment data (not feature value) that I found in Python SDK is to use this ugly `global` construction.

Heyy.. Great question!

We do have tracking plugins with built-in batch processing. This plugin will automatically ingest events to our built-in warehouse that you can access on the Growthbook portal. It does support an `additional_callback` parameter for any custom implementations.

if you use the latest sdk, here's what you can do

```from growthbook import GrowthBook
from growthbook.plugins import growthbook_tracking_plugin
import time

# Your batch processor - this runs in addition to GrowthBook's tracking
def custom_batch_processor(experiment, result):
    """
    This callback is called for every experiment view, in addition to 
    the plugin sending data to GrowthBook servers.
    """
    experiment_data = {
        "experiment_id": experiment.key,
        "variation_id": result.variationId,
        "variation_value": result.value,
        "in_experiment": result.inExperiment,
        "user_id": result.hashValue,
        "hash_attribute": result.hashAttribute,
        "timestamp": int(time.time() * 1000)
    }
    
    # Insert directly into your feature flags table
    # This could be immediate insert or your own batching logic
    insert_into_feature_flags_table([experiment_data])
    
    # Or add to your own batch if you want different batching logic
    # your_custom_batch.append(experiment_data)

# Initialize GrowthBook 
gb = GrowthBook(
    attributes={"id": "user-123"},
    plugins=[
        growthbook_tracking_plugin(
            ingestor_host="<https://gb-ingest.growthbook.io>",  # Still sends to GrowthBook
            track_experiment_viewed=True,
            track_feature_evaluated=False,  # Only track experiments
            batch_size=10,                  # GrowthBook's batching (doesn't affect your callback)
            batch_timeout=30.0,             # GrowthBook's timeout (doesn't affect your callback)
            additional_callback=custom_batch_processor  # YOUR custom logic runs here
        )
    ]
)```

Or if you want your own batching within the callback, you could do the following, where you have full control:

```import threading
from typing import List, Dict

class FeatureFlagsBatcher:
    def __init__(self, batch_size: int = 20):
        self.batch_size = batch_size
        self._batch: List[Dict] = []
        self._lock = threading.Lock()
    
    def add_experiment(self, experiment, result):
        """Called by the additional_callback."""
        with self._lock:
            self._batch.append({
                "experiment_id": experiment.key,
                "variation_id": result.variationId,
                "variation_value": result.value,
                "in_experiment": result.inExperiment,
                "user_id": result.hashValue,
                "timestamp": int(time.time() * 1000),
            })
            
            # Your own batching logic
            if len(self._batch) &gt;= self.batch_size:
                self._flush_to_database()
    
    def _flush_to_database(self):
        if self._batch:
            batch_copy = self._batch.copy()
            self._batch.clear()
            # Insert into YOUR feature flags table
            insert_into_feature_flags_table(batch_copy)
            print(f"Inserted {len(batch_copy)} experiments into feature flags table")

# Create your batcher
feature_flags_batcher = FeatureFlagsBatcher(batch_size=15)

gb = GrowthBook(
    attributes={"id": "user-123"},
    plugins=[
        growthbook_tracking_plugin(
            ingestor_host="<https://gb-ingest.growthbook.io>",  # GrowthBook gets data
            additional_callback=feature_flags_batcher.add_experiment  # You get data too
        )
    ]
)```

Hello, I'm curious what is a good practice to initialize the growthbook client in python. Should the client be initialized once globally without any attributes and assume that the features will get refreshed every `cache_ttl` seconds as per the legacy client example shown here:<https://docs.growthbook.io/lib/python#built-in-fetching-and-caching>, and every feature evaluation use it's own set attributes, *OR* since attributes is needed for initializing the client in every example shown, the client be created whenever an evaluation is needed.

I believe I could create the client once and use set_attributes on every feature evaluation, though I'm afraid what would happen in a concurrent evaluation?

Hi Swapnil, the GrowthBook client should be created for every evaluation.

To keep it efficient, use the built-in fetching/caching in the SDK (`api_host`, `client_key`, `cache_ttl`) or use a shared cache (e.g., Redis) so features are reused across instances. Each request creates its own `GrowthBook(attributes=...)`, calls `load_features` (which is cached), evaluates, then destroys.

The AI-powered chat widget in the lower right corner of our documentation site was actually pretty helpful for this question, in case you want to check it out!

<https://docs.growthbook.io/>