管理 API | OpenAI API

管理 API 允许您自动化组织管理工作流，例如用户邀请、审计日志审查、项目管理、API 密钥管理、支出提醒、数据保留和速率限制操作。将它们用于后台办公自动化、安全工作流以及应在控制面板之外运行的操作工具。

有关端点的详细信息，请参阅管理 API 参考，包括 Admin API 密钥, 邀请, 用户, 项目，且审计日志.

结合 SDK 使用 Admin API 密钥

To access these endpoints, 创建 Admin API 密钥。Admin API 密钥不能用于非管理类端点。

以下 SDK 版本中添加了对管理 API 的支持，您可能需要更新您的 SDK 版本：

Node: 6.36.0
Python: 2.34.0
Go: 3.34.0
Ruby: 0.61.0
Java: 4.34.0

设置 OPENAI_ADMIN_KEY，然后初始化适用于您所用语言的 SDK。

使用 Admin API 密钥设置 SDK

javascript

1
2
3
4
5
import OpenAI from "openai";

const client = new OpenAI({
  adminAPIKey: process.env.OPENAI_ADMIN_KEY,
});

1
2
3
4
5
6
import os
from openai import OpenAI

client = OpenAI(
    admin_api_key=os.environ["OPENAI_ADMIN_KEY"],
)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
package main

import (
    "os"

    "github.com/openai/openai-go/v3"
    "github.com/openai/openai-go/v3/option"
)

func main() {
    client := openai.NewClient(
        option.WithAdminAPIKey(os.Getenv("OPENAI_ADMIN_KEY")),
    )

    _ = client
}

1
2
3
4
5
require "openai"

openai = OpenAI::Client.new(
  admin_api_key: ENV.fetch("OPENAI_ADMIN_KEY")
)

1
2
3
4
5
6
import com.openai.client.OpenAIClient;
import com.openai.client.okhttp.OpenAIOkHttpClient;

OpenAIClient client = OpenAIOkHttpClient.builder()
    .adminApiKey(System.getenv("OPENAI_ADMIN_KEY"))
    .build();

限制项目的模型访问

使用项目模型权限为项目设置允许列表或拒绝列表。将 mode to allow_list 设置为仅允许列出的模型，或将 mode to deny_list 设置为阻止列出的模型，同时允许其他可用模型。模型 ID 必须对该组织可见，包括可见的微调模型快照。

设置项目模型允许列表/拒绝列表

javascript

1
2
3
4
5
6
7
const modelPermissions =
  await client.admin.organization.projects.modelPermissions.update("proj_abc", {
    mode: "allow_list",
    model_ids: ["gpt-4.1", "o3"],
  });

console.log(modelPermissions.mode);

1
2
3
4
5
6
7
model_permissions = client.admin.organization.projects.model_permissions.update(
    "proj_abc",
    mode="allow_list",
    model_ids=["gpt-4.1", "o3"],
)

print(model_permissions.mode)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
ctx := context.Background()

modelPermissions, err := client.Admin.Organization.Projects.ModelPermissions.Update(
    ctx,
    "proj_abc",
    openai.AdminOrganizationProjectModelPermissionUpdateParams{
        Mode:     openai.AdminOrganizationProjectModelPermissionUpdateParamsModeAllowList,
        ModelIDs: []string{"gpt-4.1", "o3"},
    },
)
if err != nil {
    panic(err)
}

println(modelPermissions.Mode)

1
2
3
4
5
6
7
model_permissions = openai.admin.organization.projects.model_permissions.update(
  "proj_abc",
  mode: :allow_list,
  model_ids: ["gpt-4.1", "o3"]
)

puts(model_permissions.mode)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
import com.openai.models.admin.organization.projects.modelpermissions.ModelPermissionUpdateParams;
import com.openai.models.admin.organization.projects.modelpermissions.ProjectModelPermissions;
import java.util.List;

ProjectModelPermissions modelPermissions = client.admin()
    .organization()
    .projects()
    .modelPermissions()
    .update(
        "proj_abc",
        ModelPermissionUpdateParams.builder()
            .mode(ModelPermissionUpdateParams.Mode.ALLOW_LIST)
            .modelIds(List.of("gpt-4.1", "o3"))
            .build()
    );

System.out.println(modelPermissions.mode());

管理支出限制提醒

使用项目支出提醒功能，在项目支出达到阈值时通知您的团队。阈值金额以美分为单位指定。

创建项目支出限制提醒

javascript

1
2
3
4
5
6
7
8
9
10
11
12
13
const spendAlert =
  await client.admin.organization.projects.spendAlerts.create("proj_abc", {
    currency: "USD",
    interval: "month",
    notification_channel: {
      recipients: ["billing@example.com"],
      type: "email",
      subject_prefix: "[OpenAI spend]",
    },
    threshold_amount: 50000,
  });

console.log(spendAlert.id);

1
2
3
4
5
6
7
8
9
10
11
12
13
spend_alert = client.admin.organization.projects.spend_alerts.create(
    "proj_abc",
    currency="USD",
    interval="month",
    notification_channel={
        "recipients": ["billing@example.com"],
        "type": "email",
        "subject_prefix": "[OpenAI spend]",
    },
    threshold_amount=50000,
)

print(spend_alert.id)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
ctx := context.Background()

spendAlert, err := client.Admin.Organization.Projects.SpendAlerts.New(
    ctx,
    "proj_abc",
    openai.AdminOrganizationProjectSpendAlertNewParams{
        Currency: openai.AdminOrganizationProjectSpendAlertNewParamsCurrencyUsd,
        Interval: openai.AdminOrganizationProjectSpendAlertNewParamsIntervalMonth,
        NotificationChannel: openai.AdminOrganizationProjectSpendAlertNewParamsNotificationChannel{
            Recipients:    []string{"billing@example.com"},
            Type:          "email",
            SubjectPrefix: openai.String("[OpenAI spend]"),
        },
        ThresholdAmount: 50000,
    },
)
if err != nil {
    panic(err)
}

println(spendAlert.ID)

1
2
3
4
5
6
7
8
9
10
11
12
13
spend_alert = openai.admin.organization.projects.spend_alerts.create(
  "proj_abc",
  currency: :USD,
  interval: :month,
  notification_channel: {
    recipients: ["billing@example.com"],
    type: :email,
    subject_prefix: "[OpenAI spend]"
  },
  threshold_amount: 50_000
)

puts(spend_alert.id)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
import com.openai.models.admin.organization.projects.spendalerts.ProjectSpendAlert;
import com.openai.models.admin.organization.projects.spendalerts.SpendAlertCreateParams;

ProjectSpendAlert spendAlert = client.admin()
    .organization()
    .projects()
    .spendAlerts()
    .create(
        "proj_abc",
        SpendAlertCreateParams.builder()
            .currency(SpendAlertCreateParams.Currency.USD)
            .interval(SpendAlertCreateParams.Interval.MONTH)
            .notificationChannel(
                SpendAlertCreateParams.NotificationChannel.builder()
                    .addRecipient("billing@example.com")
                    .subjectPrefix("[OpenAI spend]")
                    .build()
            )
            .thresholdAmount(50000L)
            .build()
    );

System.out.println(spendAlert.id());

管理数据保留

使用项目数据保留控制功能，为项目覆盖或继承组织的数据保留策略。将 retention_type to organization_default 设置为继承组织设置。

设置项目数据保留

javascript

1
2
3
4
5
6
const dataRetention =
  await client.admin.organization.projects.dataRetention.update("proj_abc", {
    retention_type: "organization_default",
  });

console.log(dataRetention.type);

1
2
3
4
5
6
data_retention = client.admin.organization.projects.data_retention.update(
    "proj_abc",
    retention_type="organization_default",
)

print(data_retention.type)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
ctx := context.Background()

dataRetention, err := client.Admin.Organization.Projects.DataRetention.Update(
    ctx,
    "proj_abc",
    openai.AdminOrganizationProjectDataRetentionUpdateParams{
        RetentionType: openai.AdminOrganizationProjectDataRetentionUpdateParamsRetentionTypeOrganizationDefault,
    },
)
if err != nil {
    panic(err)
}

println(dataRetention.Type)

1
2
3
4
5
6
data_retention = openai.admin.organization.projects.data_retention.update(
  "proj_abc",
  retention_type: :organization_default
)

puts(data_retention.type)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
import com.openai.models.admin.organization.projects.dataretention.DataRetentionUpdateParams;
import com.openai.models.admin.organization.projects.dataretention.ProjectDataRetention;

ProjectDataRetention dataRetention = client.admin()
    .organization()
    .projects()
    .dataRetention()
    .update(
        "proj_abc",
        DataRetentionUpdateParams.builder()
            .retentionType(DataRetentionUpdateParams.RetentionType.ORGANIZATION_DEFAULT)
            .build()
    );

System.out.println(dataRetention.type());

通过电子邮件邀请用户

使用邀请 (Invites) 端点向电子邮件地址发送组织邀请。

通过电子邮件邀请用户

javascript

1
2
3
4
5
6
const invite = await client.admin.organization.invites.create({
  email: "user@example.com",
  role: "reader",
});

console.log(invite.id);

1
2
3
4
5
6
invite = client.admin.organization.invites.create(
    email="user@example.com",
    role="reader",
)

print(invite.id)

1
2
3
4
5
6
7
8
9
10
11
ctx := context.Background()

invite, err := client.Admin.Organization.Invites.New(ctx, openai.AdminOrganizationInviteNewParams{
    Email: "user@example.com",
    Role:  openai.AdminOrganizationInviteNewParamsRoleReader,
})
if err != nil {
    panic(err)
}

println(invite.ID)

1
2
3
4
5
6
invite = openai.admin.organization.invites.create(
  email: "user@example.com",
  role: :reader
)

puts(invite.id)

1
2
3
4
5
6
7
8
9
10
11
import com.openai.models.admin.organization.invites.Invite;
import com.openai.models.admin.organization.invites.InviteCreateParams;

Invite invite = client.admin().organization().invites().create(
    InviteCreateParams.builder()
        .email("user@example.com")
        .role(InviteCreateParams.Role.READER)
        .build()
);

System.out.println(invite.id());

检索审计日志

使用审计日志 (Audit Logs) 端点列出组织最近的用户操作和配置更改。

检索审计日志

javascript

1
2
3
4
5
const auditLogs = await client.admin.organization.auditLogs.list({
  limit: 10,
});

console.log(auditLogs.data);

1
2
3
4
audit_logs = client.admin.organization.audit_logs.list(limit=10)

for audit_log in audit_logs.data:
    print(audit_log.id)

1
2
3
4
5
6
7
8
9
10
11
12
ctx := context.Background()

auditLogs, err := client.Admin.Organization.AuditLogs.List(ctx, openai.AdminOrganizationAuditLogListParams{
    Limit: openai.Int(10),
})
if err != nil {
    panic(err)
}

for _, auditLog := range auditLogs.Data {
    println(auditLog.ID)
}

1
2
3
4
5
audit_logs = openai.admin.organization.audit_logs.list(limit: 10)

audit_logs.data.each do |audit_log|
  puts(audit_log.id)
end

1
2
3
4
5
6
7
8
9
import com.openai.models.admin.organization.auditlogs.AuditLogListParams;

var page = client.admin().organization().auditLogs().list(
    AuditLogListParams.builder()
        .limit(10L)
        .build()
);

page.data().forEach(auditLog -> System.out.println(auditLog.id()));

推荐

入门

核心概念

Apps SDK

工具

运行与扩展

评估

实时与音频

模型优化

专业模型

正式上线

旧版 API

资源

入门指南

使用 Codex

配置

管理

自动化

学习

发布

核心概念

规划

构建

部署

转化应用

指南

资源

指南

文件上传

API

衡量

广告主 API

API 参考

最新

主题

主题

贡献

分类

主题

项目

活动

结合 SDK 使用 Admin API 密钥

限制项目的模型访问

管理支出限制提醒

管理数据保留

通过电子邮件邀请用户

检索审计日志