---
title: OptimizelyConfig for the Go SDK
slug: feature-experimentation/docs/optimizelyconfig-go
docTags: 
createdAt: 2026-08-05T20:40:02.000Z
---

Optimizely Feature Experimentation SDKs open a well-defined set of public APIs, hiding implementation details. However, you may need access to project configuration data within the [datafile](docId:3LmHm4b3kTxKBuoR93KN8). The following section extends the public APIs to define data models and access methods, which you can use to access project configuration data.

A public configuration data model (OptimizelyConfig) is defined as a structured format of static Optimizely Project data.

### Get `OptimizelyConfig`

You can access `OptimizelyConfig` through the `OptimizelyClient` (top-level) using this public API call.

```go
client, err := optimizelyFactory.Client()
if err != nil {
	// handler error
}
var config = client.GetOptimizelyConfig()
```

`getOptimizelyConfig` returns an `OptimizelyConfig` instance containing the following:

- Environment key
- SDK key
- Datafile revision number
- Experiments mapped by key values
- All attributes
- All audiences
- All events
- Feature flags mapped by key values
- Function to retrieve the project configuration (the datafile)

:::hint{type="info"}
When the system updates the SDK datafile, you can add a notification listener for `ProjectConfigUpdateNotification` to get notified. After receiving the notification, call the method to get the updated `OptimizelyConfig` data. Refer to the following examples.
:::

### Get datafile

To share the same datafile between multiple SDK instances, such as in a client or server scenario, pass a JSON string representation of the config (the datafile) between instances. To get the datafile, use the `OptimizelyConfig` object's `GetDatafile` method. For information, see [Sharing the datafile with multiple SDK implementations](docId\:eH-UMm_rOn_GdGDGLV6__).

### Object model

The following shows the object model for `OptimizelyConfig`:

```go
type OptimizelyConfig struct {
	EnvironmentKey string
	SdkKey         string
	Revision       string

	// This experimentsMap is for experiments of legacy projects only.
	// For flag projects, experiment keys are not guaranteed to be unique
	// across multiple flags, so this map may not include all experiments
	// when keys conflict.
	ExperimentsMap map[string]OptimizelyExperiment

	FeaturesMap map[string]OptimizelyFeature
	Attributes  []OptimizelyAttribute
	Audiences   []OptimizelyAudience
	Events      []OptimizelyEvent
}

type OptimizelyExperiment struct {
	ID            string
	Key           string
	Audiences     string
	VariationsMap map[string]OptimizelyVariation
}

type OptimizelyFeature struct {
	ID              string
	Key             string
	ExperimentRules []OptimizelyExperiment
	DeliveryRules   []OptimizelyExperiment
	VariablesMap    map[string]OptimizelyVariable

	// Deprecated: Use experimentRules and deliveryRules
	ExperimentsMap map[string]OptimizelyExperiment
}

type OptimizelyVariation struct {
	ID             string
	Key            string
	FeatureEnabled bool
	VariablesMap   map[string]OptimizelyVariable
}

type OptimizelyVariable struct {
	ID    string
	Key   string
	Type  string
	Value string
}

type OptimizelyAttribute struct {
	ID  string
	Key string
}

type OptimizelyAudience struct {
	ID         string
	Name       string
	Conditions string
}

type OptimizelyEvent struct {
	ID            string
	Key           string
	ExperimentIds []string
}
```

## Examples

You can access `OptimizelyConfig` from the `OptimizelyClient` (top-level) using the following code example:

```go
optimizelyConfig := optimizelyClient.GetOptimizelyConfig()

	fmt.Println("[OptimizelyConfig] revision = " + optimizelyConfig.Revision)
	fmt.Println("[OptimizelyConfig] sdkKey = " + optimizelyConfig.SdkKey)
	fmt.Println("[OptimizelyConfig] environmentKey = " + optimizelyConfig.EnvironmentKey)

	fmt.Println("[OptimizelyConfig] attributes:")
	for _, attribute := range optimizelyConfig.Attributes {
		fmt.Println("[OptimizelyAttribute]   -- (id, key) = " + attribute.ID + ", " + attribute.Key)
	}
	fmt.Println("[OptimizelyConfig] audiences:")
	for _, audience := range optimizelyConfig.Audiences {
		fmt.Println("[OptimizelyAudience]   -- (id, name, conditions) = " + audience.ID + ", " + audience.Name + ", " + audience.Conditions)
	}
	fmt.Println("[OptimizelyConfig] events:")
	for _, event := range optimizelyConfig.Events {
		fmt.Println(fmt.Sprintf("[OptimizelyEvent]   -- (id, key, experimentIds) = %s, %s, %v", event.ID, event.Key, event.ExperimentIds))
	}

	// all flags
	flagKeys := []string{}
	for flagKey := range optimizelyConfig.FeaturesMap {
		flagKeys = append(flagKeys, flagKey)
	}

	for _, flagKey := range flagKeys {
		flag := optimizelyConfig.FeaturesMap[flagKey]

		experimentRules := flag.ExperimentRules
		deliveryRules := flag.DeliveryRules

		// use experiment rules and delivery rules and other flag data here...

		for _, experiment := range experimentRules {
			fmt.Println("[OptimizelyExperiment]   - experiment rule-key = " + experiment.Key)
			fmt.Println("[OptimizelyExperiment]   - experiment audiences = " + experiment.Audiences)

			variationKeys := []string{}
			variationsMap := experiment.VariationsMap
			for variationKey, _ := range variationsMap {
				variationKeys = append(variationKeys, variationKey)
			}

			for _, varKey := range variationKeys {
				variation := variationsMap[varKey]
				fmt.Println(fmt.Sprintf("[OptimizelyVariation]       -- variation = { key: %s, id: %s, featureEnabled: %v }", varKey, variation.ID, variation.FeatureEnabled))

				variablesMap := variationsMap[varKey].VariablesMap
				variableKeys := []string{}

				for variableKey := range variablesMap {
					variableKeys = append(variableKeys, variableKey)
				}

				for _, variableKey := range variableKeys {
					variable := variablesMap[variableKey]

					fmt.Println(fmt.Sprintf("[OptimizelyVariable]           --- variable: %s, %v", variableKey, variable))
				}
			}
		}

		for _, delivery := range deliveryRules {
			fmt.Println("[OptimizelyExperiment]   - delivery rule-key = " + delivery.Key)
			fmt.Println("[OptimizelyExperiment]   - delivery audiences = " + delivery.Audiences)

			// use delivery rule data here...
		}
	}

	// listen to NotificationType.datafileChange to get updated data
	callback := func(notification notification.ProjectConfigUpdateNotification) {
		var newOptConfig = optimizelyClient.GetOptimizelyConfig()
		fmt.Println("[OptimizelyConfig] revision = " + newOptConfig.Revision)
	}
	optimizelyClient.ConfigManager.OnProjectConfigUpdate(callback)
```