> ## Documentation Index
> Fetch the complete documentation index at: https://docs2.growthbook.io/llms.txt
> Use this file to discover all available pages before exploring further.
# Webhooks Events
> Reference of the event types GrowthBook can send to event webhooks, covering experiments, feature flags, and user changes.
We currently support the following event types:
| Event name | Description |
| ------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **[feature.created](#feature-created)** | Triggered when a feature is created |
| **[feature.updated](#feature-updated)** | Triggered when a feature is updated |
| **[feature.deleted](#feature-deleted)** | Triggered when a feature is deleted |
| **[feature.saferollout.ship](#feature-saferollout-ship)** | Triggered when a safe rollout is completed and safe to rollout to 100%. |
| **[feature.saferollout.rollback](#feature-saferollout-rollback)** | Triggered when a safe rollout has a failing guardrail and should be reverted. |
| **[feature.saferollout.unhealthy](#feature-saferollout-unhealthy)** | Triggered when a safe rollout is failing a health check and may not be working as expected. |
| **[feature.rampSchedule.created](#feature-rampSchedule-created)** | Triggered when a ramp schedule is created for a feature |
| **[feature.rampSchedule.deleted](#feature-rampSchedule-deleted)** | Triggered when a ramp schedule is deleted from a feature |
| **[feature.rampSchedule.actions.started](#feature-rampSchedule-actions-started)** | Triggered when a feature ramp schedule starts |
| **[feature.rampSchedule.actions.completed](#feature-rampSchedule-actions-completed)** | Triggered when a feature ramp schedule completes all steps |
| **[feature.rampSchedule.actions.rolledBack](#feature-rampSchedule-actions-rolledBack)** | Triggered when a feature ramp schedule is rolled back or reset to start |
| **[feature.rampSchedule.actions.jumped](#feature-rampSchedule-actions-jumped)** | Triggered when a feature ramp schedule is jumped to a specific step |
| **[feature.rampSchedule.actions.step.advanced](#feature-rampSchedule-actions-step-advanced)** | Triggered when a feature ramp schedule advances to the next step |
| **[feature.rampSchedule.actions.step.approvalRequired](#feature-rampSchedule-actions-step-approvalrequired)** | Triggered when a feature ramp step is waiting for approval |
| **[feature.rampSchedule.actions.awaitingStartApproval](#feature-rampSchedule-actions-awaitingstartapproval)** | Triggered when a feature ramp schedule is published but held at the start, awaiting an explicit start approval |
| **[feature.rampSchedule.actions.startApproved](#feature-rampSchedule-actions-startapproved)** | Triggered when a held ramp schedule's start is approved by a user |
| **[feature.revision.created](#feature-revision-created)** | Triggered when a new draft revision is created for a feature |
| **[feature.revision.updated](#feature-revision-updated)** | Triggered when a draft revision is modified (rules, default value, toggles, prerequisites, metadata, etc.). The `change` field indicates the specific kind of mutation. |
| **[feature.revision.reviewRequested](#feature-revision-reviewrequested)** | Triggered when a draft revision is submitted for review |
| **[feature.revision.approved](#feature-revision-approved)** | Triggered when a draft revision is approved by a reviewer |
| **[feature.revision.changesRequested](#feature-revision-changesrequested)** | Triggered when a reviewer requests changes on a draft revision |
| **[feature.revision.commented](#feature-revision-commented)** | Triggered when a comment is added to a draft revision |
| **[feature.revision.discarded](#feature-revision-discarded)** | Triggered when a draft revision is discarded |
| **[feature.revision.reopened](#feature-revision-reopened)** | Triggered when a discarded draft revision is reopened as a draft |
| **[feature.revision.rebased](#feature-revision-rebased)** | Triggered when a draft revision is rebased onto the latest published version |
| **[feature.revision.published](#feature-revision-published)** | Triggered when a draft revision is published. Overlaps with `feature.updated` but provides revision-specific context (base version, comment, author). |
| **[feature.revision.reverted](#feature-revision-reverted)** | Triggered when a feature is reverted to a previous published revision |
| **[experiment.created](#experiment-created)** | Triggered when an experiment is created |
| **[experiment.updated](#experiment-updated)** | Triggered when an experiment is updated |
| **[experiment.deleted](#experiment-deleted)** | Triggered when an experiment is deleted |
| **[experiment.warning](#experiment-warning)** | Triggered when a warning condition is detected on an experiment |
| **[experiment.info.significance](#experiment-info-significance)** | Triggered when a goal or guardrail metric reaches significance in an experiment (e.g. either above 95% or below 5% chance to win). Be careful using this without Sequential Testing as it can lead to peeking problems. |
| **[experiment.info.scheduled-status-update](#experiment-info-scheduled-status-update)** | Triggered when a scheduled start or stop is automatically applied to an experiment, including the auto-ship outcome for a scheduled end. |
| **[experiment.decision.ship](#experiment-decision-ship)** | Triggered when an experiment is ready to ship a variation. |
| **[experiment.decision.rollback](#experiment-decision-rollback)** | Triggered when an experiment should be rolled back to the control. |
| **[experiment.decision.review](#experiment-decision-review)** | Triggered when an experiment has reached the desired power point, but the results may be ambiguous. |
| **[savedGroup.created](#savedgroup-created)** | Triggered when a saved group is created |
| **[savedGroup.updated](#savedgroup-updated)** | Triggered when a saved group is updated |
| **[savedGroup.deleted](#savedgroup-deleted)** | Triggered when a saved group is deleted |
| **[savedGroup.revision.created](#savedgroup-revision-created)** | Triggered when a new draft revision is created for a saved group |
| **[savedGroup.revision.updated](#savedgroup-revision-updated)** | Triggered when a draft revision's proposed changes are modified (values, condition, archive, or metadata). The `change` field indicates the kind of mutation. |
| **[savedGroup.revision.reviewRequested](#savedgroup-revision-reviewrequested)** | Triggered when a draft revision is submitted for review |
| **[savedGroup.revision.approved](#savedgroup-revision-approved)** | Triggered when a draft revision is approved by a reviewer |
| **[savedGroup.revision.changesRequested](#savedgroup-revision-changesrequested)** | Triggered when a reviewer requests changes on a draft revision |
| **[savedGroup.revision.commented](#savedgroup-revision-commented)** | Triggered when a comment is added to a draft revision |
| **[savedGroup.revision.discarded](#savedgroup-revision-discarded)** | Triggered when a draft revision is discarded |
| **[savedGroup.revision.rebased](#savedgroup-revision-rebased)** | Triggered when a draft revision is rebased onto the latest live state |
| **[savedGroup.revision.published](#savedgroup-revision-published)** | Triggered when a draft revision is published. Overlaps with `savedGroup.updated` but provides revision-specific context. |
| **[savedGroup.revision.reverted](#savedgroup-revision-reverted)** | Triggered when a saved group is reverted to a previous published revision |
| **[savedGroup.revision.reopened](#savedgroup-revision-reopened)** | Triggered when a discarded revision is reopened |
| **[user.login](#user-login)** | Triggered when a user logs in |
### feature.created
Triggered when a feature is created
```typescript theme={null}
{
event: "feature.created";
object: "feature";
api_version: string;
created: number;
data: {
object: {
id: string;
dateCreated: string;
dateUpdated: string;
archived: boolean;
description: string;
/** The userId of the owner (or raw owner name/email for legacy records) */
owner: string;
project: string;
valueType: "boolean" | "string" | "number" | "json";
defaultValue: string;
tags: string[];
environments: Record;
/** Feature IDs. Each feature must evaluate to `true` */
prerequisites?: string[] | undefined;
revision: {
version: number;
comment: string;
date: string;
createdBy: string;
publishedBy: string;
};
customFields?: Record | undefined;
holdout?: ({
/** Holdout ID */
id: string;
/** The feature value assigned to users in the holdout treatment group */
value: string;
} | null) | undefined;
};
};
user: {
type: "dashboard";
id: string;
email: string;
name: string;
} | {
type: "api_key";
apiKey: string;
id?: string | undefined;
name?: string | undefined;
email?: string | undefined;
} | {
type: "system";
subtype?: string | undefined;
id?: string | undefined;
} | null;
tags: string[];
/** The environments affected by the change described by this event. For live-state events (e.g. `feature.updated`) these are the environments whose effective configuration actually changed; for draft lifecycle events (`*.revision.*`) they are the environments the proposed changes would affect. Webhook environment filters match against this field. An empty array means the event has no environment-scoped impact (it will only be delivered to subscriptions without an environment filter). */
environments: string[];
containsSecrets: boolean;
}
```
### feature.updated
Triggered when a feature is updated
```typescript theme={null}
{
event: "feature.updated";
object: "feature";
api_version: string;
created: number;
data: {
object: {
id: string;
dateCreated: string;
dateUpdated: string;
archived: boolean;
description: string;
/** The userId of the owner (or raw owner name/email for legacy records) */
owner: string;
project: string;
valueType: "boolean" | "string" | "number" | "json";
defaultValue: string;
tags: string[];
environments: Record;
/** Feature IDs. Each feature must evaluate to `true` */
prerequisites?: string[] | undefined;
revision: {
version: number;
comment: string;
date: string;
createdBy: string;
publishedBy: string;
};
customFields?: Record | undefined;
holdout?: ({
/** Holdout ID */
id: string;
/** The feature value assigned to users in the holdout treatment group */
value: string;
} | null) | undefined;
};
previous_attributes: {
id?: string | undefined;
dateCreated?: string | undefined;
dateUpdated?: string | undefined;
archived?: boolean | undefined;
description?: string | undefined;
/** The userId of the owner (or raw owner name/email for legacy records) */
owner?: string | undefined;
project?: string | undefined;
valueType?: ("boolean" | "string" | "number" | "json") | undefined;
defaultValue?: string | undefined;
tags?: string[] | undefined;
environments?: Record | undefined;
/** Feature IDs. Each feature must evaluate to `true` */
prerequisites?: string[] | undefined;
revision?: {
version: number;
comment: string;
date: string;
createdBy: string;
publishedBy: string;
} | undefined;
customFields?: Record | undefined;
holdout?: ({
/** Holdout ID */
id: string;
/** The feature value assigned to users in the holdout treatment group */
value: string;
} | null) | undefined;
};
changes?: {
added: Record;
removed: Record;
modified: Record;
} | undefined;
};
user: {
type: "dashboard";
id: string;
email: string;
name: string;
} | {
type: "api_key";
apiKey: string;
id?: string | undefined;
name?: string | undefined;
email?: string | undefined;
} | {
type: "system";
subtype?: string | undefined;
id?: string | undefined;
} | null;
tags: string[];
/** The environments affected by the change described by this event. For live-state events (e.g. `feature.updated`) these are the environments whose effective configuration actually changed; for draft lifecycle events (`*.revision.*`) they are the environments the proposed changes would affect. Webhook environment filters match against this field. An empty array means the event has no environment-scoped impact (it will only be delivered to subscriptions without an environment filter). */
environments: string[];
containsSecrets: boolean;
}
```
### feature.deleted
Triggered when a feature is deleted
```typescript theme={null}
{
event: "feature.deleted";
object: "feature";
api_version: string;
created: number;
data: {
object: {
id: string;
dateCreated: string;
dateUpdated: string;
archived: boolean;
description: string;
/** The userId of the owner (or raw owner name/email for legacy records) */
owner: string;
project: string;
valueType: "boolean" | "string" | "number" | "json";
defaultValue: string;
tags: string[];
environments: Record;
/** Feature IDs. Each feature must evaluate to `true` */
prerequisites?: string[] | undefined;
revision: {
version: number;
comment: string;
date: string;
createdBy: string;
publishedBy: string;
};
customFields?: Record | undefined;
holdout?: ({
/** Holdout ID */
id: string;
/** The feature value assigned to users in the holdout treatment group */
value: string;
} | null) | undefined;
};
};
user: {
type: "dashboard";
id: string;
email: string;
name: string;
} | {
type: "api_key";
apiKey: string;
id?: string | undefined;
name?: string | undefined;
email?: string | undefined;
} | {
type: "system";
subtype?: string | undefined;
id?: string | undefined;
} | null;
tags: string[];
/** The environments affected by the change described by this event. For live-state events (e.g. `feature.updated`) these are the environments whose effective configuration actually changed; for draft lifecycle events (`*.revision.*`) they are the environments the proposed changes would affect. Webhook environment filters match against this field. An empty array means the event has no environment-scoped impact (it will only be delivered to subscriptions without an environment filter). */
environments: string[];
containsSecrets: boolean;
}
```
### feature.saferollout.ship
Triggered when a safe rollout is completed and safe to rollout to 100%.
```typescript theme={null}
{
event: "feature.saferollout.ship";
object: "feature";
api_version: string;
created: number;
data: {
object: {
featureId: string;
safeRolloutId: string;
environment: string;
};
};
user: {
type: "dashboard";
id: string;
email: string;
name: string;
} | {
type: "api_key";
apiKey: string;
id?: string | undefined;
name?: string | undefined;
email?: string | undefined;
} | {
type: "system";
subtype?: string | undefined;
id?: string | undefined;
} | null;
tags: string[];
/** The environments affected by the change described by this event. For live-state events (e.g. `feature.updated`) these are the environments whose effective configuration actually changed; for draft lifecycle events (`*.revision.*`) they are the environments the proposed changes would affect. Webhook environment filters match against this field. An empty array means the event has no environment-scoped impact (it will only be delivered to subscriptions without an environment filter). */
environments: string[];
containsSecrets: boolean;
}
```
### feature.saferollout.rollback
Triggered when a safe rollout has a failing guardrail and should be reverted.
```typescript theme={null}
{
event: "feature.saferollout.rollback";
object: "feature";
api_version: string;
created: number;
data: {
object: {
featureId: string;
safeRolloutId: string;
environment: string;
};
};
user: {
type: "dashboard";
id: string;
email: string;
name: string;
} | {
type: "api_key";
apiKey: string;
id?: string | undefined;
name?: string | undefined;
email?: string | undefined;
} | {
type: "system";
subtype?: string | undefined;
id?: string | undefined;
} | null;
tags: string[];
/** The environments affected by the change described by this event. For live-state events (e.g. `feature.updated`) these are the environments whose effective configuration actually changed; for draft lifecycle events (`*.revision.*`) they are the environments the proposed changes would affect. Webhook environment filters match against this field. An empty array means the event has no environment-scoped impact (it will only be delivered to subscriptions without an environment filter). */
environments: string[];
containsSecrets: boolean;
}
```
### feature.saferollout.unhealthy
Triggered when a safe rollout is failing a health check and may not be working as expected.
```typescript theme={null}
{
event: "feature.saferollout.unhealthy";
object: "feature";
api_version: string;
created: number;
data: {
object: {
featureId: string;
safeRolloutId: string;
environment: string;
unhealthyReason: ("srm" | "multipleExposures")[];
};
};
user: {
type: "dashboard";
id: string;
email: string;
name: string;
} | {
type: "api_key";
apiKey: string;
id?: string | undefined;
name?: string | undefined;
email?: string | undefined;
} | {
type: "system";
subtype?: string | undefined;
id?: string | undefined;
} | null;
tags: string[];
/** The environments affected by the change described by this event. For live-state events (e.g. `feature.updated`) these are the environments whose effective configuration actually changed; for draft lifecycle events (`*.revision.*`) they are the environments the proposed changes would affect. Webhook environment filters match against this field. An empty array means the event has no environment-scoped impact (it will only be delivered to subscriptions without an environment filter). */
environments: string[];
containsSecrets: boolean;
}
```
### feature.rampSchedule.created
Triggered when a ramp schedule is created for a feature
```typescript theme={null}
{
event: "feature.rampSchedule.created";
object: "feature";
api_version: string;
created: number;
data: {
object: {
rampScheduleId: string;
rampName: string;
orgId: string;
entityType: string;
entityId: string;
};
};
user: {
type: "dashboard";
id: string;
email: string;
name: string;
} | {
type: "api_key";
apiKey: string;
id?: string | undefined;
name?: string | undefined;
email?: string | undefined;
} | {
type: "system";
subtype?: string | undefined;
id?: string | undefined;
} | null;
tags: string[];
/** The environments affected by the change described by this event. For live-state events (e.g. `feature.updated`) these are the environments whose effective configuration actually changed; for draft lifecycle events (`*.revision.*`) they are the environments the proposed changes would affect. Webhook environment filters match against this field. An empty array means the event has no environment-scoped impact (it will only be delivered to subscriptions without an environment filter). */
environments: string[];
containsSecrets: boolean;
}
```
### feature.rampSchedule.deleted
Triggered when a ramp schedule is deleted from a feature
```typescript theme={null}
{
event: "feature.rampSchedule.deleted";
object: "feature";
api_version: string;
created: number;
data: {
object: {
rampScheduleId: string;
rampName: string;
orgId: string;
};
};
user: {
type: "dashboard";
id: string;
email: string;
name: string;
} | {
type: "api_key";
apiKey: string;
id?: string | undefined;
name?: string | undefined;
email?: string | undefined;
} | {
type: "system";
subtype?: string | undefined;
id?: string | undefined;
} | null;
tags: string[];
/** The environments affected by the change described by this event. For live-state events (e.g. `feature.updated`) these are the environments whose effective configuration actually changed; for draft lifecycle events (`*.revision.*`) they are the environments the proposed changes would affect. Webhook environment filters match against this field. An empty array means the event has no environment-scoped impact (it will only be delivered to subscriptions without an environment filter). */
environments: string[];
containsSecrets: boolean;
}
```
### feature.rampSchedule.actions.started
Triggered when a feature ramp schedule starts
```typescript theme={null}
{
event: "feature.rampSchedule.actions.started";
object: "feature";
api_version: string;
created: number;
data: {
object: {
rampScheduleId: string;
rampName: string;
orgId: string;
currentStepIndex: number;
status: string;
};
};
user: {
type: "dashboard";
id: string;
email: string;
name: string;
} | {
type: "api_key";
apiKey: string;
id?: string | undefined;
name?: string | undefined;
email?: string | undefined;
} | {
type: "system";
subtype?: string | undefined;
id?: string | undefined;
} | null;
tags: string[];
/** The environments affected by the change described by this event. For live-state events (e.g. `feature.updated`) these are the environments whose effective configuration actually changed; for draft lifecycle events (`*.revision.*`) they are the environments the proposed changes would affect. Webhook environment filters match against this field. An empty array means the event has no environment-scoped impact (it will only be delivered to subscriptions without an environment filter). */
environments: string[];
containsSecrets: boolean;
}
```
### feature.rampSchedule.actions.completed
Triggered when a feature ramp schedule completes all steps
```typescript theme={null}
{
event: "feature.rampSchedule.actions.completed";
object: "feature";
api_version: string;
created: number;
data: {
object: {
rampScheduleId: string;
rampName: string;
orgId: string;
currentStepIndex: number;
status: string;
};
};
user: {
type: "dashboard";
id: string;
email: string;
name: string;
} | {
type: "api_key";
apiKey: string;
id?: string | undefined;
name?: string | undefined;
email?: string | undefined;
} | {
type: "system";
subtype?: string | undefined;
id?: string | undefined;
} | null;
tags: string[];
/** The environments affected by the change described by this event. For live-state events (e.g. `feature.updated`) these are the environments whose effective configuration actually changed; for draft lifecycle events (`*.revision.*`) they are the environments the proposed changes would affect. Webhook environment filters match against this field. An empty array means the event has no environment-scoped impact (it will only be delivered to subscriptions without an environment filter). */
environments: string[];
containsSecrets: boolean;
}
```
### feature.rampSchedule.actions.rolledBack
Triggered when a feature ramp schedule is rolled back or reset to start
```typescript theme={null}
{
event: "feature.rampSchedule.actions.rolledBack";
object: "feature";
api_version: string;
created: number;
data: {
object: {
rampScheduleId: string;
rampName: string;
orgId: string;
currentStepIndex: number;
status: string;
targetStepIndex: number;
};
};
user: {
type: "dashboard";
id: string;
email: string;
name: string;
} | {
type: "api_key";
apiKey: string;
id?: string | undefined;
name?: string | undefined;
email?: string | undefined;
} | {
type: "system";
subtype?: string | undefined;
id?: string | undefined;
} | null;
tags: string[];
/** The environments affected by the change described by this event. For live-state events (e.g. `feature.updated`) these are the environments whose effective configuration actually changed; for draft lifecycle events (`*.revision.*`) they are the environments the proposed changes would affect. Webhook environment filters match against this field. An empty array means the event has no environment-scoped impact (it will only be delivered to subscriptions without an environment filter). */
environments: string[];
containsSecrets: boolean;
}
```
### feature.rampSchedule.actions.jumped
Triggered when a feature ramp schedule is jumped to a specific step
```typescript theme={null}
{
event: "feature.rampSchedule.actions.jumped";
object: "feature";
api_version: string;
created: number;
data: {
object: {
rampScheduleId: string;
rampName: string;
orgId: string;
currentStepIndex: number;
status: string;
targetStepIndex: number;
};
};
user: {
type: "dashboard";
id: string;
email: string;
name: string;
} | {
type: "api_key";
apiKey: string;
id?: string | undefined;
name?: string | undefined;
email?: string | undefined;
} | {
type: "system";
subtype?: string | undefined;
id?: string | undefined;
} | null;
tags: string[];
/** The environments affected by the change described by this event. For live-state events (e.g. `feature.updated`) these are the environments whose effective configuration actually changed; for draft lifecycle events (`*.revision.*`) they are the environments the proposed changes would affect. Webhook environment filters match against this field. An empty array means the event has no environment-scoped impact (it will only be delivered to subscriptions without an environment filter). */
environments: string[];
containsSecrets: boolean;
}
```
### feature.rampSchedule.actions.step.advanced
Triggered when a feature ramp schedule advances to the next step
```typescript theme={null}
{
event: "feature.rampSchedule.actions.step.advanced";
object: "feature";
api_version: string;
created: number;
data: {
object: {
rampScheduleId: string;
rampName: string;
orgId: string;
currentStepIndex: number;
status: string;
};
};
user: {
type: "dashboard";
id: string;
email: string;
name: string;
} | {
type: "api_key";
apiKey: string;
id?: string | undefined;
name?: string | undefined;
email?: string | undefined;
} | {
type: "system";
subtype?: string | undefined;
id?: string | undefined;
} | null;
tags: string[];
/** The environments affected by the change described by this event. For live-state events (e.g. `feature.updated`) these are the environments whose effective configuration actually changed; for draft lifecycle events (`*.revision.*`) they are the environments the proposed changes would affect. Webhook environment filters match against this field. An empty array means the event has no environment-scoped impact (it will only be delivered to subscriptions without an environment filter). */
environments: string[];
containsSecrets: boolean;
}
```
### feature.rampSchedule.actions.step.approvalRequired
Triggered when a feature ramp step is waiting for approval
```typescript theme={null}
{
event: "feature.rampSchedule.actions.step.approvalRequired";
object: "feature";
api_version: string;
created: number;
data: {
object: {
rampScheduleId: string;
rampName: string;
orgId: string;
currentStepIndex: number;
status: string;
approvalNotes?: (string | null) | undefined;
};
};
user: {
type: "dashboard";
id: string;
email: string;
name: string;
} | {
type: "api_key";
apiKey: string;
id?: string | undefined;
name?: string | undefined;
email?: string | undefined;
} | {
type: "system";
subtype?: string | undefined;
id?: string | undefined;
} | null;
tags: string[];
/** The environments affected by the change described by this event. For live-state events (e.g. `feature.updated`) these are the environments whose effective configuration actually changed; for draft lifecycle events (`*.revision.*`) they are the environments the proposed changes would affect. Webhook environment filters match against this field. An empty array means the event has no environment-scoped impact (it will only be delivered to subscriptions without an environment filter). */
environments: string[];
containsSecrets: boolean;
}
```
### feature.rampSchedule.actions.awaitingStartApproval
Triggered when a feature ramp schedule is published but held at the start, awaiting an explicit start approval
```typescript theme={null}
{
event: "feature.rampSchedule.actions.awaitingStartApproval";
object: "feature";
api_version: string;
created: number;
data: {
object: {
rampScheduleId: string;
rampName: string;
orgId: string;
currentStepIndex: number;
status: string;
};
};
user: {
type: "dashboard";
id: string;
email: string;
name: string;
} | {
type: "api_key";
apiKey: string;
id?: string | undefined;
name?: string | undefined;
email?: string | undefined;
} | {
type: "system";
subtype?: string | undefined;
id?: string | undefined;
} | null;
tags: string[];
/** The environments affected by the change described by this event. For live-state events (e.g. `feature.updated`) these are the environments whose effective configuration actually changed; for draft lifecycle events (`*.revision.*`) they are the environments the proposed changes would affect. Webhook environment filters match against this field. An empty array means the event has no environment-scoped impact (it will only be delivered to subscriptions without an environment filter). */
environments: string[];
containsSecrets: boolean;
}
```
### feature.rampSchedule.actions.startApproved
Triggered when a held ramp schedule's start is approved by a user
```typescript theme={null}
{
event: "feature.rampSchedule.actions.startApproved";
object: "feature";
api_version: string;
created: number;
data: {
object: {
rampScheduleId: string;
rampName: string;
orgId: string;
currentStepIndex: number;
status: string;
};
};
user: {
type: "dashboard";
id: string;
email: string;
name: string;
} | {
type: "api_key";
apiKey: string;
id?: string | undefined;
name?: string | undefined;
email?: string | undefined;
} | {
type: "system";
subtype?: string | undefined;
id?: string | undefined;
} | null;
tags: string[];
/** The environments affected by the change described by this event. For live-state events (e.g. `feature.updated`) these are the environments whose effective configuration actually changed; for draft lifecycle events (`*.revision.*`) they are the environments the proposed changes would affect. Webhook environment filters match against this field. An empty array means the event has no environment-scoped impact (it will only be delivered to subscriptions without an environment filter). */
environments: string[];
containsSecrets: boolean;
}
```
### feature.revision.created
Triggered when a new draft revision is created for a feature
```typescript theme={null}
{
event: "feature.revision.created";
object: "feature";
api_version: string;
created: number;
data: {
object: {
id?: string | undefined;
/** The feature this revision belongs to */
featureId: string;
baseVersion: number;
version: number;
comment: string;
date: string;
status: string;
createdBy?: string | undefined;
publishedBy?: string | undefined;
/** The default value at the time this revision was created */
defaultValue?: string | undefined;
rules: Record;
definitions?: Record | undefined;
environmentsEnabled?: Record | undefined;
envPrerequisites?: Record | undefined;
prerequisites?: {
/** Feature ID */
id: string;
condition: string;
}[] | undefined;
metadata?: {} | undefined;
};
};
user: {
type: "dashboard";
id: string;
email: string;
name: string;
} | {
type: "api_key";
apiKey: string;
id?: string | undefined;
name?: string | undefined;
email?: string | undefined;
} | {
type: "system";
subtype?: string | undefined;
id?: string | undefined;
} | null;
tags: string[];
/** The environments affected by the change described by this event. For live-state events (e.g. `feature.updated`) these are the environments whose effective configuration actually changed; for draft lifecycle events (`*.revision.*`) they are the environments the proposed changes would affect. Webhook environment filters match against this field. An empty array means the event has no environment-scoped impact (it will only be delivered to subscriptions without an environment filter). */
environments: string[];
containsSecrets: boolean;
}
```
### feature.revision.updated
Triggered when a draft revision is modified (rules, default value, toggles, prerequisites, metadata, etc.). The `change` field indicates the specific kind of mutation.
```typescript theme={null}
{
event: "feature.revision.updated";
object: "feature";
api_version: string;
created: number;
data: {
object: {
id?: string | undefined;
/** The feature this revision belongs to */
featureId: string;
baseVersion: number;
version: number;
comment: string;
date: string;
status: string;
createdBy?: string | undefined;
publishedBy?: string | undefined;
/** The default value at the time this revision was created */
defaultValue?: string | undefined;
rules: Record;
definitions?: Record | undefined;
environmentsEnabled?: Record | undefined;
envPrerequisites?: Record | undefined;
prerequisites?: {
/** Feature ID */
id: string;
condition: string;
}[] | undefined;
metadata?: {} | undefined;
change: "rule.add" | "rule.update" | "rule.delete" | "rule.reorder" | "rule.rampSchedule.set" | "rule.rampSchedule.remove" | "toggle" | "defaultValue" | "prerequisites" | "holdout" | "archive" | "metadata";
environments?: string[] | undefined;
};
};
user: {
type: "dashboard";
id: string;
email: string;
name: string;
} | {
type: "api_key";
apiKey: string;
id?: string | undefined;
name?: string | undefined;
email?: string | undefined;
} | {
type: "system";
subtype?: string | undefined;
id?: string | undefined;
} | null;
tags: string[];
/** The environments affected by the change described by this event. For live-state events (e.g. `feature.updated`) these are the environments whose effective configuration actually changed; for draft lifecycle events (`*.revision.*`) they are the environments the proposed changes would affect. Webhook environment filters match against this field. An empty array means the event has no environment-scoped impact (it will only be delivered to subscriptions without an environment filter). */
environments: string[];
containsSecrets: boolean;
}
```
### feature.revision.reviewRequested
Triggered when a draft revision is submitted for review
```typescript theme={null}
{
event: "feature.revision.reviewRequested";
object: "feature";
api_version: string;
created: number;
data: {
object: {
id?: string | undefined;
/** The feature this revision belongs to */
featureId: string;
baseVersion: number;
version: number;
comment: string;
date: string;
status: string;
createdBy?: string | undefined;
publishedBy?: string | undefined;
/** The default value at the time this revision was created */
defaultValue?: string | undefined;
rules: Record;
definitions?: Record | undefined;
environmentsEnabled?: Record | undefined;
envPrerequisites?: Record | undefined;
prerequisites?: {
/** Feature ID */
id: string;
condition: string;
}[] | undefined;
metadata?: {} | undefined;
reviewComment: string | null;
};
};
user: {
type: "dashboard";
id: string;
email: string;
name: string;
} | {
type: "api_key";
apiKey: string;
id?: string | undefined;
name?: string | undefined;
email?: string | undefined;
} | {
type: "system";
subtype?: string | undefined;
id?: string | undefined;
} | null;
tags: string[];
/** The environments affected by the change described by this event. For live-state events (e.g. `feature.updated`) these are the environments whose effective configuration actually changed; for draft lifecycle events (`*.revision.*`) they are the environments the proposed changes would affect. Webhook environment filters match against this field. An empty array means the event has no environment-scoped impact (it will only be delivered to subscriptions without an environment filter). */
environments: string[];
containsSecrets: boolean;
}
```
### feature.revision.approved
Triggered when a draft revision is approved by a reviewer
```typescript theme={null}
{
event: "feature.revision.approved";
object: "feature";
api_version: string;
created: number;
data: {
object: {
id?: string | undefined;
/** The feature this revision belongs to */
featureId: string;
baseVersion: number;
version: number;
comment: string;
date: string;
status: string;
createdBy?: string | undefined;
publishedBy?: string | undefined;
/** The default value at the time this revision was created */
defaultValue?: string | undefined;
rules: Record;
definitions?: Record | undefined;
environmentsEnabled?: Record | undefined;
envPrerequisites?: Record | undefined;
prerequisites?: {
/** Feature ID */
id: string;
condition: string;
}[] | undefined;
metadata?: {} | undefined;
reviewer: {
id?: string | undefined;
name?: string | undefined;
email?: string | undefined;
};
reviewComment: string | null;
};
};
user: {
type: "dashboard";
id: string;
email: string;
name: string;
} | {
type: "api_key";
apiKey: string;
id?: string | undefined;
name?: string | undefined;
email?: string | undefined;
} | {
type: "system";
subtype?: string | undefined;
id?: string | undefined;
} | null;
tags: string[];
/** The environments affected by the change described by this event. For live-state events (e.g. `feature.updated`) these are the environments whose effective configuration actually changed; for draft lifecycle events (`*.revision.*`) they are the environments the proposed changes would affect. Webhook environment filters match against this field. An empty array means the event has no environment-scoped impact (it will only be delivered to subscriptions without an environment filter). */
environments: string[];
containsSecrets: boolean;
}
```
### feature.revision.changesRequested
Triggered when a reviewer requests changes on a draft revision
```typescript theme={null}
{
event: "feature.revision.changesRequested";
object: "feature";
api_version: string;
created: number;
data: {
object: {
id?: string | undefined;
/** The feature this revision belongs to */
featureId: string;
baseVersion: number;
version: number;
comment: string;
date: string;
status: string;
createdBy?: string | undefined;
publishedBy?: string | undefined;
/** The default value at the time this revision was created */
defaultValue?: string | undefined;
rules: Record;
definitions?: Record | undefined;
environmentsEnabled?: Record | undefined;
envPrerequisites?: Record | undefined;
prerequisites?: {
/** Feature ID */
id: string;
condition: string;
}[] | undefined;
metadata?: {} | undefined;
reviewer: {
id?: string | undefined;
name?: string | undefined;
email?: string | undefined;
};
reviewComment: string | null;
};
};
user: {
type: "dashboard";
id: string;
email: string;
name: string;
} | {
type: "api_key";
apiKey: string;
id?: string | undefined;
name?: string | undefined;
email?: string | undefined;
} | {
type: "system";
subtype?: string | undefined;
id?: string | undefined;
} | null;
tags: string[];
/** The environments affected by the change described by this event. For live-state events (e.g. `feature.updated`) these are the environments whose effective configuration actually changed; for draft lifecycle events (`*.revision.*`) they are the environments the proposed changes would affect. Webhook environment filters match against this field. An empty array means the event has no environment-scoped impact (it will only be delivered to subscriptions without an environment filter). */
environments: string[];
containsSecrets: boolean;
}
```
### feature.revision.commented
Triggered when a comment is added to a draft revision
```typescript theme={null}
{
event: "feature.revision.commented";
object: "feature";
api_version: string;
created: number;
data: {
object: {
id?: string | undefined;
/** The feature this revision belongs to */
featureId: string;
baseVersion: number;
version: number;
comment: string;
date: string;
status: string;
createdBy?: string | undefined;
publishedBy?: string | undefined;
/** The default value at the time this revision was created */
defaultValue?: string | undefined;
rules: Record;
definitions?: Record | undefined;
environmentsEnabled?: Record | undefined;
envPrerequisites?: Record | undefined;
prerequisites?: {
/** Feature ID */
id: string;
condition: string;
}[] | undefined;
metadata?: {} | undefined;
reviewer: {
id?: string | undefined;
name?: string | undefined;
email?: string | undefined;
};
reviewComment: string;
};
};
user: {
type: "dashboard";
id: string;
email: string;
name: string;
} | {
type: "api_key";
apiKey: string;
id?: string | undefined;
name?: string | undefined;
email?: string | undefined;
} | {
type: "system";
subtype?: string | undefined;
id?: string | undefined;
} | null;
tags: string[];
/** The environments affected by the change described by this event. For live-state events (e.g. `feature.updated`) these are the environments whose effective configuration actually changed; for draft lifecycle events (`*.revision.*`) they are the environments the proposed changes would affect. Webhook environment filters match against this field. An empty array means the event has no environment-scoped impact (it will only be delivered to subscriptions without an environment filter). */
environments: string[];
containsSecrets: boolean;
}
```
### feature.revision.discarded
Triggered when a draft revision is discarded
```typescript theme={null}
{
event: "feature.revision.discarded";
object: "feature";
api_version: string;
created: number;
data: {
object: {
id?: string | undefined;
/** The feature this revision belongs to */
featureId: string;
baseVersion: number;
version: number;
comment: string;
date: string;
status: string;
createdBy?: string | undefined;
publishedBy?: string | undefined;
/** The default value at the time this revision was created */
defaultValue?: string | undefined;
rules: Record;
definitions?: Record | undefined;
environmentsEnabled?: Record | undefined;
envPrerequisites?: Record | undefined;
prerequisites?: {
/** Feature ID */
id: string;
condition: string;
}[] | undefined;
metadata?: {} | undefined;
};
};
user: {
type: "dashboard";
id: string;
email: string;
name: string;
} | {
type: "api_key";
apiKey: string;
id?: string | undefined;
name?: string | undefined;
email?: string | undefined;
} | {
type: "system";
subtype?: string | undefined;
id?: string | undefined;
} | null;
tags: string[];
/** The environments affected by the change described by this event. For live-state events (e.g. `feature.updated`) these are the environments whose effective configuration actually changed; for draft lifecycle events (`*.revision.*`) they are the environments the proposed changes would affect. Webhook environment filters match against this field. An empty array means the event has no environment-scoped impact (it will only be delivered to subscriptions without an environment filter). */
environments: string[];
containsSecrets: boolean;
}
```
### feature.revision.reopened
Triggered when a discarded draft revision is reopened as a draft
```typescript theme={null}
{
event: "feature.revision.reopened";
object: "feature";
api_version: string;
created: number;
data: {
object: {
id?: string | undefined;
/** The feature this revision belongs to */
featureId: string;
baseVersion: number;
version: number;
comment: string;
date: string;
status: string;
createdBy?: string | undefined;
publishedBy?: string | undefined;
/** The default value at the time this revision was created */
defaultValue?: string | undefined;
rules: Record;
definitions?: Record | undefined;
environmentsEnabled?: Record | undefined;
envPrerequisites?: Record | undefined;
prerequisites?: {
/** Feature ID */
id: string;
condition: string;
}[] | undefined;
metadata?: {} | undefined;
};
};
user: {
type: "dashboard";
id: string;
email: string;
name: string;
} | {
type: "api_key";
apiKey: string;
id?: string | undefined;
name?: string | undefined;
email?: string | undefined;
} | {
type: "system";
subtype?: string | undefined;
id?: string | undefined;
} | null;
tags: string[];
/** The environments affected by the change described by this event. For live-state events (e.g. `feature.updated`) these are the environments whose effective configuration actually changed; for draft lifecycle events (`*.revision.*`) they are the environments the proposed changes would affect. Webhook environment filters match against this field. An empty array means the event has no environment-scoped impact (it will only be delivered to subscriptions without an environment filter). */
environments: string[];
containsSecrets: boolean;
}
```
### feature.revision.rebased
Triggered when a draft revision is rebased onto the latest published version
```typescript theme={null}
{
event: "feature.revision.rebased";
object: "feature";
api_version: string;
created: number;
data: {
object: {
id?: string | undefined;
/** The feature this revision belongs to */
featureId: string;
baseVersion: number;
version: number;
comment: string;
date: string;
status: string;
createdBy?: string | undefined;
publishedBy?: string | undefined;
/** The default value at the time this revision was created */
defaultValue?: string | undefined;
rules: Record;
definitions?: Record | undefined;
environmentsEnabled?: Record | undefined;
envPrerequisites?: Record | undefined;
prerequisites?: {
/** Feature ID */
id: string;
condition: string;
}[] | undefined;
metadata?: {} | undefined;
};
};
user: {
type: "dashboard";
id: string;
email: string;
name: string;
} | {
type: "api_key";
apiKey: string;
id?: string | undefined;
name?: string | undefined;
email?: string | undefined;
} | {
type: "system";
subtype?: string | undefined;
id?: string | undefined;
} | null;
tags: string[];
/** The environments affected by the change described by this event. For live-state events (e.g. `feature.updated`) these are the environments whose effective configuration actually changed; for draft lifecycle events (`*.revision.*`) they are the environments the proposed changes would affect. Webhook environment filters match against this field. An empty array means the event has no environment-scoped impact (it will only be delivered to subscriptions without an environment filter). */
environments: string[];
containsSecrets: boolean;
}
```
### feature.revision.published
Triggered when a draft revision is published. Overlaps with `feature.updated` but provides revision-specific context (base version, comment, author).
```typescript theme={null}
{
event: "feature.revision.published";
object: "feature";
api_version: string;
created: number;
data: {
object: {
id?: string | undefined;
/** The feature this revision belongs to */
featureId: string;
baseVersion: number;
version: number;
comment: string;
date: string;
status: string;
createdBy?: string | undefined;
publishedBy?: string | undefined;
/** The default value at the time this revision was created */
defaultValue?: string | undefined;
rules: Record;
definitions?: Record | undefined;
environmentsEnabled?: Record | undefined;
envPrerequisites?: Record | undefined;
prerequisites?: {
/** Feature ID */
id: string;
condition: string;
}[] | undefined;
metadata?: {} | undefined;
bulkPublishId?: string | undefined;
};
};
user: {
type: "dashboard";
id: string;
email: string;
name: string;
} | {
type: "api_key";
apiKey: string;
id?: string | undefined;
name?: string | undefined;
email?: string | undefined;
} | {
type: "system";
subtype?: string | undefined;
id?: string | undefined;
} | null;
tags: string[];
/** The environments affected by the change described by this event. For live-state events (e.g. `feature.updated`) these are the environments whose effective configuration actually changed; for draft lifecycle events (`*.revision.*`) they are the environments the proposed changes would affect. Webhook environment filters match against this field. An empty array means the event has no environment-scoped impact (it will only be delivered to subscriptions without an environment filter). */
environments: string[];
containsSecrets: boolean;
}
```
### feature.revision.reverted
Triggered when a feature is reverted to a previous published revision
```typescript theme={null}
{
event: "feature.revision.reverted";
object: "feature";
api_version: string;
created: number;
data: {
object: {
id?: string | undefined;
/** The feature this revision belongs to */
featureId: string;
baseVersion: number;
version: number;
comment: string;
date: string;
status: string;
createdBy?: string | undefined;
publishedBy?: string | undefined;
/** The default value at the time this revision was created */
defaultValue?: string | undefined;
rules: Record;
definitions?: Record | undefined;
environmentsEnabled?: Record | undefined;
envPrerequisites?: Record | undefined;
prerequisites?: {
/** Feature ID */
id: string;
condition: string;
}[] | undefined;
metadata?: {} | undefined;
revertedToVersion: number;
bulkPublishId?: string | undefined;
};
};
user: {
type: "dashboard";
id: string;
email: string;
name: string;
} | {
type: "api_key";
apiKey: string;
id?: string | undefined;
name?: string | undefined;
email?: string | undefined;
} | {
type: "system";
subtype?: string | undefined;
id?: string | undefined;
} | null;
tags: string[];
/** The environments affected by the change described by this event. For live-state events (e.g. `feature.updated`) these are the environments whose effective configuration actually changed; for draft lifecycle events (`*.revision.*`) they are the environments the proposed changes would affect. Webhook environment filters match against this field. An empty array means the event has no environment-scoped impact (it will only be delivered to subscriptions without an environment filter). */
environments: string[];
containsSecrets: boolean;
}
```
### experiment.created
Triggered when an experiment is created
```typescript theme={null}
{
event: "experiment.created";
object: "experiment";
api_version: string;
created: number;
data: {
object: {
id: string;
trackingKey: string;
dateCreated: string;
dateUpdated: string;
name: string;
type: "standard" | "multi-armed-bandit" | "holdout";
project: string;
hypothesis: string;
description: string;
tags: string[];
/** The userId of the owner (or raw owner name/email for legacy records) */
owner: string;
ownerEmail?: string | undefined;
archived: boolean;
status: string;
autoRefresh: boolean;
hashAttribute: string;
fallbackAttribute?: string | undefined;
hashVersion: 1 | 2;
disableStickyBucketing?: boolean | undefined;
bucketVersion?: number | undefined;
minBucketVersion?: number | undefined;
variations: {
variationId: string;
key: string;
name: string;
description: string;
screenshots: string[];
}[];
phases: {
name: string;
dateStarted: string;
dateEnded: string;
reasonForStopping: string;
seed: string;
coverage: number;
trafficSplit: {
variationId: string;
weight: number;
}[];
namespace?: {
namespaceId: string;
enabled?: boolean | undefined;
range?: number[] | undefined;
ranges?: [
number,
number
][] | undefined;
} | undefined;
targetingCondition: string;
prerequisites?: {
id: string;
condition: string;
}[] | undefined;
savedGroupTargeting?: {
matchType: "all" | "any" | "none";
savedGroups: string[];
}[] | undefined;
}[];
settings: {
datasourceId: string;
assignmentQueryId: string;
experimentId: string;
segmentId: string;
queryFilter: string;
inProgressConversions: "include" | "exclude";
/** Setting attribution model to `"experimentDuration"` is the same as selecting "Ignore Conversion Windows" for the Conversion Window Override. Setting it to `"lookbackOverride"` requires a `lookbackOverride` object to be provided. */
attributionModel: "firstExposure" | "experimentDuration" | "lookbackOverride";
/** Controls the lookback override for the experiment. For type "window", value must be a non-negative number and valueUnit is required. */
lookbackOverride?: {
type: "date" | "window";
/** For "window" type - non-negative numeric value (e.g. 7 for 7 days). For "date" type a date string. */
value: number | string;
/** Used when type is "window". Defaults to "days". */
valueUnit?: ("minutes" | "hours" | "days" | "weeks") | undefined;
} | undefined;
statsEngine: "bayesian" | "frequentist";
regressionAdjustmentEnabled?: boolean | undefined;
sequentialTestingEnabled?: boolean | undefined;
sequentialTestingTuningParameter?: number | undefined;
/** When null, the organization default is used. */
postStratificationEnabled?: (boolean | null) | undefined;
/** Controls the decision framework and metric overrides for the experiment. Replaces the entire stored object on update (does not patch individual fields). */
decisionFrameworkSettings?: {
decisionCriteriaId?: string | undefined;
decisionFrameworkMetricOverrides?: {
/** ID of the metric to override settings for. */
id: string;
/** The target relative MDE to use for the metric, expressed as proportions (e.g. use 0.1 for 10%). Must be greater than 0. */
targetMDE?: number | undefined;
}[] | undefined;
} | undefined;
/** Per-metric analysis overrides; also reflected in goals/secondaryMetrics/guardrails overrides when applicable. On create/update, this replaces the entire stored array (it does not patch individual entries). */
metricOverrides?: {
/** ID of the metric to override settings for. */
id: string;
windowType?: ("conversion" | "lookback" | "") | undefined;
windowHours?: number | undefined;
delayHours?: number | undefined;
/** Must be true for the override to take effect. If true, the other proper prior settings in this object will be used if present. */
properPriorOverride?: boolean | undefined;
properPriorEnabled?: boolean | undefined;
properPriorMean?: number | undefined;
properPriorStdDev?: number | undefined;
/** Must be true for the override to take effect. If true, the other regression adjustment settings in this object will be used if present. */
regressionAdjustmentOverride?: boolean | undefined;
regressionAdjustmentEnabled?: boolean | undefined;
regressionAdjustmentDays?: number | undefined;
}[] | undefined;
goals: {
metricId: string;
overrides: {
delayHours?: number | undefined;
windowHours?: number | undefined;
window?: ("conversion" | "lookback" | "") | undefined;
winRiskThreshold?: number | undefined;
loseRiskThreshold?: number | undefined;
properPriorOverride?: boolean | undefined;
properPriorEnabled?: boolean | undefined;
properPriorMean?: number | undefined;
properPriorStdDev?: number | undefined;
regressionAdjustmentOverride?: boolean | undefined;
regressionAdjustmentEnabled?: boolean | undefined;
regressionAdjustmentDays?: number | undefined;
};
}[];
secondaryMetrics: {
metricId: string;
overrides: {
delayHours?: number | undefined;
windowHours?: number | undefined;
window?: ("conversion" | "lookback" | "") | undefined;
winRiskThreshold?: number | undefined;
loseRiskThreshold?: number | undefined;
properPriorOverride?: boolean | undefined;
properPriorEnabled?: boolean | undefined;
properPriorMean?: number | undefined;
properPriorStdDev?: number | undefined;
regressionAdjustmentOverride?: boolean | undefined;
regressionAdjustmentEnabled?: boolean | undefined;
regressionAdjustmentDays?: number | undefined;
};
}[];
guardrails: {
metricId: string;
overrides: {
delayHours?: number | undefined;
windowHours?: number | undefined;
window?: ("conversion" | "lookback" | "") | undefined;
winRiskThreshold?: number | undefined;
loseRiskThreshold?: number | undefined;
properPriorOverride?: boolean | undefined;
properPriorEnabled?: boolean | undefined;
properPriorMean?: number | undefined;
properPriorStdDev?: number | undefined;
regressionAdjustmentOverride?: boolean | undefined;
regressionAdjustmentEnabled?: boolean | undefined;
regressionAdjustmentDays?: number | undefined;
};
}[];
activationMetric?: {
metricId: string;
overrides: {
delayHours?: number | undefined;
windowHours?: number | undefined;
window?: ("conversion" | "lookback" | "") | undefined;
winRiskThreshold?: number | undefined;
loseRiskThreshold?: number | undefined;
properPriorOverride?: boolean | undefined;
properPriorEnabled?: boolean | undefined;
properPriorMean?: number | undefined;
properPriorStdDev?: number | undefined;
regressionAdjustmentOverride?: boolean | undefined;
regressionAdjustmentEnabled?: boolean | undefined;
regressionAdjustmentDays?: number | undefined;
};
} | undefined;
};
resultSummary?: {
status: string;
winner: string;
conclusions: string;
releasedVariationId: string;
excludeFromPayload: boolean;
} | undefined;
shareLevel?: ("public" | "organization") | undefined;
publicUrl?: string | undefined;
banditScheduleValue?: number | undefined;
banditScheduleUnit?: ("days" | "hours") | undefined;
banditBurnInValue?: number | undefined;
banditBurnInUnit?: ("days" | "hours") | undefined;
banditConversionWindowValue?: number | undefined;
banditConversionWindowUnit?: ("days" | "hours") | undefined;
linkedFeatures?: string[] | undefined;
hasVisualChangesets?: boolean | undefined;
hasURLRedirects?: boolean | undefined;
customFields?: Record | undefined;
/** Custom slices that apply to ALL applicable metrics in the experiment */
customMetricSlices?: {
slices: {
column: string;
levels: string[];
}[];
}[] | undefined;
precomputedUnitDimensionIds?: string[] | undefined;
/** ID of the default dashboard for this experiment. */
defaultDashboardId?: string | undefined;
templateId?: string | undefined;
statusUpdateSchedule?: ({
startAt?: string | undefined;
stopAt?: string | undefined;
/** Relative end offset. Deferred: resolved to a concrete `stopAt` at the experiment's actual start (or off `dateStarted` when already running). */
stopAfter?: {
value: number;
unit: "hours" | "days";
} | undefined;
/** What happens at the scheduled end date. `notify` keeps the experiment running and just notifies (soft). `auto-ship` (requires the Decision Framework) ships the winning variation and stops; multi-winner ties break on `tiebreakerMetricId` (higher lift); with no clear winner, `fallback` either keeps running (`notify`) or ships `fallbackVariationId`. `force-ship` stops and rolls out `fallbackVariationId`. `stop` is a hard deadline that stops with no rollout. For `force-ship` and `stop`, the Decision Framework verdict (won/lost/inconclusive) is recorded as metadata when available. */
scheduledStopPlan?: {
mode: "notify" | "auto-ship" | "force-ship" | "stop";
tiebreakerMetricId?: string | undefined;
fallback: "notify" | "force-ship";
fallbackVariationId?: string | undefined;
} | undefined;
} | null) | undefined;
nextScheduledStatusUpdate?: ({
type: "start" | "stop";
date: string;
} | null) | undefined;
};
};
user: {
type: "dashboard";
id: string;
email: string;
name: string;
} | {
type: "api_key";
apiKey: string;
id?: string | undefined;
name?: string | undefined;
email?: string | undefined;
} | {
type: "system";
subtype?: string | undefined;
id?: string | undefined;
} | null;
tags: string[];
/** The environments affected by the change described by this event. For live-state events (e.g. `feature.updated`) these are the environments whose effective configuration actually changed; for draft lifecycle events (`*.revision.*`) they are the environments the proposed changes would affect. Webhook environment filters match against this field. An empty array means the event has no environment-scoped impact (it will only be delivered to subscriptions without an environment filter). */
environments: string[];
containsSecrets: boolean;
}
```
### experiment.updated
Triggered when an experiment is updated
```typescript theme={null}
{
event: "experiment.updated";
object: "experiment";
api_version: string;
created: number;
data: {
object: {
id: string;
trackingKey: string;
dateCreated: string;
dateUpdated: string;
name: string;
type: "standard" | "multi-armed-bandit" | "holdout";
project: string;
hypothesis: string;
description: string;
tags: string[];
/** The userId of the owner (or raw owner name/email for legacy records) */
owner: string;
ownerEmail?: string | undefined;
archived: boolean;
status: string;
autoRefresh: boolean;
hashAttribute: string;
fallbackAttribute?: string | undefined;
hashVersion: 1 | 2;
disableStickyBucketing?: boolean | undefined;
bucketVersion?: number | undefined;
minBucketVersion?: number | undefined;
variations: {
variationId: string;
key: string;
name: string;
description: string;
screenshots: string[];
}[];
phases: {
name: string;
dateStarted: string;
dateEnded: string;
reasonForStopping: string;
seed: string;
coverage: number;
trafficSplit: {
variationId: string;
weight: number;
}[];
namespace?: {
namespaceId: string;
enabled?: boolean | undefined;
range?: number[] | undefined;
ranges?: [
number,
number
][] | undefined;
} | undefined;
targetingCondition: string;
prerequisites?: {
id: string;
condition: string;
}[] | undefined;
savedGroupTargeting?: {
matchType: "all" | "any" | "none";
savedGroups: string[];
}[] | undefined;
}[];
settings: {
datasourceId: string;
assignmentQueryId: string;
experimentId: string;
segmentId: string;
queryFilter: string;
inProgressConversions: "include" | "exclude";
/** Setting attribution model to `"experimentDuration"` is the same as selecting "Ignore Conversion Windows" for the Conversion Window Override. Setting it to `"lookbackOverride"` requires a `lookbackOverride` object to be provided. */
attributionModel: "firstExposure" | "experimentDuration" | "lookbackOverride";
/** Controls the lookback override for the experiment. For type "window", value must be a non-negative number and valueUnit is required. */
lookbackOverride?: {
type: "date" | "window";
/** For "window" type - non-negative numeric value (e.g. 7 for 7 days). For "date" type a date string. */
value: number | string;
/** Used when type is "window". Defaults to "days". */
valueUnit?: ("minutes" | "hours" | "days" | "weeks") | undefined;
} | undefined;
statsEngine: "bayesian" | "frequentist";
regressionAdjustmentEnabled?: boolean | undefined;
sequentialTestingEnabled?: boolean | undefined;
sequentialTestingTuningParameter?: number | undefined;
/** When null, the organization default is used. */
postStratificationEnabled?: (boolean | null) | undefined;
/** Controls the decision framework and metric overrides for the experiment. Replaces the entire stored object on update (does not patch individual fields). */
decisionFrameworkSettings?: {
decisionCriteriaId?: string | undefined;
decisionFrameworkMetricOverrides?: {
/** ID of the metric to override settings for. */
id: string;
/** The target relative MDE to use for the metric, expressed as proportions (e.g. use 0.1 for 10%). Must be greater than 0. */
targetMDE?: number | undefined;
}[] | undefined;
} | undefined;
/** Per-metric analysis overrides; also reflected in goals/secondaryMetrics/guardrails overrides when applicable. On create/update, this replaces the entire stored array (it does not patch individual entries). */
metricOverrides?: {
/** ID of the metric to override settings for. */
id: string;
windowType?: ("conversion" | "lookback" | "") | undefined;
windowHours?: number | undefined;
delayHours?: number | undefined;
/** Must be true for the override to take effect. If true, the other proper prior settings in this object will be used if present. */
properPriorOverride?: boolean | undefined;
properPriorEnabled?: boolean | undefined;
properPriorMean?: number | undefined;
properPriorStdDev?: number | undefined;
/** Must be true for the override to take effect. If true, the other regression adjustment settings in this object will be used if present. */
regressionAdjustmentOverride?: boolean | undefined;
regressionAdjustmentEnabled?: boolean | undefined;
regressionAdjustmentDays?: number | undefined;
}[] | undefined;
goals: {
metricId: string;
overrides: {
delayHours?: number | undefined;
windowHours?: number | undefined;
window?: ("conversion" | "lookback" | "") | undefined;
winRiskThreshold?: number | undefined;
loseRiskThreshold?: number | undefined;
properPriorOverride?: boolean | undefined;
properPriorEnabled?: boolean | undefined;
properPriorMean?: number | undefined;
properPriorStdDev?: number | undefined;
regressionAdjustmentOverride?: boolean | undefined;
regressionAdjustmentEnabled?: boolean | undefined;
regressionAdjustmentDays?: number | undefined;
};
}[];
secondaryMetrics: {
metricId: string;
overrides: {
delayHours?: number | undefined;
windowHours?: number | undefined;
window?: ("conversion" | "lookback" | "") | undefined;
winRiskThreshold?: number | undefined;
loseRiskThreshold?: number | undefined;
properPriorOverride?: boolean | undefined;
properPriorEnabled?: boolean | undefined;
properPriorMean?: number | undefined;
properPriorStdDev?: number | undefined;
regressionAdjustmentOverride?: boolean | undefined;
regressionAdjustmentEnabled?: boolean | undefined;
regressionAdjustmentDays?: number | undefined;
};
}[];
guardrails: {
metricId: string;
overrides: {
delayHours?: number | undefined;
windowHours?: number | undefined;
window?: ("conversion" | "lookback" | "") | undefined;
winRiskThreshold?: number | undefined;
loseRiskThreshold?: number | undefined;
properPriorOverride?: boolean | undefined;
properPriorEnabled?: boolean | undefined;
properPriorMean?: number | undefined;
properPriorStdDev?: number | undefined;
regressionAdjustmentOverride?: boolean | undefined;
regressionAdjustmentEnabled?: boolean | undefined;
regressionAdjustmentDays?: number | undefined;
};
}[];
activationMetric?: {
metricId: string;
overrides: {
delayHours?: number | undefined;
windowHours?: number | undefined;
window?: ("conversion" | "lookback" | "") | undefined;
winRiskThreshold?: number | undefined;
loseRiskThreshold?: number | undefined;
properPriorOverride?: boolean | undefined;
properPriorEnabled?: boolean | undefined;
properPriorMean?: number | undefined;
properPriorStdDev?: number | undefined;
regressionAdjustmentOverride?: boolean | undefined;
regressionAdjustmentEnabled?: boolean | undefined;
regressionAdjustmentDays?: number | undefined;
};
} | undefined;
};
resultSummary?: {
status: string;
winner: string;
conclusions: string;
releasedVariationId: string;
excludeFromPayload: boolean;
} | undefined;
shareLevel?: ("public" | "organization") | undefined;
publicUrl?: string | undefined;
banditScheduleValue?: number | undefined;
banditScheduleUnit?: ("days" | "hours") | undefined;
banditBurnInValue?: number | undefined;
banditBurnInUnit?: ("days" | "hours") | undefined;
banditConversionWindowValue?: number | undefined;
banditConversionWindowUnit?: ("days" | "hours") | undefined;
linkedFeatures?: string[] | undefined;
hasVisualChangesets?: boolean | undefined;
hasURLRedirects?: boolean | undefined;
customFields?: Record | undefined;
/** Custom slices that apply to ALL applicable metrics in the experiment */
customMetricSlices?: {
slices: {
column: string;
levels: string[];
}[];
}[] | undefined;
precomputedUnitDimensionIds?: string[] | undefined;
/** ID of the default dashboard for this experiment. */
defaultDashboardId?: string | undefined;
templateId?: string | undefined;
statusUpdateSchedule?: ({
startAt?: string | undefined;
stopAt?: string | undefined;
/** Relative end offset. Deferred: resolved to a concrete `stopAt` at the experiment's actual start (or off `dateStarted` when already running). */
stopAfter?: {
value: number;
unit: "hours" | "days";
} | undefined;
/** What happens at the scheduled end date. `notify` keeps the experiment running and just notifies (soft). `auto-ship` (requires the Decision Framework) ships the winning variation and stops; multi-winner ties break on `tiebreakerMetricId` (higher lift); with no clear winner, `fallback` either keeps running (`notify`) or ships `fallbackVariationId`. `force-ship` stops and rolls out `fallbackVariationId`. `stop` is a hard deadline that stops with no rollout. For `force-ship` and `stop`, the Decision Framework verdict (won/lost/inconclusive) is recorded as metadata when available. */
scheduledStopPlan?: {
mode: "notify" | "auto-ship" | "force-ship" | "stop";
tiebreakerMetricId?: string | undefined;
fallback: "notify" | "force-ship";
fallbackVariationId?: string | undefined;
} | undefined;
} | null) | undefined;
nextScheduledStatusUpdate?: ({
type: "start" | "stop";
date: string;
} | null) | undefined;
};
previous_attributes: {
id?: string | undefined;
trackingKey?: string | undefined;
dateCreated?: string | undefined;
dateUpdated?: string | undefined;
name?: string | undefined;
type?: ("standard" | "multi-armed-bandit" | "holdout") | undefined;
project?: string | undefined;
hypothesis?: string | undefined;
description?: string | undefined;
tags?: string[] | undefined;
/** The userId of the owner (or raw owner name/email for legacy records) */
owner?: string | undefined;
ownerEmail?: string | undefined;
archived?: boolean | undefined;
status?: string | undefined;
autoRefresh?: boolean | undefined;
hashAttribute?: string | undefined;
fallbackAttribute?: string | undefined;
hashVersion?: (1 | 2) | undefined;
disableStickyBucketing?: boolean | undefined;
bucketVersion?: number | undefined;
minBucketVersion?: number | undefined;
variations?: {
variationId: string;
key: string;
name: string;
description: string;
screenshots: string[];
}[] | undefined;
phases?: {
name: string;
dateStarted: string;
dateEnded: string;
reasonForStopping: string;
seed: string;
coverage: number;
trafficSplit: {
variationId: string;
weight: number;
}[];
namespace?: {
namespaceId: string;
enabled?: boolean | undefined;
range?: number[] | undefined;
ranges?: [
number,
number
][] | undefined;
} | undefined;
targetingCondition: string;
prerequisites?: {
id: string;
condition: string;
}[] | undefined;
savedGroupTargeting?: {
matchType: "all" | "any" | "none";
savedGroups: string[];
}[] | undefined;
}[] | undefined;
settings?: {
datasourceId: string;
assignmentQueryId: string;
experimentId: string;
segmentId: string;
queryFilter: string;
inProgressConversions: "include" | "exclude";
/** Setting attribution model to `"experimentDuration"` is the same as selecting "Ignore Conversion Windows" for the Conversion Window Override. Setting it to `"lookbackOverride"` requires a `lookbackOverride` object to be provided. */
attributionModel: "firstExposure" | "experimentDuration" | "lookbackOverride";
/** Controls the lookback override for the experiment. For type "window", value must be a non-negative number and valueUnit is required. */
lookbackOverride?: {
type: "date" | "window";
/** For "window" type - non-negative numeric value (e.g. 7 for 7 days). For "date" type a date string. */
value: number | string;
/** Used when type is "window". Defaults to "days". */
valueUnit?: ("minutes" | "hours" | "days" | "weeks") | undefined;
} | undefined;
statsEngine: "bayesian" | "frequentist";
regressionAdjustmentEnabled?: boolean | undefined;
sequentialTestingEnabled?: boolean | undefined;
sequentialTestingTuningParameter?: number | undefined;
/** When null, the organization default is used. */
postStratificationEnabled?: (boolean | null) | undefined;
/** Controls the decision framework and metric overrides for the experiment. Replaces the entire stored object on update (does not patch individual fields). */
decisionFrameworkSettings?: {
decisionCriteriaId?: string | undefined;
decisionFrameworkMetricOverrides?: {
/** ID of the metric to override settings for. */
id: string;
/** The target relative MDE to use for the metric, expressed as proportions (e.g. use 0.1 for 10%). Must be greater than 0. */
targetMDE?: number | undefined;
}[] | undefined;
} | undefined;
/** Per-metric analysis overrides; also reflected in goals/secondaryMetrics/guardrails overrides when applicable. On create/update, this replaces the entire stored array (it does not patch individual entries). */
metricOverrides?: {
/** ID of the metric to override settings for. */
id: string;
windowType?: ("conversion" | "lookback" | "") | undefined;
windowHours?: number | undefined;
delayHours?: number | undefined;
/** Must be true for the override to take effect. If true, the other proper prior settings in this object will be used if present. */
properPriorOverride?: boolean | undefined;
properPriorEnabled?: boolean | undefined;
properPriorMean?: number | undefined;
properPriorStdDev?: number | undefined;
/** Must be true for the override to take effect. If true, the other regression adjustment settings in this object will be used if present. */
regressionAdjustmentOverride?: boolean | undefined;
regressionAdjustmentEnabled?: boolean | undefined;
regressionAdjustmentDays?: number | undefined;
}[] | undefined;
goals: {
metricId: string;
overrides: {
delayHours?: number | undefined;
windowHours?: number | undefined;
window?: ("conversion" | "lookback" | "") | undefined;
winRiskThreshold?: number | undefined;
loseRiskThreshold?: number | undefined;
properPriorOverride?: boolean | undefined;
properPriorEnabled?: boolean | undefined;
properPriorMean?: number | undefined;
properPriorStdDev?: number | undefined;
regressionAdjustmentOverride?: boolean | undefined;
regressionAdjustmentEnabled?: boolean | undefined;
regressionAdjustmentDays?: number | undefined;
};
}[];
secondaryMetrics: {
metricId: string;
overrides: {
delayHours?: number | undefined;
windowHours?: number | undefined;
window?: ("conversion" | "lookback" | "") | undefined;
winRiskThreshold?: number | undefined;
loseRiskThreshold?: number | undefined;
properPriorOverride?: boolean | undefined;
properPriorEnabled?: boolean | undefined;
properPriorMean?: number | undefined;
properPriorStdDev?: number | undefined;
regressionAdjustmentOverride?: boolean | undefined;
regressionAdjustmentEnabled?: boolean | undefined;
regressionAdjustmentDays?: number | undefined;
};
}[];
guardrails: {
metricId: string;
overrides: {
delayHours?: number | undefined;
windowHours?: number | undefined;
window?: ("conversion" | "lookback" | "") | undefined;
winRiskThreshold?: number | undefined;
loseRiskThreshold?: number | undefined;
properPriorOverride?: boolean | undefined;
properPriorEnabled?: boolean | undefined;
properPriorMean?: number | undefined;
properPriorStdDev?: number | undefined;
regressionAdjustmentOverride?: boolean | undefined;
regressionAdjustmentEnabled?: boolean | undefined;
regressionAdjustmentDays?: number | undefined;
};
}[];
activationMetric?: {
metricId: string;
overrides: {
delayHours?: number | undefined;
windowHours?: number | undefined;
window?: ("conversion" | "lookback" | "") | undefined;
winRiskThreshold?: number | undefined;
loseRiskThreshold?: number | undefined;
properPriorOverride?: boolean | undefined;
properPriorEnabled?: boolean | undefined;
properPriorMean?: number | undefined;
properPriorStdDev?: number | undefined;
regressionAdjustmentOverride?: boolean | undefined;
regressionAdjustmentEnabled?: boolean | undefined;
regressionAdjustmentDays?: number | undefined;
};
} | undefined;
} | undefined;
resultSummary?: {
status: string;
winner: string;
conclusions: string;
releasedVariationId: string;
excludeFromPayload: boolean;
} | undefined;
shareLevel?: ("public" | "organization") | undefined;
publicUrl?: string | undefined;
banditScheduleValue?: number | undefined;
banditScheduleUnit?: ("days" | "hours") | undefined;
banditBurnInValue?: number | undefined;
banditBurnInUnit?: ("days" | "hours") | undefined;
banditConversionWindowValue?: number | undefined;
banditConversionWindowUnit?: ("days" | "hours") | undefined;
linkedFeatures?: string[] | undefined;
hasVisualChangesets?: boolean | undefined;
hasURLRedirects?: boolean | undefined;
customFields?: Record | undefined;
/** Custom slices that apply to ALL applicable metrics in the experiment */
customMetricSlices?: {
slices: {
column: string;
levels: string[];
}[];
}[] | undefined;
precomputedUnitDimensionIds?: string[] | undefined;
/** ID of the default dashboard for this experiment. */
defaultDashboardId?: string | undefined;
templateId?: string | undefined;
statusUpdateSchedule?: ({
startAt?: string | undefined;
stopAt?: string | undefined;
/** Relative end offset. Deferred: resolved to a concrete `stopAt` at the experiment's actual start (or off `dateStarted` when already running). */
stopAfter?: {
value: number;
unit: "hours" | "days";
} | undefined;
/** What happens at the scheduled end date. `notify` keeps the experiment running and just notifies (soft). `auto-ship` (requires the Decision Framework) ships the winning variation and stops; multi-winner ties break on `tiebreakerMetricId` (higher lift); with no clear winner, `fallback` either keeps running (`notify`) or ships `fallbackVariationId`. `force-ship` stops and rolls out `fallbackVariationId`. `stop` is a hard deadline that stops with no rollout. For `force-ship` and `stop`, the Decision Framework verdict (won/lost/inconclusive) is recorded as metadata when available. */
scheduledStopPlan?: {
mode: "notify" | "auto-ship" | "force-ship" | "stop";
tiebreakerMetricId?: string | undefined;
fallback: "notify" | "force-ship";
fallbackVariationId?: string | undefined;
} | undefined;
} | null) | undefined;
nextScheduledStatusUpdate?: ({
type: "start" | "stop";
date: string;
} | null) | undefined;
};
changes?: {
added: Record;
removed: Record;
modified: Record;
} | undefined;
};
user: {
type: "dashboard";
id: string;
email: string;
name: string;
} | {
type: "api_key";
apiKey: string;
id?: string | undefined;
name?: string | undefined;
email?: string | undefined;
} | {
type: "system";
subtype?: string | undefined;
id?: string | undefined;
} | null;
tags: string[];
/** The environments affected by the change described by this event. For live-state events (e.g. `feature.updated`) these are the environments whose effective configuration actually changed; for draft lifecycle events (`*.revision.*`) they are the environments the proposed changes would affect. Webhook environment filters match against this field. An empty array means the event has no environment-scoped impact (it will only be delivered to subscriptions without an environment filter). */
environments: string[];
containsSecrets: boolean;
}
```
### experiment.deleted
Triggered when an experiment is deleted
```typescript theme={null}
{
event: "experiment.deleted";
object: "experiment";
api_version: string;
created: number;
data: {
object: {
id: string;
trackingKey: string;
dateCreated: string;
dateUpdated: string;
name: string;
type: "standard" | "multi-armed-bandit" | "holdout";
project: string;
hypothesis: string;
description: string;
tags: string[];
/** The userId of the owner (or raw owner name/email for legacy records) */
owner: string;
ownerEmail?: string | undefined;
archived: boolean;
status: string;
autoRefresh: boolean;
hashAttribute: string;
fallbackAttribute?: string | undefined;
hashVersion: 1 | 2;
disableStickyBucketing?: boolean | undefined;
bucketVersion?: number | undefined;
minBucketVersion?: number | undefined;
variations: {
variationId: string;
key: string;
name: string;
description: string;
screenshots: string[];
}[];
phases: {
name: string;
dateStarted: string;
dateEnded: string;
reasonForStopping: string;
seed: string;
coverage: number;
trafficSplit: {
variationId: string;
weight: number;
}[];
namespace?: {
namespaceId: string;
enabled?: boolean | undefined;
range?: number[] | undefined;
ranges?: [
number,
number
][] | undefined;
} | undefined;
targetingCondition: string;
prerequisites?: {
id: string;
condition: string;
}[] | undefined;
savedGroupTargeting?: {
matchType: "all" | "any" | "none";
savedGroups: string[];
}[] | undefined;
}[];
settings: {
datasourceId: string;
assignmentQueryId: string;
experimentId: string;
segmentId: string;
queryFilter: string;
inProgressConversions: "include" | "exclude";
/** Setting attribution model to `"experimentDuration"` is the same as selecting "Ignore Conversion Windows" for the Conversion Window Override. Setting it to `"lookbackOverride"` requires a `lookbackOverride` object to be provided. */
attributionModel: "firstExposure" | "experimentDuration" | "lookbackOverride";
/** Controls the lookback override for the experiment. For type "window", value must be a non-negative number and valueUnit is required. */
lookbackOverride?: {
type: "date" | "window";
/** For "window" type - non-negative numeric value (e.g. 7 for 7 days). For "date" type a date string. */
value: number | string;
/** Used when type is "window". Defaults to "days". */
valueUnit?: ("minutes" | "hours" | "days" | "weeks") | undefined;
} | undefined;
statsEngine: "bayesian" | "frequentist";
regressionAdjustmentEnabled?: boolean | undefined;
sequentialTestingEnabled?: boolean | undefined;
sequentialTestingTuningParameter?: number | undefined;
/** When null, the organization default is used. */
postStratificationEnabled?: (boolean | null) | undefined;
/** Controls the decision framework and metric overrides for the experiment. Replaces the entire stored object on update (does not patch individual fields). */
decisionFrameworkSettings?: {
decisionCriteriaId?: string | undefined;
decisionFrameworkMetricOverrides?: {
/** ID of the metric to override settings for. */
id: string;
/** The target relative MDE to use for the metric, expressed as proportions (e.g. use 0.1 for 10%). Must be greater than 0. */
targetMDE?: number | undefined;
}[] | undefined;
} | undefined;
/** Per-metric analysis overrides; also reflected in goals/secondaryMetrics/guardrails overrides when applicable. On create/update, this replaces the entire stored array (it does not patch individual entries). */
metricOverrides?: {
/** ID of the metric to override settings for. */
id: string;
windowType?: ("conversion" | "lookback" | "") | undefined;
windowHours?: number | undefined;
delayHours?: number | undefined;
/** Must be true for the override to take effect. If true, the other proper prior settings in this object will be used if present. */
properPriorOverride?: boolean | undefined;
properPriorEnabled?: boolean | undefined;
properPriorMean?: number | undefined;
properPriorStdDev?: number | undefined;
/** Must be true for the override to take effect. If true, the other regression adjustment settings in this object will be used if present. */
regressionAdjustmentOverride?: boolean | undefined;
regressionAdjustmentEnabled?: boolean | undefined;
regressionAdjustmentDays?: number | undefined;
}[] | undefined;
goals: {
metricId: string;
overrides: {
delayHours?: number | undefined;
windowHours?: number | undefined;
window?: ("conversion" | "lookback" | "") | undefined;
winRiskThreshold?: number | undefined;
loseRiskThreshold?: number | undefined;
properPriorOverride?: boolean | undefined;
properPriorEnabled?: boolean | undefined;
properPriorMean?: number | undefined;
properPriorStdDev?: number | undefined;
regressionAdjustmentOverride?: boolean | undefined;
regressionAdjustmentEnabled?: boolean | undefined;
regressionAdjustmentDays?: number | undefined;
};
}[];
secondaryMetrics: {
metricId: string;
overrides: {
delayHours?: number | undefined;
windowHours?: number | undefined;
window?: ("conversion" | "lookback" | "") | undefined;
winRiskThreshold?: number | undefined;
loseRiskThreshold?: number | undefined;
properPriorOverride?: boolean | undefined;
properPriorEnabled?: boolean | undefined;
properPriorMean?: number | undefined;
properPriorStdDev?: number | undefined;
regressionAdjustmentOverride?: boolean | undefined;
regressionAdjustmentEnabled?: boolean | undefined;
regressionAdjustmentDays?: number | undefined;
};
}[];
guardrails: {
metricId: string;
overrides: {
delayHours?: number | undefined;
windowHours?: number | undefined;
window?: ("conversion" | "lookback" | "") | undefined;
winRiskThreshold?: number | undefined;
loseRiskThreshold?: number | undefined;
properPriorOverride?: boolean | undefined;
properPriorEnabled?: boolean | undefined;
properPriorMean?: number | undefined;
properPriorStdDev?: number | undefined;
regressionAdjustmentOverride?: boolean | undefined;
regressionAdjustmentEnabled?: boolean | undefined;
regressionAdjustmentDays?: number | undefined;
};
}[];
activationMetric?: {
metricId: string;
overrides: {
delayHours?: number | undefined;
windowHours?: number | undefined;
window?: ("conversion" | "lookback" | "") | undefined;
winRiskThreshold?: number | undefined;
loseRiskThreshold?: number | undefined;
properPriorOverride?: boolean | undefined;
properPriorEnabled?: boolean | undefined;
properPriorMean?: number | undefined;
properPriorStdDev?: number | undefined;
regressionAdjustmentOverride?: boolean | undefined;
regressionAdjustmentEnabled?: boolean | undefined;
regressionAdjustmentDays?: number | undefined;
};
} | undefined;
};
resultSummary?: {
status: string;
winner: string;
conclusions: string;
releasedVariationId: string;
excludeFromPayload: boolean;
} | undefined;
shareLevel?: ("public" | "organization") | undefined;
publicUrl?: string | undefined;
banditScheduleValue?: number | undefined;
banditScheduleUnit?: ("days" | "hours") | undefined;
banditBurnInValue?: number | undefined;
banditBurnInUnit?: ("days" | "hours") | undefined;
banditConversionWindowValue?: number | undefined;
banditConversionWindowUnit?: ("days" | "hours") | undefined;
linkedFeatures?: string[] | undefined;
hasVisualChangesets?: boolean | undefined;
hasURLRedirects?: boolean | undefined;
customFields?: Record | undefined;
/** Custom slices that apply to ALL applicable metrics in the experiment */
customMetricSlices?: {
slices: {
column: string;
levels: string[];
}[];
}[] | undefined;
precomputedUnitDimensionIds?: string[] | undefined;
/** ID of the default dashboard for this experiment. */
defaultDashboardId?: string | undefined;
templateId?: string | undefined;
statusUpdateSchedule?: ({
startAt?: string | undefined;
stopAt?: string | undefined;
/** Relative end offset. Deferred: resolved to a concrete `stopAt` at the experiment's actual start (or off `dateStarted` when already running). */
stopAfter?: {
value: number;
unit: "hours" | "days";
} | undefined;
/** What happens at the scheduled end date. `notify` keeps the experiment running and just notifies (soft). `auto-ship` (requires the Decision Framework) ships the winning variation and stops; multi-winner ties break on `tiebreakerMetricId` (higher lift); with no clear winner, `fallback` either keeps running (`notify`) or ships `fallbackVariationId`. `force-ship` stops and rolls out `fallbackVariationId`. `stop` is a hard deadline that stops with no rollout. For `force-ship` and `stop`, the Decision Framework verdict (won/lost/inconclusive) is recorded as metadata when available. */
scheduledStopPlan?: {
mode: "notify" | "auto-ship" | "force-ship" | "stop";
tiebreakerMetricId?: string | undefined;
fallback: "notify" | "force-ship";
fallbackVariationId?: string | undefined;
} | undefined;
} | null) | undefined;
nextScheduledStatusUpdate?: ({
type: "start" | "stop";
date: string;
} | null) | undefined;
};
};
user: {
type: "dashboard";
id: string;
email: string;
name: string;
} | {
type: "api_key";
apiKey: string;
id?: string | undefined;
name?: string | undefined;
email?: string | undefined;
} | {
type: "system";
subtype?: string | undefined;
id?: string | undefined;
} | null;
tags: string[];
/** The environments affected by the change described by this event. For live-state events (e.g. `feature.updated`) these are the environments whose effective configuration actually changed; for draft lifecycle events (`*.revision.*`) they are the environments the proposed changes would affect. Webhook environment filters match against this field. An empty array means the event has no environment-scoped impact (it will only be delivered to subscriptions without an environment filter). */
environments: string[];
containsSecrets: boolean;
}
```
### experiment.warning
Triggered when a warning condition is detected on an experiment
```typescript theme={null}
{
event: "experiment.warning";
object: "experiment";
api_version: string;
created: number;
data: {
object: {
type: "auto-update";
success: boolean;
experimentName: string;
experimentId: string;
} | {
type: "multiple-exposures";
experimentName: string;
experimentId: string;
usersCount: number;
percent: number;
} | {
type: "srm";
experimentName: string;
experimentId: string;
threshold: number;
} | {
type: "no-data";
experimentName: string;
experimentId: string;
} | {
type: "scheduled-status-update-failed";
experimentName: string;
experimentId: string;
scheduledStatusUpdateType: "start" | "stop";
attempts: number;
maxAttempts: number;
willRetry: boolean;
reason: string;
};
};
user: {
type: "dashboard";
id: string;
email: string;
name: string;
} | {
type: "api_key";
apiKey: string;
id?: string | undefined;
name?: string | undefined;
email?: string | undefined;
} | {
type: "system";
subtype?: string | undefined;
id?: string | undefined;
} | null;
tags: string[];
/** The environments affected by the change described by this event. For live-state events (e.g. `feature.updated`) these are the environments whose effective configuration actually changed; for draft lifecycle events (`*.revision.*`) they are the environments the proposed changes would affect. Webhook environment filters match against this field. An empty array means the event has no environment-scoped impact (it will only be delivered to subscriptions without an environment filter). */
environments: string[];
containsSecrets: boolean;
}
```
### experiment.info.significance
Triggered when a goal or guardrail metric reaches significance in an experiment (e.g. either above 95% or below 5% chance to win). Be careful using this without Sequential Testing as it can lead to peeking problems.
```typescript theme={null}
{
event: "experiment.info.significance";
object: "experiment";
api_version: string;
created: number;
data: {
object: {
experimentName: string;
experimentId: string;
variationId: string;
variationName: string;
metricName: string;
metricId: string;
statsEngine: string;
criticalValue: number;
winning: boolean;
};
};
user: {
type: "dashboard";
id: string;
email: string;
name: string;
} | {
type: "api_key";
apiKey: string;
id?: string | undefined;
name?: string | undefined;
email?: string | undefined;
} | {
type: "system";
subtype?: string | undefined;
id?: string | undefined;
} | null;
tags: string[];
/** The environments affected by the change described by this event. For live-state events (e.g. `feature.updated`) these are the environments whose effective configuration actually changed; for draft lifecycle events (`*.revision.*`) they are the environments the proposed changes would affect. Webhook environment filters match against this field. An empty array means the event has no environment-scoped impact (it will only be delivered to subscriptions without an environment filter). */
environments: string[];
containsSecrets: boolean;
}
```
### experiment.info.scheduled-status-update
Triggered when a scheduled start or stop is automatically applied to an experiment, including the auto-ship outcome for a scheduled end.
```typescript theme={null}
{
event: "experiment.info.scheduled-status-update";
object: "experiment";
api_version: string;
created: number;
data: {
object: {
experimentId: string;
experimentName: string;
action: "started" | "stopped" | "kept-running";
shipped?: boolean | undefined;
shippedVariationId?: string | undefined;
shippedVariationName?: string | undefined;
forced?: boolean | undefined;
recommendedVariationId?: string | undefined;
recommendedVariationName?: string | undefined;
};
};
user: {
type: "dashboard";
id: string;
email: string;
name: string;
} | {
type: "api_key";
apiKey: string;
id?: string | undefined;
name?: string | undefined;
email?: string | undefined;
} | {
type: "system";
subtype?: string | undefined;
id?: string | undefined;
} | null;
tags: string[];
/** The environments affected by the change described by this event. For live-state events (e.g. `feature.updated`) these are the environments whose effective configuration actually changed; for draft lifecycle events (`*.revision.*`) they are the environments the proposed changes would affect. Webhook environment filters match against this field. An empty array means the event has no environment-scoped impact (it will only be delivered to subscriptions without an environment filter). */
environments: string[];
containsSecrets: boolean;
}
```
### experiment.decision.ship
Triggered when an experiment is ready to ship a variation.
```typescript theme={null}
{
event: "experiment.decision.ship";
object: "experiment";
api_version: string;
created: number;
data: {
object: {
experimentName: string;
experimentId: string;
decisionDescription?: string | undefined;
source: "scheduled-end" | "analysis";
};
};
user: {
type: "dashboard";
id: string;
email: string;
name: string;
} | {
type: "api_key";
apiKey: string;
id?: string | undefined;
name?: string | undefined;
email?: string | undefined;
} | {
type: "system";
subtype?: string | undefined;
id?: string | undefined;
} | null;
tags: string[];
/** The environments affected by the change described by this event. For live-state events (e.g. `feature.updated`) these are the environments whose effective configuration actually changed; for draft lifecycle events (`*.revision.*`) they are the environments the proposed changes would affect. Webhook environment filters match against this field. An empty array means the event has no environment-scoped impact (it will only be delivered to subscriptions without an environment filter). */
environments: string[];
containsSecrets: boolean;
}
```
### experiment.decision.rollback
Triggered when an experiment should be rolled back to the control.
```typescript theme={null}
{
event: "experiment.decision.rollback";
object: "experiment";
api_version: string;
created: number;
data: {
object: {
experimentName: string;
experimentId: string;
decisionDescription?: string | undefined;
source: "scheduled-end" | "analysis";
};
};
user: {
type: "dashboard";
id: string;
email: string;
name: string;
} | {
type: "api_key";
apiKey: string;
id?: string | undefined;
name?: string | undefined;
email?: string | undefined;
} | {
type: "system";
subtype?: string | undefined;
id?: string | undefined;
} | null;
tags: string[];
/** The environments affected by the change described by this event. For live-state events (e.g. `feature.updated`) these are the environments whose effective configuration actually changed; for draft lifecycle events (`*.revision.*`) they are the environments the proposed changes would affect. Webhook environment filters match against this field. An empty array means the event has no environment-scoped impact (it will only be delivered to subscriptions without an environment filter). */
environments: string[];
containsSecrets: boolean;
}
```
### experiment.decision.review
Triggered when an experiment has reached the desired power point, but the results may be ambiguous.
```typescript theme={null}
{
event: "experiment.decision.review";
object: "experiment";
api_version: string;
created: number;
data: {
object: {
experimentName: string;
experimentId: string;
decisionDescription?: string | undefined;
source: "scheduled-end" | "analysis";
};
};
user: {
type: "dashboard";
id: string;
email: string;
name: string;
} | {
type: "api_key";
apiKey: string;
id?: string | undefined;
name?: string | undefined;
email?: string | undefined;
} | {
type: "system";
subtype?: string | undefined;
id?: string | undefined;
} | null;
tags: string[];
/** The environments affected by the change described by this event. For live-state events (e.g. `feature.updated`) these are the environments whose effective configuration actually changed; for draft lifecycle events (`*.revision.*`) they are the environments the proposed changes would affect. Webhook environment filters match against this field. An empty array means the event has no environment-scoped impact (it will only be delivered to subscriptions without an environment filter). */
environments: string[];
containsSecrets: boolean;
}
```
### savedGroup.created
Triggered when a saved group is created
```typescript theme={null}
{
event: "savedGroup.created";
object: "savedGroup";
api_version: string;
created: number;
data: {
object: {
id: string;
type: "condition" | "list";
dateCreated: string;
dateUpdated: string;
name: string;
/** The userId of the owner (or raw owner name/email for legacy records) */
owner?: string | undefined;
ownerEmail?: string | undefined;
/** When type = 'condition', this is the JSON-encoded condition for the group */
condition?: string | undefined;
/** When type = 'list', this is the attribute key the group is based on */
attributeKey?: string | undefined;
/** When type = 'list', this is the list of values for the attribute key */
values?: string[] | undefined;
description?: string | undefined;
projects?: string[] | undefined;
archived?: boolean | undefined;
useEmptyListGroup?: boolean | undefined;
};
};
user: {
type: "dashboard";
id: string;
email: string;
name: string;
} | {
type: "api_key";
apiKey: string;
id?: string | undefined;
name?: string | undefined;
email?: string | undefined;
} | {
type: "system";
subtype?: string | undefined;
id?: string | undefined;
} | null;
tags: string[];
/** The environments affected by the change described by this event. For live-state events (e.g. `feature.updated`) these are the environments whose effective configuration actually changed; for draft lifecycle events (`*.revision.*`) they are the environments the proposed changes would affect. Webhook environment filters match against this field. An empty array means the event has no environment-scoped impact (it will only be delivered to subscriptions without an environment filter). */
environments: string[];
containsSecrets: boolean;
}
```
### savedGroup.updated
Triggered when a saved group is updated
```typescript theme={null}
{
event: "savedGroup.updated";
object: "savedGroup";
api_version: string;
created: number;
data: {
object: {
id: string;
type: "condition" | "list";
dateCreated: string;
dateUpdated: string;
name: string;
/** The userId of the owner (or raw owner name/email for legacy records) */
owner?: string | undefined;
ownerEmail?: string | undefined;
/** When type = 'condition', this is the JSON-encoded condition for the group */
condition?: string | undefined;
/** When type = 'list', this is the attribute key the group is based on */
attributeKey?: string | undefined;
/** When type = 'list', this is the list of values for the attribute key */
values?: string[] | undefined;
description?: string | undefined;
projects?: string[] | undefined;
archived?: boolean | undefined;
useEmptyListGroup?: boolean | undefined;
};
previous_attributes: {
id?: string | undefined;
type?: ("condition" | "list") | undefined;
dateCreated?: string | undefined;
dateUpdated?: string | undefined;
name?: string | undefined;
/** The userId of the owner (or raw owner name/email for legacy records) */
owner?: string | undefined;
ownerEmail?: string | undefined;
/** When type = 'condition', this is the JSON-encoded condition for the group */
condition?: string | undefined;
/** When type = 'list', this is the attribute key the group is based on */
attributeKey?: string | undefined;
/** When type = 'list', this is the list of values for the attribute key */
values?: string[] | undefined;
description?: string | undefined;
projects?: string[] | undefined;
archived?: boolean | undefined;
useEmptyListGroup?: boolean | undefined;
};
changes?: {
added: Record;
removed: Record;
modified: Record;
} | undefined;
};
user: {
type: "dashboard";
id: string;
email: string;
name: string;
} | {
type: "api_key";
apiKey: string;
id?: string | undefined;
name?: string | undefined;
email?: string | undefined;
} | {
type: "system";
subtype?: string | undefined;
id?: string | undefined;
} | null;
tags: string[];
/** The environments affected by the change described by this event. For live-state events (e.g. `feature.updated`) these are the environments whose effective configuration actually changed; for draft lifecycle events (`*.revision.*`) they are the environments the proposed changes would affect. Webhook environment filters match against this field. An empty array means the event has no environment-scoped impact (it will only be delivered to subscriptions without an environment filter). */
environments: string[];
containsSecrets: boolean;
}
```
### savedGroup.deleted
Triggered when a saved group is deleted
```typescript theme={null}
{
event: "savedGroup.deleted";
object: "savedGroup";
api_version: string;
created: number;
data: {
object: {
id: string;
type: "condition" | "list";
dateCreated: string;
dateUpdated: string;
name: string;
/** The userId of the owner (or raw owner name/email for legacy records) */
owner?: string | undefined;
ownerEmail?: string | undefined;
/** When type = 'condition', this is the JSON-encoded condition for the group */
condition?: string | undefined;
/** When type = 'list', this is the attribute key the group is based on */
attributeKey?: string | undefined;
/** When type = 'list', this is the list of values for the attribute key */
values?: string[] | undefined;
description?: string | undefined;
projects?: string[] | undefined;
archived?: boolean | undefined;
useEmptyListGroup?: boolean | undefined;
};
};
user: {
type: "dashboard";
id: string;
email: string;
name: string;
} | {
type: "api_key";
apiKey: string;
id?: string | undefined;
name?: string | undefined;
email?: string | undefined;
} | {
type: "system";
subtype?: string | undefined;
id?: string | undefined;
} | null;
tags: string[];
/** The environments affected by the change described by this event. For live-state events (e.g. `feature.updated`) these are the environments whose effective configuration actually changed; for draft lifecycle events (`*.revision.*`) they are the environments the proposed changes would affect. Webhook environment filters match against this field. An empty array means the event has no environment-scoped impact (it will only be delivered to subscriptions without an environment filter). */
environments: string[];
containsSecrets: boolean;
}
```
### savedGroup.revision.created
Triggered when a new draft revision is created for a saved group
```typescript theme={null}
{
event: "savedGroup.revision.created";
object: "savedGroup";
api_version: string;
created: number;
data: {
object: {
id: string;
version?: number | undefined;
title?: string | undefined;
status: "draft" | "pending-review" | "approved" | "changes-requested" | "merged" | "discarded";
authorId: string;
authorEmail?: string | undefined;
contributors?: string[] | undefined;
revertedFrom?: string | undefined;
reviews: {
id: string;
userId: string;
decision: "approve" | "request-changes" | "comment";
comment?: string | undefined;
dateCreated: string;
}[];
activityLog: {
id: string;
userId: string;
action: string;
dateCreated: string;
}[];
resolution?: {
action: "merged" | "discarded";
userId: string;
dateCreated: string;
} | undefined;
dateCreated: string;
dateUpdated: string;
baseSavedGroup: {
id: string;
type: "condition" | "list";
dateCreated: string;
dateUpdated: string;
name: string;
/** The userId of the owner (or raw owner name/email for legacy records) */
owner?: string | undefined;
ownerEmail?: string | undefined;
/** When type = 'condition', this is the JSON-encoded condition for the group */
condition?: string | undefined;
/** When type = 'list', this is the attribute key the group is based on */
attributeKey?: string | undefined;
/** When type = 'list', this is the list of values for the attribute key */
values?: string[] | undefined;
description?: string | undefined;
projects?: string[] | undefined;
archived?: boolean | undefined;
useEmptyListGroup?: boolean | undefined;
};
proposedSavedGroup: {
id: string;
type: "condition" | "list";
dateCreated: string;
dateUpdated: string;
name: string;
/** The userId of the owner (or raw owner name/email for legacy records) */
owner?: string | undefined;
ownerEmail?: string | undefined;
/** When type = 'condition', this is the JSON-encoded condition for the group */
condition?: string | undefined;
/** When type = 'list', this is the attribute key the group is based on */
attributeKey?: string | undefined;
/** When type = 'list', this is the list of values for the attribute key */
values?: string[] | undefined;
description?: string | undefined;
projects?: string[] | undefined;
archived?: boolean | undefined;
useEmptyListGroup?: boolean | undefined;
};
proposedChanges: {
op: string;
path: string;
}[];
};
};
user: {
type: "dashboard";
id: string;
email: string;
name: string;
} | {
type: "api_key";
apiKey: string;
id?: string | undefined;
name?: string | undefined;
email?: string | undefined;
} | {
type: "system";
subtype?: string | undefined;
id?: string | undefined;
} | null;
tags: string[];
/** The environments affected by the change described by this event. For live-state events (e.g. `feature.updated`) these are the environments whose effective configuration actually changed; for draft lifecycle events (`*.revision.*`) they are the environments the proposed changes would affect. Webhook environment filters match against this field. An empty array means the event has no environment-scoped impact (it will only be delivered to subscriptions without an environment filter). */
environments: string[];
containsSecrets: boolean;
}
```
### savedGroup.revision.updated
Triggered when a draft revision's proposed changes are modified (values, condition, archive, or metadata). The `change` field indicates the kind of mutation.
```typescript theme={null}
{
event: "savedGroup.revision.updated";
object: "savedGroup";
api_version: string;
created: number;
data: {
object: {
id: string;
version?: number | undefined;
title?: string | undefined;
status: "draft" | "pending-review" | "approved" | "changes-requested" | "merged" | "discarded";
authorId: string;
authorEmail?: string | undefined;
contributors?: string[] | undefined;
revertedFrom?: string | undefined;
reviews: {
id: string;
userId: string;
decision: "approve" | "request-changes" | "comment";
comment?: string | undefined;
dateCreated: string;
}[];
activityLog: {
id: string;
userId: string;
action: string;
dateCreated: string;
}[];
resolution?: {
action: "merged" | "discarded";
userId: string;
dateCreated: string;
} | undefined;
dateCreated: string;
dateUpdated: string;
baseSavedGroup: {
id: string;
type: "condition" | "list";
dateCreated: string;
dateUpdated: string;
name: string;
/** The userId of the owner (or raw owner name/email for legacy records) */
owner?: string | undefined;
ownerEmail?: string | undefined;
/** When type = 'condition', this is the JSON-encoded condition for the group */
condition?: string | undefined;
/** When type = 'list', this is the attribute key the group is based on */
attributeKey?: string | undefined;
/** When type = 'list', this is the list of values for the attribute key */
values?: string[] | undefined;
description?: string | undefined;
projects?: string[] | undefined;
archived?: boolean | undefined;
useEmptyListGroup?: boolean | undefined;
};
proposedSavedGroup: {
id: string;
type: "condition" | "list";
dateCreated: string;
dateUpdated: string;
name: string;
/** The userId of the owner (or raw owner name/email for legacy records) */
owner?: string | undefined;
ownerEmail?: string | undefined;
/** When type = 'condition', this is the JSON-encoded condition for the group */
condition?: string | undefined;
/** When type = 'list', this is the attribute key the group is based on */
attributeKey?: string | undefined;
/** When type = 'list', this is the list of values for the attribute key */
values?: string[] | undefined;
description?: string | undefined;
projects?: string[] | undefined;
archived?: boolean | undefined;
useEmptyListGroup?: boolean | undefined;
};
proposedChanges: {
op: string;
path: string;
}[];
change: "metadata" | "condition" | "values" | "archive";
};
};
user: {
type: "dashboard";
id: string;
email: string;
name: string;
} | {
type: "api_key";
apiKey: string;
id?: string | undefined;
name?: string | undefined;
email?: string | undefined;
} | {
type: "system";
subtype?: string | undefined;
id?: string | undefined;
} | null;
tags: string[];
/** The environments affected by the change described by this event. For live-state events (e.g. `feature.updated`) these are the environments whose effective configuration actually changed; for draft lifecycle events (`*.revision.*`) they are the environments the proposed changes would affect. Webhook environment filters match against this field. An empty array means the event has no environment-scoped impact (it will only be delivered to subscriptions without an environment filter). */
environments: string[];
containsSecrets: boolean;
}
```
### savedGroup.revision.reviewRequested
Triggered when a draft revision is submitted for review
```typescript theme={null}
{
event: "savedGroup.revision.reviewRequested";
object: "savedGroup";
api_version: string;
created: number;
data: {
object: {
id: string;
version?: number | undefined;
title?: string | undefined;
status: "draft" | "pending-review" | "approved" | "changes-requested" | "merged" | "discarded";
authorId: string;
authorEmail?: string | undefined;
contributors?: string[] | undefined;
revertedFrom?: string | undefined;
reviews: {
id: string;
userId: string;
decision: "approve" | "request-changes" | "comment";
comment?: string | undefined;
dateCreated: string;
}[];
activityLog: {
id: string;
userId: string;
action: string;
dateCreated: string;
}[];
resolution?: {
action: "merged" | "discarded";
userId: string;
dateCreated: string;
} | undefined;
dateCreated: string;
dateUpdated: string;
baseSavedGroup: {
id: string;
type: "condition" | "list";
dateCreated: string;
dateUpdated: string;
name: string;
/** The userId of the owner (or raw owner name/email for legacy records) */
owner?: string | undefined;
ownerEmail?: string | undefined;
/** When type = 'condition', this is the JSON-encoded condition for the group */
condition?: string | undefined;
/** When type = 'list', this is the attribute key the group is based on */
attributeKey?: string | undefined;
/** When type = 'list', this is the list of values for the attribute key */
values?: string[] | undefined;
description?: string | undefined;
projects?: string[] | undefined;
archived?: boolean | undefined;
useEmptyListGroup?: boolean | undefined;
};
proposedSavedGroup: {
id: string;
type: "condition" | "list";
dateCreated: string;
dateUpdated: string;
name: string;
/** The userId of the owner (or raw owner name/email for legacy records) */
owner?: string | undefined;
ownerEmail?: string | undefined;
/** When type = 'condition', this is the JSON-encoded condition for the group */
condition?: string | undefined;
/** When type = 'list', this is the attribute key the group is based on */
attributeKey?: string | undefined;
/** When type = 'list', this is the list of values for the attribute key */
values?: string[] | undefined;
description?: string | undefined;
projects?: string[] | undefined;
archived?: boolean | undefined;
useEmptyListGroup?: boolean | undefined;
};
proposedChanges: {
op: string;
path: string;
}[];
};
};
user: {
type: "dashboard";
id: string;
email: string;
name: string;
} | {
type: "api_key";
apiKey: string;
id?: string | undefined;
name?: string | undefined;
email?: string | undefined;
} | {
type: "system";
subtype?: string | undefined;
id?: string | undefined;
} | null;
tags: string[];
/** The environments affected by the change described by this event. For live-state events (e.g. `feature.updated`) these are the environments whose effective configuration actually changed; for draft lifecycle events (`*.revision.*`) they are the environments the proposed changes would affect. Webhook environment filters match against this field. An empty array means the event has no environment-scoped impact (it will only be delivered to subscriptions without an environment filter). */
environments: string[];
containsSecrets: boolean;
}
```
### savedGroup.revision.approved
Triggered when a draft revision is approved by a reviewer
```typescript theme={null}
{
event: "savedGroup.revision.approved";
object: "savedGroup";
api_version: string;
created: number;
data: {
object: {
id: string;
version?: number | undefined;
title?: string | undefined;
status: "draft" | "pending-review" | "approved" | "changes-requested" | "merged" | "discarded";
authorId: string;
authorEmail?: string | undefined;
contributors?: string[] | undefined;
revertedFrom?: string | undefined;
reviews: {
id: string;
userId: string;
decision: "approve" | "request-changes" | "comment";
comment?: string | undefined;
dateCreated: string;
}[];
activityLog: {
id: string;
userId: string;
action: string;
dateCreated: string;
}[];
resolution?: {
action: "merged" | "discarded";
userId: string;
dateCreated: string;
} | undefined;
dateCreated: string;
dateUpdated: string;
baseSavedGroup: {
id: string;
type: "condition" | "list";
dateCreated: string;
dateUpdated: string;
name: string;
/** The userId of the owner (or raw owner name/email for legacy records) */
owner?: string | undefined;
ownerEmail?: string | undefined;
/** When type = 'condition', this is the JSON-encoded condition for the group */
condition?: string | undefined;
/** When type = 'list', this is the attribute key the group is based on */
attributeKey?: string | undefined;
/** When type = 'list', this is the list of values for the attribute key */
values?: string[] | undefined;
description?: string | undefined;
projects?: string[] | undefined;
archived?: boolean | undefined;
useEmptyListGroup?: boolean | undefined;
};
proposedSavedGroup: {
id: string;
type: "condition" | "list";
dateCreated: string;
dateUpdated: string;
name: string;
/** The userId of the owner (or raw owner name/email for legacy records) */
owner?: string | undefined;
ownerEmail?: string | undefined;
/** When type = 'condition', this is the JSON-encoded condition for the group */
condition?: string | undefined;
/** When type = 'list', this is the attribute key the group is based on */
attributeKey?: string | undefined;
/** When type = 'list', this is the list of values for the attribute key */
values?: string[] | undefined;
description?: string | undefined;
projects?: string[] | undefined;
archived?: boolean | undefined;
useEmptyListGroup?: boolean | undefined;
};
proposedChanges: {
op: string;
path: string;
}[];
reviewer: {
id?: string | undefined;
name?: string | undefined;
email?: string | undefined;
};
reviewComment: string | null;
};
};
user: {
type: "dashboard";
id: string;
email: string;
name: string;
} | {
type: "api_key";
apiKey: string;
id?: string | undefined;
name?: string | undefined;
email?: string | undefined;
} | {
type: "system";
subtype?: string | undefined;
id?: string | undefined;
} | null;
tags: string[];
/** The environments affected by the change described by this event. For live-state events (e.g. `feature.updated`) these are the environments whose effective configuration actually changed; for draft lifecycle events (`*.revision.*`) they are the environments the proposed changes would affect. Webhook environment filters match against this field. An empty array means the event has no environment-scoped impact (it will only be delivered to subscriptions without an environment filter). */
environments: string[];
containsSecrets: boolean;
}
```
### savedGroup.revision.changesRequested
Triggered when a reviewer requests changes on a draft revision
```typescript theme={null}
{
event: "savedGroup.revision.changesRequested";
object: "savedGroup";
api_version: string;
created: number;
data: {
object: {
id: string;
version?: number | undefined;
title?: string | undefined;
status: "draft" | "pending-review" | "approved" | "changes-requested" | "merged" | "discarded";
authorId: string;
authorEmail?: string | undefined;
contributors?: string[] | undefined;
revertedFrom?: string | undefined;
reviews: {
id: string;
userId: string;
decision: "approve" | "request-changes" | "comment";
comment?: string | undefined;
dateCreated: string;
}[];
activityLog: {
id: string;
userId: string;
action: string;
dateCreated: string;
}[];
resolution?: {
action: "merged" | "discarded";
userId: string;
dateCreated: string;
} | undefined;
dateCreated: string;
dateUpdated: string;
baseSavedGroup: {
id: string;
type: "condition" | "list";
dateCreated: string;
dateUpdated: string;
name: string;
/** The userId of the owner (or raw owner name/email for legacy records) */
owner?: string | undefined;
ownerEmail?: string | undefined;
/** When type = 'condition', this is the JSON-encoded condition for the group */
condition?: string | undefined;
/** When type = 'list', this is the attribute key the group is based on */
attributeKey?: string | undefined;
/** When type = 'list', this is the list of values for the attribute key */
values?: string[] | undefined;
description?: string | undefined;
projects?: string[] | undefined;
archived?: boolean | undefined;
useEmptyListGroup?: boolean | undefined;
};
proposedSavedGroup: {
id: string;
type: "condition" | "list";
dateCreated: string;
dateUpdated: string;
name: string;
/** The userId of the owner (or raw owner name/email for legacy records) */
owner?: string | undefined;
ownerEmail?: string | undefined;
/** When type = 'condition', this is the JSON-encoded condition for the group */
condition?: string | undefined;
/** When type = 'list', this is the attribute key the group is based on */
attributeKey?: string | undefined;
/** When type = 'list', this is the list of values for the attribute key */
values?: string[] | undefined;
description?: string | undefined;
projects?: string[] | undefined;
archived?: boolean | undefined;
useEmptyListGroup?: boolean | undefined;
};
proposedChanges: {
op: string;
path: string;
}[];
reviewer: {
id?: string | undefined;
name?: string | undefined;
email?: string | undefined;
};
reviewComment: string | null;
};
};
user: {
type: "dashboard";
id: string;
email: string;
name: string;
} | {
type: "api_key";
apiKey: string;
id?: string | undefined;
name?: string | undefined;
email?: string | undefined;
} | {
type: "system";
subtype?: string | undefined;
id?: string | undefined;
} | null;
tags: string[];
/** The environments affected by the change described by this event. For live-state events (e.g. `feature.updated`) these are the environments whose effective configuration actually changed; for draft lifecycle events (`*.revision.*`) they are the environments the proposed changes would affect. Webhook environment filters match against this field. An empty array means the event has no environment-scoped impact (it will only be delivered to subscriptions without an environment filter). */
environments: string[];
containsSecrets: boolean;
}
```
### savedGroup.revision.commented
Triggered when a comment is added to a draft revision
```typescript theme={null}
{
event: "savedGroup.revision.commented";
object: "savedGroup";
api_version: string;
created: number;
data: {
object: {
id: string;
version?: number | undefined;
title?: string | undefined;
status: "draft" | "pending-review" | "approved" | "changes-requested" | "merged" | "discarded";
authorId: string;
authorEmail?: string | undefined;
contributors?: string[] | undefined;
revertedFrom?: string | undefined;
reviews: {
id: string;
userId: string;
decision: "approve" | "request-changes" | "comment";
comment?: string | undefined;
dateCreated: string;
}[];
activityLog: {
id: string;
userId: string;
action: string;
dateCreated: string;
}[];
resolution?: {
action: "merged" | "discarded";
userId: string;
dateCreated: string;
} | undefined;
dateCreated: string;
dateUpdated: string;
baseSavedGroup: {
id: string;
type: "condition" | "list";
dateCreated: string;
dateUpdated: string;
name: string;
/** The userId of the owner (or raw owner name/email for legacy records) */
owner?: string | undefined;
ownerEmail?: string | undefined;
/** When type = 'condition', this is the JSON-encoded condition for the group */
condition?: string | undefined;
/** When type = 'list', this is the attribute key the group is based on */
attributeKey?: string | undefined;
/** When type = 'list', this is the list of values for the attribute key */
values?: string[] | undefined;
description?: string | undefined;
projects?: string[] | undefined;
archived?: boolean | undefined;
useEmptyListGroup?: boolean | undefined;
};
proposedSavedGroup: {
id: string;
type: "condition" | "list";
dateCreated: string;
dateUpdated: string;
name: string;
/** The userId of the owner (or raw owner name/email for legacy records) */
owner?: string | undefined;
ownerEmail?: string | undefined;
/** When type = 'condition', this is the JSON-encoded condition for the group */
condition?: string | undefined;
/** When type = 'list', this is the attribute key the group is based on */
attributeKey?: string | undefined;
/** When type = 'list', this is the list of values for the attribute key */
values?: string[] | undefined;
description?: string | undefined;
projects?: string[] | undefined;
archived?: boolean | undefined;
useEmptyListGroup?: boolean | undefined;
};
proposedChanges: {
op: string;
path: string;
}[];
reviewer: {
id?: string | undefined;
name?: string | undefined;
email?: string | undefined;
};
reviewComment: string;
};
};
user: {
type: "dashboard";
id: string;
email: string;
name: string;
} | {
type: "api_key";
apiKey: string;
id?: string | undefined;
name?: string | undefined;
email?: string | undefined;
} | {
type: "system";
subtype?: string | undefined;
id?: string | undefined;
} | null;
tags: string[];
/** The environments affected by the change described by this event. For live-state events (e.g. `feature.updated`) these are the environments whose effective configuration actually changed; for draft lifecycle events (`*.revision.*`) they are the environments the proposed changes would affect. Webhook environment filters match against this field. An empty array means the event has no environment-scoped impact (it will only be delivered to subscriptions without an environment filter). */
environments: string[];
containsSecrets: boolean;
}
```
### savedGroup.revision.discarded
Triggered when a draft revision is discarded
```typescript theme={null}
{
event: "savedGroup.revision.discarded";
object: "savedGroup";
api_version: string;
created: number;
data: {
object: {
id: string;
version?: number | undefined;
title?: string | undefined;
status: "draft" | "pending-review" | "approved" | "changes-requested" | "merged" | "discarded";
authorId: string;
authorEmail?: string | undefined;
contributors?: string[] | undefined;
revertedFrom?: string | undefined;
reviews: {
id: string;
userId: string;
decision: "approve" | "request-changes" | "comment";
comment?: string | undefined;
dateCreated: string;
}[];
activityLog: {
id: string;
userId: string;
action: string;
dateCreated: string;
}[];
resolution?: {
action: "merged" | "discarded";
userId: string;
dateCreated: string;
} | undefined;
dateCreated: string;
dateUpdated: string;
baseSavedGroup: {
id: string;
type: "condition" | "list";
dateCreated: string;
dateUpdated: string;
name: string;
/** The userId of the owner (or raw owner name/email for legacy records) */
owner?: string | undefined;
ownerEmail?: string | undefined;
/** When type = 'condition', this is the JSON-encoded condition for the group */
condition?: string | undefined;
/** When type = 'list', this is the attribute key the group is based on */
attributeKey?: string | undefined;
/** When type = 'list', this is the list of values for the attribute key */
values?: string[] | undefined;
description?: string | undefined;
projects?: string[] | undefined;
archived?: boolean | undefined;
useEmptyListGroup?: boolean | undefined;
};
proposedSavedGroup: {
id: string;
type: "condition" | "list";
dateCreated: string;
dateUpdated: string;
name: string;
/** The userId of the owner (or raw owner name/email for legacy records) */
owner?: string | undefined;
ownerEmail?: string | undefined;
/** When type = 'condition', this is the JSON-encoded condition for the group */
condition?: string | undefined;
/** When type = 'list', this is the attribute key the group is based on */
attributeKey?: string | undefined;
/** When type = 'list', this is the list of values for the attribute key */
values?: string[] | undefined;
description?: string | undefined;
projects?: string[] | undefined;
archived?: boolean | undefined;
useEmptyListGroup?: boolean | undefined;
};
proposedChanges: {
op: string;
path: string;
}[];
};
};
user: {
type: "dashboard";
id: string;
email: string;
name: string;
} | {
type: "api_key";
apiKey: string;
id?: string | undefined;
name?: string | undefined;
email?: string | undefined;
} | {
type: "system";
subtype?: string | undefined;
id?: string | undefined;
} | null;
tags: string[];
/** The environments affected by the change described by this event. For live-state events (e.g. `feature.updated`) these are the environments whose effective configuration actually changed; for draft lifecycle events (`*.revision.*`) they are the environments the proposed changes would affect. Webhook environment filters match against this field. An empty array means the event has no environment-scoped impact (it will only be delivered to subscriptions without an environment filter). */
environments: string[];
containsSecrets: boolean;
}
```
### savedGroup.revision.rebased
Triggered when a draft revision is rebased onto the latest live state
```typescript theme={null}
{
event: "savedGroup.revision.rebased";
object: "savedGroup";
api_version: string;
created: number;
data: {
object: {
id: string;
version?: number | undefined;
title?: string | undefined;
status: "draft" | "pending-review" | "approved" | "changes-requested" | "merged" | "discarded";
authorId: string;
authorEmail?: string | undefined;
contributors?: string[] | undefined;
revertedFrom?: string | undefined;
reviews: {
id: string;
userId: string;
decision: "approve" | "request-changes" | "comment";
comment?: string | undefined;
dateCreated: string;
}[];
activityLog: {
id: string;
userId: string;
action: string;
dateCreated: string;
}[];
resolution?: {
action: "merged" | "discarded";
userId: string;
dateCreated: string;
} | undefined;
dateCreated: string;
dateUpdated: string;
baseSavedGroup: {
id: string;
type: "condition" | "list";
dateCreated: string;
dateUpdated: string;
name: string;
/** The userId of the owner (or raw owner name/email for legacy records) */
owner?: string | undefined;
ownerEmail?: string | undefined;
/** When type = 'condition', this is the JSON-encoded condition for the group */
condition?: string | undefined;
/** When type = 'list', this is the attribute key the group is based on */
attributeKey?: string | undefined;
/** When type = 'list', this is the list of values for the attribute key */
values?: string[] | undefined;
description?: string | undefined;
projects?: string[] | undefined;
archived?: boolean | undefined;
useEmptyListGroup?: boolean | undefined;
};
proposedSavedGroup: {
id: string;
type: "condition" | "list";
dateCreated: string;
dateUpdated: string;
name: string;
/** The userId of the owner (or raw owner name/email for legacy records) */
owner?: string | undefined;
ownerEmail?: string | undefined;
/** When type = 'condition', this is the JSON-encoded condition for the group */
condition?: string | undefined;
/** When type = 'list', this is the attribute key the group is based on */
attributeKey?: string | undefined;
/** When type = 'list', this is the list of values for the attribute key */
values?: string[] | undefined;
description?: string | undefined;
projects?: string[] | undefined;
archived?: boolean | undefined;
useEmptyListGroup?: boolean | undefined;
};
proposedChanges: {
op: string;
path: string;
}[];
};
};
user: {
type: "dashboard";
id: string;
email: string;
name: string;
} | {
type: "api_key";
apiKey: string;
id?: string | undefined;
name?: string | undefined;
email?: string | undefined;
} | {
type: "system";
subtype?: string | undefined;
id?: string | undefined;
} | null;
tags: string[];
/** The environments affected by the change described by this event. For live-state events (e.g. `feature.updated`) these are the environments whose effective configuration actually changed; for draft lifecycle events (`*.revision.*`) they are the environments the proposed changes would affect. Webhook environment filters match against this field. An empty array means the event has no environment-scoped impact (it will only be delivered to subscriptions without an environment filter). */
environments: string[];
containsSecrets: boolean;
}
```
### savedGroup.revision.published
Triggered when a draft revision is published. Overlaps with `savedGroup.updated` but provides revision-specific context.
```typescript theme={null}
{
event: "savedGroup.revision.published";
object: "savedGroup";
api_version: string;
created: number;
data: {
object: {
id: string;
version?: number | undefined;
title?: string | undefined;
status: "draft" | "pending-review" | "approved" | "changes-requested" | "merged" | "discarded";
authorId: string;
authorEmail?: string | undefined;
contributors?: string[] | undefined;
revertedFrom?: string | undefined;
reviews: {
id: string;
userId: string;
decision: "approve" | "request-changes" | "comment";
comment?: string | undefined;
dateCreated: string;
}[];
activityLog: {
id: string;
userId: string;
action: string;
dateCreated: string;
}[];
resolution?: {
action: "merged" | "discarded";
userId: string;
dateCreated: string;
} | undefined;
dateCreated: string;
dateUpdated: string;
baseSavedGroup: {
id: string;
type: "condition" | "list";
dateCreated: string;
dateUpdated: string;
name: string;
/** The userId of the owner (or raw owner name/email for legacy records) */
owner?: string | undefined;
ownerEmail?: string | undefined;
/** When type = 'condition', this is the JSON-encoded condition for the group */
condition?: string | undefined;
/** When type = 'list', this is the attribute key the group is based on */
attributeKey?: string | undefined;
/** When type = 'list', this is the list of values for the attribute key */
values?: string[] | undefined;
description?: string | undefined;
projects?: string[] | undefined;
archived?: boolean | undefined;
useEmptyListGroup?: boolean | undefined;
};
proposedSavedGroup: {
id: string;
type: "condition" | "list";
dateCreated: string;
dateUpdated: string;
name: string;
/** The userId of the owner (or raw owner name/email for legacy records) */
owner?: string | undefined;
ownerEmail?: string | undefined;
/** When type = 'condition', this is the JSON-encoded condition for the group */
condition?: string | undefined;
/** When type = 'list', this is the attribute key the group is based on */
attributeKey?: string | undefined;
/** When type = 'list', this is the list of values for the attribute key */
values?: string[] | undefined;
description?: string | undefined;
projects?: string[] | undefined;
archived?: boolean | undefined;
useEmptyListGroup?: boolean | undefined;
};
proposedChanges: {
op: string;
path: string;
}[];
bulkPublishId?: string | undefined;
};
};
user: {
type: "dashboard";
id: string;
email: string;
name: string;
} | {
type: "api_key";
apiKey: string;
id?: string | undefined;
name?: string | undefined;
email?: string | undefined;
} | {
type: "system";
subtype?: string | undefined;
id?: string | undefined;
} | null;
tags: string[];
/** The environments affected by the change described by this event. For live-state events (e.g. `feature.updated`) these are the environments whose effective configuration actually changed; for draft lifecycle events (`*.revision.*`) they are the environments the proposed changes would affect. Webhook environment filters match against this field. An empty array means the event has no environment-scoped impact (it will only be delivered to subscriptions without an environment filter). */
environments: string[];
containsSecrets: boolean;
}
```
### savedGroup.revision.reverted
Triggered when a saved group is reverted to a previous published revision
```typescript theme={null}
{
event: "savedGroup.revision.reverted";
object: "savedGroup";
api_version: string;
created: number;
data: {
object: {
id: string;
version?: number | undefined;
title?: string | undefined;
status: "draft" | "pending-review" | "approved" | "changes-requested" | "merged" | "discarded";
authorId: string;
authorEmail?: string | undefined;
contributors?: string[] | undefined;
revertedFrom?: string | undefined;
reviews: {
id: string;
userId: string;
decision: "approve" | "request-changes" | "comment";
comment?: string | undefined;
dateCreated: string;
}[];
activityLog: {
id: string;
userId: string;
action: string;
dateCreated: string;
}[];
resolution?: {
action: "merged" | "discarded";
userId: string;
dateCreated: string;
} | undefined;
dateCreated: string;
dateUpdated: string;
baseSavedGroup: {
id: string;
type: "condition" | "list";
dateCreated: string;
dateUpdated: string;
name: string;
/** The userId of the owner (or raw owner name/email for legacy records) */
owner?: string | undefined;
ownerEmail?: string | undefined;
/** When type = 'condition', this is the JSON-encoded condition for the group */
condition?: string | undefined;
/** When type = 'list', this is the attribute key the group is based on */
attributeKey?: string | undefined;
/** When type = 'list', this is the list of values for the attribute key */
values?: string[] | undefined;
description?: string | undefined;
projects?: string[] | undefined;
archived?: boolean | undefined;
useEmptyListGroup?: boolean | undefined;
};
proposedSavedGroup: {
id: string;
type: "condition" | "list";
dateCreated: string;
dateUpdated: string;
name: string;
/** The userId of the owner (or raw owner name/email for legacy records) */
owner?: string | undefined;
ownerEmail?: string | undefined;
/** When type = 'condition', this is the JSON-encoded condition for the group */
condition?: string | undefined;
/** When type = 'list', this is the attribute key the group is based on */
attributeKey?: string | undefined;
/** When type = 'list', this is the list of values for the attribute key */
values?: string[] | undefined;
description?: string | undefined;
projects?: string[] | undefined;
archived?: boolean | undefined;
useEmptyListGroup?: boolean | undefined;
};
proposedChanges: {
op: string;
path: string;
}[];
revertedToVersion?: number | undefined;
bulkPublishId?: string | undefined;
};
};
user: {
type: "dashboard";
id: string;
email: string;
name: string;
} | {
type: "api_key";
apiKey: string;
id?: string | undefined;
name?: string | undefined;
email?: string | undefined;
} | {
type: "system";
subtype?: string | undefined;
id?: string | undefined;
} | null;
tags: string[];
/** The environments affected by the change described by this event. For live-state events (e.g. `feature.updated`) these are the environments whose effective configuration actually changed; for draft lifecycle events (`*.revision.*`) they are the environments the proposed changes would affect. Webhook environment filters match against this field. An empty array means the event has no environment-scoped impact (it will only be delivered to subscriptions without an environment filter). */
environments: string[];
containsSecrets: boolean;
}
```
### savedGroup.revision.reopened
Triggered when a discarded revision is reopened
```typescript theme={null}
{
event: "savedGroup.revision.reopened";
object: "savedGroup";
api_version: string;
created: number;
data: {
object: {
id: string;
version?: number | undefined;
title?: string | undefined;
status: "draft" | "pending-review" | "approved" | "changes-requested" | "merged" | "discarded";
authorId: string;
authorEmail?: string | undefined;
contributors?: string[] | undefined;
revertedFrom?: string | undefined;
reviews: {
id: string;
userId: string;
decision: "approve" | "request-changes" | "comment";
comment?: string | undefined;
dateCreated: string;
}[];
activityLog: {
id: string;
userId: string;
action: string;
dateCreated: string;
}[];
resolution?: {
action: "merged" | "discarded";
userId: string;
dateCreated: string;
} | undefined;
dateCreated: string;
dateUpdated: string;
baseSavedGroup: {
id: string;
type: "condition" | "list";
dateCreated: string;
dateUpdated: string;
name: string;
/** The userId of the owner (or raw owner name/email for legacy records) */
owner?: string | undefined;
ownerEmail?: string | undefined;
/** When type = 'condition', this is the JSON-encoded condition for the group */
condition?: string | undefined;
/** When type = 'list', this is the attribute key the group is based on */
attributeKey?: string | undefined;
/** When type = 'list', this is the list of values for the attribute key */
values?: string[] | undefined;
description?: string | undefined;
projects?: string[] | undefined;
archived?: boolean | undefined;
useEmptyListGroup?: boolean | undefined;
};
proposedSavedGroup: {
id: string;
type: "condition" | "list";
dateCreated: string;
dateUpdated: string;
name: string;
/** The userId of the owner (or raw owner name/email for legacy records) */
owner?: string | undefined;
ownerEmail?: string | undefined;
/** When type = 'condition', this is the JSON-encoded condition for the group */
condition?: string | undefined;
/** When type = 'list', this is the attribute key the group is based on */
attributeKey?: string | undefined;
/** When type = 'list', this is the list of values for the attribute key */
values?: string[] | undefined;
description?: string | undefined;
projects?: string[] | undefined;
archived?: boolean | undefined;
useEmptyListGroup?: boolean | undefined;
};
proposedChanges: {
op: string;
path: string;
}[];
};
};
user: {
type: "dashboard";
id: string;
email: string;
name: string;
} | {
type: "api_key";
apiKey: string;
id?: string | undefined;
name?: string | undefined;
email?: string | undefined;
} | {
type: "system";
subtype?: string | undefined;
id?: string | undefined;
} | null;
tags: string[];
/** The environments affected by the change described by this event. For live-state events (e.g. `feature.updated`) these are the environments whose effective configuration actually changed; for draft lifecycle events (`*.revision.*`) they are the environments the proposed changes would affect. Webhook environment filters match against this field. An empty array means the event has no environment-scoped impact (it will only be delivered to subscriptions without an environment filter). */
environments: string[];
containsSecrets: boolean;
}
```
### user.login
Triggered when a user logs in
```typescript theme={null}
{
event: "user.login";
object: "user";
api_version: string;
created: number;
data: {
object: {
email: string;
id: string;
name: string;
ip: string;
userAgent: string;
os: string;
device: string;
};
};
user: {
type: "dashboard";
id: string;
email: string;
name: string;
} | {
type: "api_key";
apiKey: string;
id?: string | undefined;
name?: string | undefined;
email?: string | undefined;
} | {
type: "system";
subtype?: string | undefined;
id?: string | undefined;
} | null;
tags: string[];
/** The environments affected by the change described by this event. For live-state events (e.g. `feature.updated`) these are the environments whose effective configuration actually changed; for draft lifecycle events (`*.revision.*`) they are the environments the proposed changes would affect. Webhook environment filters match against this field. An empty array means the event has no environment-scoped impact (it will only be delivered to subscriptions without an environment filter). */
environments: string[];
containsSecrets: boolean;
}
```