# Experiments ## Operations ### `posthog.experimentsList` - **HTTP**: `GET /api/projects/{project_id}/experiments/` - **What it does**: List experiments for the current project. Supports filtering by status and archival state. - **OpenAPI operationId**: `experiments_list` - **Path params**: None - **Query params**: `archived`, `created_by_id`, `event`, `feature_flag_id`, `limit`, `offset`, `order`, `prompt_name`, `search`, `status` - **Response codes**: `200` - **Transport options**: None - **TypeScript**: [Client interface](../types.ts) **Inputs** - Client input type: `{ [key: string]: unknown }` - Client transport options: None **Outputs** - Client return type: `{ count: number; next?: string | null; previous?: string | null; results: ({ id: number; name: string; description?: string | null; start_date?: string | null; end_date?: string | null; feature_flag_key: string; feature...` - OpenAPI response codes: `200` ```ts import posthog from "@utdk/posthog"; type ExperimentsListInput = Parameters extends [infer T, ...unknown[]] ? T : undefined; type ExperimentsListOutput = Awaited>; const result: ExperimentsListOutput = await posthog.experimentsList(); // Result shape (from schema): { count: number; next?: string | null; previous?: string | null; results: ({ id: number; name: string; description?: string | null; start_date?: string | null; end_date?: string | null; feature_flag_key: string; feature... ``` ### `posthog.experimentsCreate` - **HTTP**: `POST /api/projects/{project_id}/experiments/` - **What it does**: Create a new experiment in draft status with optional metrics. - **OpenAPI operationId**: `experiments_create` - **Path params**: None - **Query params**: None - **Response codes**: `201` - **Transport options**: None - **TypeScript**: [Client interface](../types.ts) **Inputs** - Client input type: `{ [key: string]: unknown }` - Client transport options: None **Outputs** - Client return type: `{ id: number; name: string; description?: string | null; start_date?: string | null; end_date?: string | null; feature_flag_key: string; feature_flag: { id: number; team_id: number; name?: string; key: string; filters?:...` - OpenAPI response codes: `201` ```ts import posthog from "@utdk/posthog"; type ExperimentsCreateInput = Parameters extends [infer T, ...unknown[]] ? T : undefined; type ExperimentsCreateOutput = Awaited>; const result: ExperimentsCreateOutput = await posthog.experimentsCreate(); // Result shape (from schema): { id: number; name: string; description?: string | null; start_date?: string | null; end_date?: string | null; feature_flag_key: string; feature_flag: { id: number; team_id: number; name?: string; key: string; filters?:... ``` ### `posthog.experimentsDestroy` - **HTTP**: `DELETE /api/projects/{project_id}/experiments/{id}/` - **What it does**: Hard delete of this model is not allowed. Use a patch API call to set "deleted" to true - **OpenAPI operationId**: `experiments_destroy` - **Path params**: `id` - **Query params**: None - **Response codes**: `405` - **Transport options**: None - **TypeScript**: [Client interface](../types.ts) **Inputs** - Client input type: `{ [key: string]: unknown }` - Client transport options: None **Outputs** - Client return type: `unknown` - OpenAPI response codes: `405` ```ts import posthog from "@utdk/posthog"; type ExperimentsDestroyInput = Parameters extends [infer T, ...unknown[]] ? T : undefined; type ExperimentsDestroyOutput = Awaited>; const result: ExperimentsDestroyOutput = await posthog.experimentsDestroy(); // Result shape (from schema): unknown ``` ### `posthog.experimentsRetrieve` - **HTTP**: `GET /api/projects/{project_id}/experiments/{id}/` - **What it does**: Retrieve a single experiment by ID, including its current status, metrics, feature flag, and results metadata. - **OpenAPI operationId**: `experiments_retrieve` - **Path params**: `id` - **Query params**: None - **Response codes**: `200` - **Transport options**: None - **TypeScript**: [Client interface](../types.ts) **Inputs** - Client input type: `{ [key: string]: unknown }` - Client transport options: None **Outputs** - Client return type: `{ id: number; name: string; description?: string | null; start_date?: string | null; end_date?: string | null; feature_flag_key: string; feature_flag: { id: number; team_id: number; name?: string; key: string; filters?:...` - OpenAPI response codes: `200` ```ts import posthog from "@utdk/posthog"; type ExperimentsRetrieveInput = Parameters extends [infer T, ...unknown[]] ? T : undefined; type ExperimentsRetrieveOutput = Awaited>; const result: ExperimentsRetrieveOutput = await posthog.experimentsRetrieve(); // Result shape (from schema): { id: number; name: string; description?: string | null; start_date?: string | null; end_date?: string | null; feature_flag_key: string; feature_flag: { id: number; team_id: number; name?: string; key: string; filters?:... ``` ### `posthog.experimentsPartialUpdate` - **HTTP**: `PATCH /api/projects/{project_id}/experiments/{id}/` - **What it does**: Update an experiment. Use this to modify experiment properties such as name, description, metrics, variants, and configuration. Metrics can be added, changed and removed at any time. Feature-flag config (variants, rollout, payloads) is sent via the feature_flag object. - **OpenAPI operationId**: `experiments_partial_update` - **Path params**: `id` - **Query params**: None - **Response codes**: `200` - **Transport options**: None - **TypeScript**: [Client interface](../types.ts) **Inputs** - Client input type: `{ [key: string]: unknown }` - Client transport options: None **Outputs** - Client return type: `{ id: number; name: string; description?: string | null; start_date?: string | null; end_date?: string | null; feature_flag_key: string; feature_flag: { id: number; team_id: number; name?: string; key: string; filters?:...` - OpenAPI response codes: `200` ```ts import posthog from "@utdk/posthog"; type ExperimentsPartialUpdateInput = Parameters extends [infer T, ...unknown[]] ? T : undefined; type ExperimentsPartialUpdateOutput = Awaited>; const result: ExperimentsPartialUpdateOutput = await posthog.experimentsPartialUpdate(); // Result shape (from schema): { id: number; name: string; description?: string | null; start_date?: string | null; end_date?: string | null; feature_flag_key: string; feature_flag: { id: number; team_id: number; name?: string; key: string; filters?:... ``` ### `posthog.experimentsUpdate` - **HTTP**: `PUT /api/projects/{project_id}/experiments/{id}/` - **What it does**: Mixin for ViewSets to handle approval-gate exceptions raised from decorated serializers. Intercepts ApprovalRequired (409) and PolicyConflict (400) raised by the @approval_gate decorator on serializer methods and converts them into the same responses the viewset path produces (see decorators._result_to_response), so both paths share one contract. - **OpenAPI operationId**: `experiments_update` - **Path params**: `id` - **Query params**: None - **Response codes**: `200` - **Transport options**: None - **TypeScript**: [Client interface](../types.ts) **Inputs** - Client input type: `{ [key: string]: unknown }` - Client transport options: None **Outputs** - Client return type: `{ id: number; name: string; description?: string | null; start_date?: string | null; end_date?: string | null; feature_flag_key: string; feature_flag: { id: number; team_id: number; name?: string; key: string; filters?:...` - OpenAPI response codes: `200` ```ts import posthog from "@utdk/posthog"; type ExperimentsUpdateInput = Parameters extends [infer T, ...unknown[]] ? T : undefined; type ExperimentsUpdateOutput = Awaited>; const result: ExperimentsUpdateOutput = await posthog.experimentsUpdate(); // Result shape (from schema): { id: number; name: string; description?: string | null; start_date?: string | null; end_date?: string | null; feature_flag_key: string; feature_flag: { id: number; team_id: number; name?: string; key: string; filters?:... ``` ### `posthog.experimentsArchiveCreate` - **HTTP**: `POST /api/projects/{project_id}/experiments/{id}/archive/` - **What it does**: Archive an ended experiment. Hides the experiment from the default list view. The experiment can be restored at any time by updating archived=false. When the linked feature flag is still enabled, pass disable_feature_flag=true to also disable and archive it. Returns 400 if the experiment is already archived or has not ended yet. - **OpenAPI operationId**: `experiments_archive_create` - **Path params**: `id` - **Query params**: None - **Response codes**: `200` - **Transport options**: None - **TypeScript**: [Client interface](../types.ts) **Inputs** - Client input type: `{ [key: string]: unknown }` - Client transport options: None **Outputs** - Client return type: `{ id: number; name: string; description?: string | null; start_date?: string | null; end_date?: string | null; feature_flag_key: string; feature_flag: { id: number; team_id: number; name?: string; key: string; filters?:...` - OpenAPI response codes: `200` ```ts import posthog from "@utdk/posthog"; type ExperimentsArchiveCreateInput = Parameters extends [infer T, ...unknown[]] ? T : undefined; type ExperimentsArchiveCreateOutput = Awaited>; const result: ExperimentsArchiveCreateOutput = await posthog.experimentsArchiveCreate(); // Result shape (from schema): { id: number; name: string; description?: string | null; start_date?: string | null; end_date?: string | null; feature_flag_key: string; feature_flag: { id: number; team_id: number; name?: string; key: string; filters?:... ``` ### `posthog.experimentsCopyToProjectCreate` - **HTTP**: `POST /api/projects/{project_id}/experiments/{id}/copy_to_project/` - **What it does**: Copy an experiment into another project in the same organization as a new draft. - **OpenAPI operationId**: `experiments_copy_to_project_create` - **Path params**: `id` - **Query params**: None - **Response codes**: `200` - **Transport options**: None - **TypeScript**: [Client interface](../types.ts) **Inputs** - Client input type: `{ [key: string]: unknown }` - Client transport options: None **Outputs** - Client return type: `{ id: number; name: string; description?: string | null; start_date?: string | null; end_date?: string | null; feature_flag_key: string; feature_flag: { id: number; team_id: number; name?: string; key: string; filters?:...` - OpenAPI response codes: `200` ```ts import posthog from "@utdk/posthog"; type ExperimentsCopyToProjectCreateInput = Parameters extends [infer T, ...unknown[]] ? T : undefined; type ExperimentsCopyToProjectCreateOutput = Awaited>; const result: ExperimentsCopyToProjectCreateOutput = await posthog.experimentsCopyToProjectCreate(); // Result shape (from schema): { id: number; name: string; description?: string | null; start_date?: string | null; end_date?: string | null; feature_flag_key: string; feature_flag: { id: number; team_id: number; name?: string; key: string; filters?:... ``` ### `posthog.experimentsCreateExposureCohortForExperimentCreate` - **HTTP**: `POST /api/projects/{project_id}/experiments/{id}/create_exposure_cohort_for_experiment/` - **What it does**: Mixin for ViewSets to handle approval-gate exceptions raised from decorated serializers. Intercepts ApprovalRequired (409) and PolicyConflict (400) raised by the @approval_gate decorator on serializer methods and converts them into the same responses the viewset path produces (see decorators._result_to_response), so both paths share one contract. - **OpenAPI operationId**: `experiments_create_exposure_cohort_for_experiment_create` - **Path params**: `id` - **Query params**: None - **Response codes**: `200` - **Transport options**: None - **TypeScript**: [Client interface](../types.ts) **Inputs** - Client input type: `{ [key: string]: unknown }` - Client transport options: None **Outputs** - Client return type: `unknown` - OpenAPI response codes: `200` ```ts import posthog from "@utdk/posthog"; type ExperimentsCreateExposureCohortForExperimentCreateInput = Parameters extends [infer T, ...unknown[]] ? T : undefined; type ExperimentsCreateExposureCohortForExperimentCreateOutput = Awaited>; const result: ExperimentsCreateExposureCohortForExperimentCreateOutput = await posthog.experimentsCreateExposureCohortForExperimentCreate(); // Result shape (from schema): unknown ``` ### `posthog.experimentsDuplicateCreate` - **HTTP**: `POST /api/projects/{project_id}/experiments/{id}/duplicate/` - **What it does**: Mixin for ViewSets to handle approval-gate exceptions raised from decorated serializers. Intercepts ApprovalRequired (409) and PolicyConflict (400) raised by the @approval_gate decorator on serializer methods and converts them into the same responses the viewset path produces (see decorators._result_to_response), so both paths share one contract. - **OpenAPI operationId**: `experiments_duplicate_create` - **Path params**: `id` - **Query params**: None - **Response codes**: `200` - **Transport options**: None - **TypeScript**: [Client interface](../types.ts) **Inputs** - Client input type: `{ [key: string]: unknown }` - Client transport options: None **Outputs** - Client return type: `unknown` - OpenAPI response codes: `200` ```ts import posthog from "@utdk/posthog"; type ExperimentsDuplicateCreateInput = Parameters extends [infer T, ...unknown[]] ? T : undefined; type ExperimentsDuplicateCreateOutput = Awaited>; const result: ExperimentsDuplicateCreateOutput = await posthog.experimentsDuplicateCreate(); // Result shape (from schema): unknown ``` ### `posthog.experimentsEndCreate` - **HTTP**: `POST /api/projects/{project_id}/experiments/{id}/end/` - **What it does**: End a running experiment without shipping a variant. Sets end_date to now and marks the experiment as stopped. The feature flag is NOT modified — users continue to see their assigned variants and exposure events ($feature_flag_called) continue to be recorded. However, only data up to end_date is included in experiment results. Use this when: - You want to freeze the results window without changing which variant users see. - A variant was already shipped manually via the feature flag UI and the experiment just needs to be marked complete. The end_date can be adjusted after ending via PATCH if it needs to be backdated (e.g. to match when the flag was actually paused). Other options: - Use ship_variant to end the experiment AND roll out a single variant to 100%% of users. - Use pause to deactivate the flag without ending the experiment (stops variant assignment but does not freeze results). Returns 400 if the experiment is not running. - **OpenAPI operationId**: `experiments_end_create` - **Path params**: `id` - **Query params**: None - **Response codes**: `200` - **Transport options**: None - **TypeScript**: [Client interface](../types.ts) **Inputs** - Client input type: `{ [key: string]: unknown }` - Client transport options: None **Outputs** - Client return type: `{ id: number; name: string; description?: string | null; start_date?: string | null; end_date?: string | null; feature_flag_key: string; feature_flag: { id: number; team_id: number; name?: string; key: string; filters?:...` - OpenAPI response codes: `200` ```ts import posthog from "@utdk/posthog"; type ExperimentsEndCreateInput = Parameters extends [infer T, ...unknown[]] ? T : undefined; type ExperimentsEndCreateOutput = Awaited>; const result: ExperimentsEndCreateOutput = await posthog.experimentsEndCreate(); // Result shape (from schema): { id: number; name: string; description?: string | null; start_date?: string | null; end_date?: string | null; feature_flag_key: string; feature_flag: { id: number; team_id: number; name?: string; key: string; filters?:... ``` ### `posthog.experimentsFreezeExposureCreate` - **HTTP**: `POST /api/projects/{project_id}/experiments/{id}/freeze_exposure/` - **What it does**: Freeze exposure on a running experiment while metrics keep flowing. Snapshots the already-exposed users into a static cohort and narrows the linked feature flag so only those users keep matching — new users can no longer enter the experiment. ``end_date`` is left null so long-term metrics (revenue/LTV/renewals/retention) keep accumulating. Enrolled users keep their assigned variant. The serialized status becomes 'exposure_frozen'. Returns 400 if the experiment is not running, exposure is already frozen, the experiment is group-aggregated (group flags cannot be frozen with a person cohort), or the exposed set is too large to snapshot synchronously. - **OpenAPI operationId**: `experiments_freeze_exposure_create` - **Path params**: `id` - **Query params**: None - **Response codes**: `200` - **Transport options**: None - **TypeScript**: [Client interface](../types.ts) **Inputs** - Client input type: `{ [key: string]: unknown }` - Client transport options: None **Outputs** - Client return type: `{ id: number; name: string; description?: string | null; start_date?: string | null; end_date?: string | null; feature_flag_key: string; feature_flag: { id: number; team_id: number; name?: string; key: string; filters?:...` - OpenAPI response codes: `200` ```ts import posthog from "@utdk/posthog"; type ExperimentsFreezeExposureCreateInput = Parameters extends [infer T, ...unknown[]] ? T : undefined; type ExperimentsFreezeExposureCreateOutput = Awaited>; const result: ExperimentsFreezeExposureCreateOutput = await posthog.experimentsFreezeExposureCreate(); // Result shape (from schema): { id: number; name: string; description?: string | null; start_date?: string | null; end_date?: string | null; feature_flag_key: string; feature_flag: { id: number; team_id: number; name?: string; key: string; filters?:... ``` ### `posthog.experimentsLaunchCreate` - **HTTP**: `POST /api/projects/{project_id}/experiments/{id}/launch/` - **What it does**: Launch a draft experiment. Validates the experiment is in draft state, activates its linked feature flag, sets start_date to the current server time, and transitions the experiment to running. Returns 400 if the experiment has already been launched or if the feature flag configuration is invalid (e.g. missing "control" variant or fewer than 2 variants). - **OpenAPI operationId**: `experiments_launch_create` - **Path params**: `id` - **Query params**: None - **Response codes**: `200` - **Transport options**: None - **TypeScript**: [Client interface](../types.ts) **Inputs** - Client input type: `{ [key: string]: unknown }` - Client transport options: None **Outputs** - Client return type: `{ id: number; name: string; description?: string | null; start_date?: string | null; end_date?: string | null; feature_flag_key: string; feature_flag: { id: number; team_id: number; name?: string; key: string; filters?:...` - OpenAPI response codes: `200` ```ts import posthog from "@utdk/posthog"; type ExperimentsLaunchCreateInput = Parameters extends [infer T, ...unknown[]] ? T : undefined; type ExperimentsLaunchCreateOutput = Awaited>; const result: ExperimentsLaunchCreateOutput = await posthog.experimentsLaunchCreate(); // Result shape (from schema): { id: number; name: string; description?: string | null; start_date?: string | null; end_date?: string | null; feature_flag_key: string; feature_flag: { id: number; team_id: number; name?: string; key: string; filters?:... ``` ### `posthog.experimentsMetricsRecalculationCreate` - **HTTP**: `POST /api/projects/{project_id}/experiments/{id}/metrics_recalculation/` - **What it does**: Trigger a batch recalculation of all metrics for this experiment. Returns 201 with the new pending recalculation, or 200 with the active one if a recalculation is already pending or in progress for this experiment. The response payload intentionally does not include the `results` array — at POST time the workflow has just been queued and no per-metric results exist yet. Clients should poll `GET metrics_recalculation/{id}/` for results as the workflow progresses. - **OpenAPI operationId**: `experiments_metrics_recalculation_create` - **Path params**: `id` - **Query params**: None - **Response codes**: `200`, `201` - **Transport options**: None - **TypeScript**: [Client interface](../types.ts) **Inputs** - Client input type: `{ [key: string]: unknown }` - Client transport options: None **Outputs** - Client return type: `{ id: string; experiment_id: number; status: "pending" | "in_progress" | "completed" | "failed"; total_metrics: number; completed_metrics: number; failed_metrics: number; metric_errors: unknown; trigger: "manual" | "col...` - OpenAPI response codes: `200`, `201` ```ts import posthog from "@utdk/posthog"; type ExperimentsMetricsRecalculationCreateInput = Parameters extends [infer T, ...unknown[]] ? T : undefined; type ExperimentsMetricsRecalculationCreateOutput = Awaited>; const result: ExperimentsMetricsRecalculationCreateOutput = await posthog.experimentsMetricsRecalculationCreate(); // Result shape (from schema): { id: string; experiment_id: number; status: "pending" | "in_progress" | "completed" | "failed"; total_metrics: number; completed_metrics: number; failed_metrics: number; metric_errors: unknown; trigger: "manual" | "col... ``` ### `posthog.experimentsMetricsRecalculationRetrieve` - **HTTP**: `GET /api/projects/{project_id}/experiments/{id}/metrics_recalculation/{recalculation_id}/` - **What it does**: Mixin for ViewSets to handle approval-gate exceptions raised from decorated serializers. Intercepts ApprovalRequired (409) and PolicyConflict (400) raised by the @approval_gate decorator on serializer methods and converts them into the same responses the viewset path produces (see decorators._result_to_response), so both paths share one contract. - **OpenAPI operationId**: `experiments_metrics_recalculation_retrieve` - **Path params**: `id`, `recalculation_id` - **Query params**: None - **Response codes**: `200`, `404` - **Transport options**: None - **TypeScript**: [Client interface](../types.ts) **Inputs** - Client input type: `{ [key: string]: unknown }` - Client transport options: None **Outputs** - Client return type: `{ id: string; experiment_id: number; status: "pending" | "in_progress" | "completed" | "failed"; total_metrics: number; completed_metrics: number; failed_metrics: number; metric_errors: unknown; trigger: "manual" | "col...` - OpenAPI response codes: `200`, `404` ```ts import posthog from "@utdk/posthog"; type ExperimentsMetricsRecalculationRetrieveInput = Parameters extends [infer T, ...unknown[]] ? T : undefined; type ExperimentsMetricsRecalculationRetrieveOutput = Awaited>; const result: ExperimentsMetricsRecalculationRetrieveOutput = await posthog.experimentsMetricsRecalculationRetrieve(); // Result shape (from schema): { id: string; experiment_id: number; status: "pending" | "in_progress" | "completed" | "failed"; total_metrics: number; completed_metrics: number; failed_metrics: number; metric_errors: unknown; trigger: "manual" | "col... ``` ### `posthog.experimentsMetricsRecalculationLatestRetrieve` - **HTTP**: `GET /api/projects/{project_id}/experiments/{id}/metrics_recalculation/latest/` - **What it does**: Mixin for ViewSets to handle approval-gate exceptions raised from decorated serializers. Intercepts ApprovalRequired (409) and PolicyConflict (400) raised by the @approval_gate decorator on serializer methods and converts them into the same responses the viewset path produces (see decorators._result_to_response), so both paths share one contract. - **OpenAPI operationId**: `experiments_metrics_recalculation_latest_retrieve` - **Path params**: `id` - **Query params**: None - **Response codes**: `200`, `404` - **Transport options**: None - **TypeScript**: [Client interface](../types.ts) **Inputs** - Client input type: `{ [key: string]: unknown }` - Client transport options: None **Outputs** - Client return type: `{ id: string; experiment_id: number; status: "pending" | "in_progress" | "completed" | "failed"; total_metrics: number; completed_metrics: number; failed_metrics: number; metric_errors: unknown; trigger: "manual" | "col...` - OpenAPI response codes: `200`, `404` ```ts import posthog from "@utdk/posthog"; type ExperimentsMetricsRecalculationLatestRetrieveInput = Parameters extends [infer T, ...unknown[]] ? T : undefined; type ExperimentsMetricsRecalculationLatestRetrieveOutput = Awaited>; const result: ExperimentsMetricsRecalculationLatestRetrieveOutput = await posthog.experimentsMetricsRecalculationLatestRetrieve(); // Result shape (from schema): { id: string; experiment_id: number; status: "pending" | "in_progress" | "completed" | "failed"; total_metrics: number; completed_metrics: number; failed_metrics: number; metric_errors: unknown; trigger: "manual" | "col... ``` ### `posthog.experimentsPauseCreate` - **HTTP**: `POST /api/projects/{project_id}/experiments/{id}/pause/` - **What it does**: Pause a running experiment. Deactivates the linked feature flag so it is no longer returned by the /decide endpoint. Users fall back to the application default (typically the control experience), and no new exposure events are recorded (i.e. $feature_flag_called is not fired). Returns 400 if the experiment is not running or is already paused. - **OpenAPI operationId**: `experiments_pause_create` - **Path params**: `id` - **Query params**: None - **Response codes**: `200` - **Transport options**: None - **TypeScript**: [Client interface](../types.ts) **Inputs** - Client input type: `{ [key: string]: unknown }` - Client transport options: None **Outputs** - Client return type: `{ id: number; name: string; description?: string | null; start_date?: string | null; end_date?: string | null; feature_flag_key: string; feature_flag: { id: number; team_id: number; name?: string; key: string; filters?:...` - OpenAPI response codes: `200` ```ts import posthog from "@utdk/posthog"; type ExperimentsPauseCreateInput = Parameters extends [infer T, ...unknown[]] ? T : undefined; type ExperimentsPauseCreateOutput = Awaited>; const result: ExperimentsPauseCreateOutput = await posthog.experimentsPauseCreate(); // Result shape (from schema): { id: number; name: string; description?: string | null; start_date?: string | null; end_date?: string | null; feature_flag_key: string; feature_flag: { id: number; team_id: number; name?: string; key: string; filters?:... ``` ### `posthog.experimentsRecalculateTimeseriesCreate` - **HTTP**: `POST /api/projects/{project_id}/experiments/{id}/recalculate_timeseries/` - **What it does**: Mixin for ViewSets to handle approval-gate exceptions raised from decorated serializers. Intercepts ApprovalRequired (409) and PolicyConflict (400) raised by the @approval_gate decorator on serializer methods and converts them into the same responses the viewset path produces (see decorators._result_to_response), so both paths share one contract. - **OpenAPI operationId**: `experiments_recalculate_timeseries_create` - **Path params**: `id` - **Query params**: None - **Response codes**: `200` - **Transport options**: None - **TypeScript**: [Client interface](../types.ts) **Inputs** - Client input type: `{ [key: string]: unknown }` - Client transport options: None **Outputs** - Client return type: `unknown` - OpenAPI response codes: `200` ```ts import posthog from "@utdk/posthog"; type ExperimentsRecalculateTimeseriesCreateInput = Parameters extends [infer T, ...unknown[]] ? T : undefined; type ExperimentsRecalculateTimeseriesCreateOutput = Awaited>; const result: ExperimentsRecalculateTimeseriesCreateOutput = await posthog.experimentsRecalculateTimeseriesCreate(); // Result shape (from schema): unknown ``` ### `posthog.experimentsResetCreate` - **HTTP**: `POST /api/projects/{project_id}/experiments/{id}/reset/` - **What it does**: Reset an experiment back to draft state. Clears start/end dates, conclusion, and archived flag. The feature flag is left unchanged — users continue to see their assigned variants. Previously collected events still exist but won't be included in results unless the start date is manually adjusted after re-launch. Returns 400 if the experiment is already in draft state. - **OpenAPI operationId**: `experiments_reset_create` - **Path params**: `id` - **Query params**: None - **Response codes**: `200` - **Transport options**: None - **TypeScript**: [Client interface](../types.ts) **Inputs** - Client input type: `{ [key: string]: unknown }` - Client transport options: None **Outputs** - Client return type: `{ id: number; name: string; description?: string | null; start_date?: string | null; end_date?: string | null; feature_flag_key: string; feature_flag: { id: number; team_id: number; name?: string; key: string; filters?:...` - OpenAPI response codes: `200` ```ts import posthog from "@utdk/posthog"; type ExperimentsResetCreateInput = Parameters extends [infer T, ...unknown[]] ? T : undefined; type ExperimentsResetCreateOutput = Awaited>; const result: ExperimentsResetCreateOutput = await posthog.experimentsResetCreate(); // Result shape (from schema): { id: number; name: string; description?: string | null; start_date?: string | null; end_date?: string | null; feature_flag_key: string; feature_flag: { id: number; team_id: number; name?: string; key: string; filters?:... ``` ### `posthog.experimentsResumeCreate` - **HTTP**: `POST /api/projects/{project_id}/experiments/{id}/resume/` - **What it does**: Resume a paused experiment. Reactivates the linked feature flag so it is returned by /decide again. Users are re-bucketed deterministically into the same variants they had before the pause, and exposure tracking resumes. Returns 400 if the experiment is not running or is not paused. - **OpenAPI operationId**: `experiments_resume_create` - **Path params**: `id` - **Query params**: None - **Response codes**: `200` - **Transport options**: None - **TypeScript**: [Client interface](../types.ts) **Inputs** - Client input type: `{ [key: string]: unknown }` - Client transport options: None **Outputs** - Client return type: `{ id: number; name: string; description?: string | null; start_date?: string | null; end_date?: string | null; feature_flag_key: string; feature_flag: { id: number; team_id: number; name?: string; key: string; filters?:...` - OpenAPI response codes: `200` ```ts import posthog from "@utdk/posthog"; type ExperimentsResumeCreateInput = Parameters extends [infer T, ...unknown[]] ? T : undefined; type ExperimentsResumeCreateOutput = Awaited>; const result: ExperimentsResumeCreateOutput = await posthog.experimentsResumeCreate(); // Result shape (from schema): { id: number; name: string; description?: string | null; start_date?: string | null; end_date?: string | null; feature_flag_key: string; feature_flag: { id: number; team_id: number; name?: string; key: string; filters?:... ``` ### `posthog.experimentsShipVariantCreate` - **HTTP**: `POST /api/projects/{project_id}/experiments/{id}/ship_variant/` - **What it does**: Ship a variant and (optionally) end the experiment. Updates the feature flag so the selected variant gets 100% of the variant distribution. By default, existing release conditions on the flag are preserved untouched — the variant is served only to users who already match them. Pass ``release_to_everyone: true`` to also prepend a catch-all release condition that rolls the variant out to 100% of users (overrides any existing release conditions on the flag). Can be called on both running and stopped experiments. If the experiment is still running, it will also be ended (end_date set and status marked as stopped). If the experiment has already ended, only the flag is rewritten - this supports the "end first, ship later" workflow. If an approval policy requires review before changes on the flag take effect, the API returns 409 with a change_request_id. The experiment is NOT ended until the change request is approved and the user retries. Returns 400 if the experiment is in draft state, the variant_key is not found on the flag, or the experiment has no linked feature flag. - **OpenAPI operationId**: `experiments_ship_variant_create` - **Path params**: `id` - **Query params**: None - **Response codes**: `200` - **Transport options**: None - **TypeScript**: [Client interface](../types.ts) **Inputs** - Client input type: `{ [key: string]: unknown }` - Client transport options: None **Outputs** - Client return type: `{ id: number; name: string; description?: string | null; start_date?: string | null; end_date?: string | null; feature_flag_key: string; feature_flag: { id: number; team_id: number; name?: string; key: string; filters?:...` - OpenAPI response codes: `200` ```ts import posthog from "@utdk/posthog"; type ExperimentsShipVariantCreateInput = Parameters extends [infer T, ...unknown[]] ? T : undefined; type ExperimentsShipVariantCreateOutput = Awaited>; const result: ExperimentsShipVariantCreateOutput = await posthog.experimentsShipVariantCreate(); // Result shape (from schema): { id: number; name: string; description?: string | null; start_date?: string | null; end_date?: string | null; feature_flag_key: string; feature_flag: { id: number; team_id: number; name?: string; key: string; filters?:... ``` ### `posthog.experimentsTimeseriesResultsRetrieve` - **HTTP**: `GET /api/projects/{project_id}/experiments/{id}/timeseries_results/` - **What it does**: Mixin for ViewSets to handle approval-gate exceptions raised from decorated serializers. Intercepts ApprovalRequired (409) and PolicyConflict (400) raised by the @approval_gate decorator on serializer methods and converts them into the same responses the viewset path produces (see decorators._result_to_response), so both paths share one contract. - **OpenAPI operationId**: `experiments_timeseries_results_retrieve` - **Path params**: `id` - **Query params**: `fingerprint`, `metric_uuid` - **Response codes**: `200` - **Transport options**: None - **TypeScript**: [Client interface](../types.ts) **Inputs** - Client input type: `{ [key: string]: unknown }` - Client transport options: None **Outputs** - Client return type: `unknown` - OpenAPI response codes: `200` ```ts import posthog from "@utdk/posthog"; type ExperimentsTimeseriesResultsRetrieveInput = Parameters extends [infer T, ...unknown[]] ? T : undefined; type ExperimentsTimeseriesResultsRetrieveOutput = Awaited>; const result: ExperimentsTimeseriesResultsRetrieveOutput = await posthog.experimentsTimeseriesResultsRetrieve(); // Result shape (from schema): unknown ``` ### `posthog.experimentsUnarchiveCreate` - **HTTP**: `POST /api/projects/{project_id}/experiments/{id}/unarchive/` - **What it does**: Unarchive an archived experiment. Restores the experiment to the default list view. Returns 400 if the experiment is not currently archived. - **OpenAPI operationId**: `experiments_unarchive_create` - **Path params**: `id` - **Query params**: None - **Response codes**: `200` - **Transport options**: None - **TypeScript**: [Client interface](../types.ts) **Inputs** - Client input type: `{ [key: string]: unknown }` - Client transport options: None **Outputs** - Client return type: `{ id: number; name: string; description?: string | null; start_date?: string | null; end_date?: string | null; feature_flag_key: string; feature_flag: { id: number; team_id: number; name?: string; key: string; filters?:...` - OpenAPI response codes: `200` ```ts import posthog from "@utdk/posthog"; type ExperimentsUnarchiveCreateInput = Parameters extends [infer T, ...unknown[]] ? T : undefined; type ExperimentsUnarchiveCreateOutput = Awaited>; const result: ExperimentsUnarchiveCreateOutput = await posthog.experimentsUnarchiveCreate(); // Result shape (from schema): { id: number; name: string; description?: string | null; start_date?: string | null; end_date?: string | null; feature_flag_key: string; feature_flag: { id: number; team_id: number; name?: string; key: string; filters?:... ``` ### `posthog.experimentsUnfreezeExposureCreate` - **HTTP**: `POST /api/projects/{project_id}/experiments/{id}/unfreeze_exposure/` - **What it does**: Reopen enrollment on an exposure-frozen experiment. Removes the snapshot-cohort condition and freeze markers from every release group, restoring the flag's original targeting: new users can enroll again and already-enrolled users keep their assigned variant. The snapshot cohort is soft-deleted. The serialized status returns to 'running'. Returns 400 if the experiment is not running or its exposure is not frozen. - **OpenAPI operationId**: `experiments_unfreeze_exposure_create` - **Path params**: `id` - **Query params**: None - **Response codes**: `200` - **Transport options**: None - **TypeScript**: [Client interface](../types.ts) **Inputs** - Client input type: `{ [key: string]: unknown }` - Client transport options: None **Outputs** - Client return type: `{ id: number; name: string; description?: string | null; start_date?: string | null; end_date?: string | null; feature_flag_key: string; feature_flag: { id: number; team_id: number; name?: string; key: string; filters?:...` - OpenAPI response codes: `200` ```ts import posthog from "@utdk/posthog"; type ExperimentsUnfreezeExposureCreateInput = Parameters extends [infer T, ...unknown[]] ? T : undefined; type ExperimentsUnfreezeExposureCreateOutput = Awaited>; const result: ExperimentsUnfreezeExposureCreateOutput = await posthog.experimentsUnfreezeExposureCreate(); // Result shape (from schema): { id: number; name: string; description?: string | null; start_date?: string | null; end_date?: string | null; feature_flag_key: string; feature_flag: { id: number; team_id: number; name?: string; key: string; filters?:... ``` ### `posthog.experimentsCalculateRunningTimeCreate` - **HTTP**: `POST /api/projects/{project_id}/experiments/calculate_running_time/` - **What it does**: Estimate the recommended sample size and running time for an experiment. Pure statistical calculation — does not read or write any experiment. Pass the metric type, a minimum detectable effect, and either a baseline value or raw baseline statistics. When `exposure_rate_per_day` is provided, the response also includes the estimated running time in days. - **OpenAPI operationId**: `experiments_calculate_running_time_create` - **Path params**: None - **Query params**: None - **Response codes**: `200` - **Transport options**: None - **TypeScript**: [Client interface](../types.ts) **Inputs** - Client input type: `{ [key: string]: unknown }` - Client transport options: None **Outputs** - Client return type: `{ baseline_value: number | null; variance: number | null; recommended_sample_size: number | null; recommended_running_time_days: number | null }` - OpenAPI response codes: `200` ```ts import posthog from "@utdk/posthog"; type ExperimentsCalculateRunningTimeCreateInput = Parameters extends [infer T, ...unknown[]] ? T : undefined; type ExperimentsCalculateRunningTimeCreateOutput = Awaited>; const result: ExperimentsCalculateRunningTimeCreateOutput = await posthog.experimentsCalculateRunningTimeCreate(); // Result shape (from schema): { baseline_value: number | null; variance: number | null; recommended_sample_size: number | null; recommended_running_time_days: number | null } ``` ### `posthog.experimentsCreateFromPromptCreate` - **HTTP**: `POST /api/projects/{project_id}/experiments/create_from_prompt/` - **What it does**: Create an experiment that compares N versions of an LLM prompt using a metric template. The user picks 2+ versions of an existing LLMPrompt and 1+ metric templates (cost / latency / eval_pass_rate). The endpoint builds the matching variants (control + test-N, each named after its prompt version) and attaches one metric per selected template, each scoped to the prompt's $ai_prompt_name. Resulting experiment is in draft state. - **OpenAPI operationId**: `experiments_create_from_prompt_create` - **Path params**: None - **Query params**: None - **Response codes**: `200` - **Transport options**: None - **TypeScript**: [Client interface](../types.ts) **Inputs** - Client input type: `{ [key: string]: unknown }` - Client transport options: None **Outputs** - Client return type: `{ id: number; name: string; description?: string | null; start_date?: string | null; end_date?: string | null; feature_flag_key: string; feature_flag: { id: number; team_id: number; name?: string; key: string; filters?:...` - OpenAPI response codes: `200` ```ts import posthog from "@utdk/posthog"; type ExperimentsCreateFromPromptCreateInput = Parameters extends [infer T, ...unknown[]] ? T : undefined; type ExperimentsCreateFromPromptCreateOutput = Awaited>; const result: ExperimentsCreateFromPromptCreateOutput = await posthog.experimentsCreateFromPromptCreate(); // Result shape (from schema): { id: number; name: string; description?: string | null; start_date?: string | null; end_date?: string | null; feature_flag_key: string; feature_flag: { id: number; team_id: number; name?: string; key: string; filters?:... ``` ### `posthog.experimentsEligibleFeatureFlagsRetrieve` - **HTTP**: `GET /api/projects/{project_id}/experiments/eligible_feature_flags/` - **What it does**: Returns a paginated list of feature flags eligible for use in experiments. Eligible flags must: - Be multivariate with at least 2 variants - Have "control" as the first variant key Query parameters: - search: Filter by flag key or name (case insensitive) - limit: Number of results per page (default: 20) - offset: Pagination offset (default: 0) - active: Filter by active status ("true" or "false") - created_by_id: Filter by creator user ID - order: Sort order field - evaluation_runtime: Filter by evaluation runtime - has_evaluation_contexts: Filter by presence of evaluation contexts ("true" or "false") - **OpenAPI operationId**: `experiments_eligible_feature_flags_retrieve` - **Path params**: None - **Query params**: None - **Response codes**: `200` - **Transport options**: None - **TypeScript**: [Client interface](../types.ts) **Inputs** - Client input type: `{ [key: string]: unknown }` - Client transport options: None **Outputs** - Client return type: `unknown` - OpenAPI response codes: `200` ```ts import posthog from "@utdk/posthog"; type ExperimentsEligibleFeatureFlagsRetrieveInput = Parameters extends [infer T, ...unknown[]] ? T : undefined; type ExperimentsEligibleFeatureFlagsRetrieveOutput = Awaited>; const result: ExperimentsEligibleFeatureFlagsRetrieveOutput = await posthog.experimentsEligibleFeatureFlagsRetrieve(); // Result shape (from schema): unknown ``` ### `posthog.experimentsPromptTemplatesRetrieve` - **HTTP**: `GET /api/projects/{project_id}/experiments/prompt_templates/` - **What it does**: List the LLM metric templates that can be passed to `create_from_prompt`. - **OpenAPI operationId**: `experiments_prompt_templates_retrieve` - **Path params**: None - **Query params**: None - **Response codes**: `200` - **Transport options**: None - **TypeScript**: [Client interface](../types.ts) **Inputs** - Client input type: `{ [key: string]: unknown }` - Client transport options: None **Outputs** - Client return type: `({ key: string; label: string; description: string })[]` - OpenAPI response codes: `200` ```ts import posthog from "@utdk/posthog"; type ExperimentsPromptTemplatesRetrieveInput = Parameters extends [infer T, ...unknown[]] ? T : undefined; type ExperimentsPromptTemplatesRetrieveOutput = Awaited>; const result: ExperimentsPromptTemplatesRetrieveOutput = await posthog.experimentsPromptTemplatesRetrieve(); // Result shape (from schema): ({ key: string; label: string; description: string })[] ``` ### `posthog.experimentsStatsRetrieve` - **HTTP**: `GET /api/projects/{project_id}/experiments/stats/` - **What it does**: Mixin for ViewSets to handle approval-gate exceptions raised from decorated serializers. Intercepts ApprovalRequired (409) and PolicyConflict (400) raised by the @approval_gate decorator on serializer methods and converts them into the same responses the viewset path produces (see decorators._result_to_response), so both paths share one contract. - **OpenAPI operationId**: `experiments_stats_retrieve` - **Path params**: None - **Query params**: None - **Response codes**: `200` - **Transport options**: None - **TypeScript**: [Client interface](../types.ts) **Inputs** - Client input type: `{ [key: string]: unknown }` - Client transport options: None **Outputs** - Client return type: `unknown` - OpenAPI response codes: `200` ```ts import posthog from "@utdk/posthog"; type ExperimentsStatsRetrieveInput = Parameters extends [infer T, ...unknown[]] ? T : undefined; type ExperimentsStatsRetrieveOutput = Awaited>; const result: ExperimentsStatsRetrieveOutput = await posthog.experimentsStatsRetrieve(); // Result shape (from schema): unknown ```