管理 API | OpenAI API

管理 API（Admin APIs）允许您自动化组织管理工作流程，例如用户邀请、审计日志查看、项目管理、API 密钥管理、支出提醒、数据保留和速率限制操作。使用它们可以实现后台自动化、安全工作流程以及需要在仪表板之外运行的操作工具。

有关端点详情，请参阅管理 API 参考文档，包括管理 API 密钥、邀请、用户、项目以及审计日志。

将管理 API 密钥与 SDK 结合使用

要访问这些端点，请创建管理 API 密钥。管理 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。

使用管理 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();

限制项目的模型访问权限

使用项目模型权限来为项目设置允许列表（allowlist）或拒绝列表（denylist）。将 mode 设置为 allow_list 仅允许列出的模型，或将 mode 设置为 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 设置为 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()));

推荐

开始使用

核心概念

Agents SDK

工具

运行与扩展

评估

实时与音频

模型优化

专用模型

上线

遗留 API

资源

开始使用

使用 Codex

配置

管理

自动化

学习

发布版本

核心概念

规划

构建

部署

转化类应用

指南

资源

指南

文件上传

API

衡量

广告主 API

API 参考

最近

主题

主题

贡献

分类

主题

项目

活动

将管理 API 密钥与 SDK 结合使用

限制项目的模型访问权限

管理支出限额提醒

管理数据保留

通过电子邮件邀请用户

检索审计日志