令牌管理 API

接口概述

令牌管理接口让你用程序完成 API Key 的全生命周期管理，不必逐个在控制台点击。最常见的场景是批量发放：给团队成员、给下游客户、给不同项目各发一把 Key，并分别限制能花多少钱、能用哪些模型、用到什么时候。配合定时任务，还能做到每把 Key 每天限额、次日自动恢复。

额度限制

remain_quota 设定这把 Key 最多能消费多少

模型限制

models 设定白名单，调用名单外的模型直接被拒

有效期限制

expired_time 设定到期时间，到点自动失效

只需要建一两把 Key 的话，直接用控制台更快，见如何创建 KEY。本接口面向需要自动化发放、定期轮换、或把 Key 管理接入自有系统的场景。

如何获取个人访问令牌

令牌管理接口用个人访问令牌认证（nap_ 开头），与 API Key 不是一回事。

打开个人访问令牌

访问 api.apiyi.com/account/profile 个人中心，在「账户选项」里点击 个人访问令牌 → 创建令牌

按用途勾选「模型密钥」权限

三项权限相互独立，只勾用得到的：

你要做的事	需要勾选
列出、查询 API Key	模型密钥 · 读取
创建、修改、禁用、删除 API Key	模型密钥 · 写入
获取新建 API Key 的明文（发放给下游）	模型密钥 · 查看密钥

批量发 Key 的脚本三项都要勾；只做用量巡检的脚本勾「读取」即可。

设置到期时间与 IP 白名单

到期时间默认 30 天，建议选久一点。发 Key 的脚本跑在固定 IP 的服务器上时，强烈建议设置 IP 白名单（创建后不能修改，可以先不填调通，再新建一把带白名单的正式令牌）

勾了「写入」和「查看密钥」的令牌能创建出可以调用模型的 API Key，请像保管账号密码一样保管它。个人访问令牌本身不能调用模型，但它能发出可以调用模型的 Key。因此这类令牌务必设置 IP 白名单、存进密钥管理工具而不是写在代码里，不要提交进代码仓库，并在到期前及时换新。

旧系统令牌计划于 2026-11-11 (UTC+8) 停用。 原来在「账号选项 - 系统令牌」生成的 AccessToken 在此之前照常可用，之后会返回 401 ACCESS_TOKEN_LEGACY_RETIRED。平台会视使用情况决定是否延期，建议尽早换成个人访问令牌。换令牌时请同时检查脚本：新版创建接口返回的 key 已打码，取明文要另调一次 POST /api/token/{id}/key，见下文。详见什么是个人访问令牌？

端点一览

所有端点的认证方式相同：Authorization 请求头填个人访问令牌，Bearer 前缀可加可不加。

方法	路径	用途	需要的权限
`GET`	`/api/token/?p=0&page_size=100`	列出本账号所有令牌（`key` 已打码）	读取
`GET`	`/api/token/{id}`	查询单个令牌	读取
`POST`	`/api/token/`	创建令牌（响应里的 `key` 已打码）	写入
`POST`	`/api/token/{id}/key`	获取 Key 明文	查看密钥
`PUT`	`/api/token/`	更新令牌（需传完整对象）	写入
`PUT`	`/api/token/?status_only=true`	只切换启用/禁用状态	写入
`DELETE`	`/api/token/{id}`	删除令牌	写入

基础地址为 https://api.apiyi.com。

创建令牌

请求示例

export APIYI_SYS_TOKEN='nap_YOUR_PERSONAL_ACCESS_TOKEN'   # 个人访问令牌

curl --compressed -s -X POST 'https://api.apiyi.com/api/token/' \
  -H "Authorization: $APIYI_SYS_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{
    "name": "team-alice",
    "remain_quota": 500000,
    "unlimited_quota": false,
    "group": "default",
    "models": "gpt-5.6,deepseek-chat",
    "expired_time": -1
  }'

请求字段

字段	类型	说明
`name`	String	令牌名称，用于自己识别用途
`remain_quota`	Integer	额度上限（额度数），500,000 = $1.00
`unlimited_quota`	Boolean	是否不限额度；缺省为 `false`
`group`	String	令牌绑定的分组标识符，如 `default`
`models`	String	模型白名单，逗号分隔；不传表示不限
`expired_time`	Integer	过期时间戳（Unix 秒），`-1` 表示永不过期

unlimited_quota 缺省为 false，而 remain_quota 缺省为 0 —— 两者一起缺省时会建出一把额度为 0、无法使用的令牌。要么显式给 remain_quota 赋值，要么把 unlimited_quota 设为 true。

模型白名单请使用 models 字段。响应结构里还存在 model_limits、model_limits_enabled、allow_ips 三个字段，传入它们不会报错（接口仍返回 200），但当前不会生效 —— 回读时这些字段仍为空。需要限制可用模型请使用 models，需要限制来源 IP 请在自己的服务侧实现。

响应示例

{
  "success": true,
  "message": "",
  "data": {
    "id": 119431,
    "user_id": 80778,
    "key": "K1RP**********4b75",
    "status": 1,
    "name": "team-alice",
    "group": "default",
    "models": "gpt-5.6,deepseek-chat",
    "remain_quota": 500000,
    "unlimited_quota": false,
    "used_quota": 0,
    "expired_time": -1,
    "created_time": 1785599000
  }
}

响应里的 key 是打码后的值，不能直接使用。 要拿到明文，用响应里的 id 再调一次获取明文接口。

获取 Key 明文

curl --compressed -s -X POST 'https://api.apiyi.com/api/token/119431/key' \
  -H "Authorization: $APIYI_SYS_TOKEN"

{
  "success": true,
  "message": "",
  "data": {
    "key": "K1RPzapuXLfBU4kDC5D9C0E70b1841AeAa542186B2F54b75"
  }
}

需要个人访问令牌勾选 模型密钥 · 查看密钥，否则返回 403 ACCESS_TOKEN_SCOPE_DENIED
返回的 key 不含 sk- 前缀，实际使用时需要自己拼上，即上例中真正的 API Key 是 sk-K1RPzapu…
拿到后立即保存并通过安全渠道分发，不要把响应体留在日志文件里

批量创建

服务端没有批量创建接口 —— 在请求体里传 count 之类的参数不会生效，仍然只创建一把。批量发放的做法是在客户端循环调用创建接口。

单个用户最多 1000 个令牌。 这是账号级别的总量上限，包含已禁用但未删除的令牌。达到上限后创建接口会失败，需要先删除不再使用的令牌腾出名额。批量发放前先用 GET /api/token/?p=0&page_size=100 翻页统计当前数量，把「新建 Key → 切流量 → 禁用旧 Key → 确认无调用后删除」中的最后一步真正执行到位，不要只禁用不删除，否则轮换几轮就会撞到上限。

Python
Node.js
cURL

import json
import os

import requests

BASE = "https://api.apiyi.com"
HEADERS = {"Authorization": os.environ["APIYI_SYS_TOKEN"],
           "Content-Type": "application/json"}
QUOTA_PER_USD = 500_000


def create_token(name, quota_usd=None, group="default", models=None, days=0):
    """创建一把令牌。quota_usd 为 None 表示不限额度，days 为 0 表示永不过期。"""
    import time
    body = {
        "name": name,
        "group": group,
        "unlimited_quota": quota_usd is None,
        "remain_quota": 0 if quota_usd is None else int(quota_usd * QUOTA_PER_USD),
        "expired_time": -1 if not days else int(time.time()) + days * 86400,
    }
    if models:
        body["models"] = models

    resp = requests.post(f"{BASE}/api/token/", headers=HEADERS, json=body, timeout=30)
    resp.raise_for_status()
    data = resp.json()["data"]          # 这里的 key 已打码

    # 取明文：需要「模型密钥 · 查看密钥」权限
    resp = requests.post(f"{BASE}/api/token/{data['id']}/key", headers=HEADERS, timeout=30)
    resp.raise_for_status()
    key = resp.json()["data"]["key"]
    return {"id": data["id"], "name": data["name"], "key": "sk-" + key}


if __name__ == "__main__":
    names = ["team-alice", "team-bob", "team-carol"]
    created = [
        create_token(n, quota_usd=1, group="default", models="gpt-5.6", days=30)
        for n in names
    ]
    for row in created:
        print(f"{row['name']:16s} id={row['id']} {row['key']}")

    # keys.json 里是明文 Key，注意妥善保存与分发，用完即删
    with open("keys.json", "w") as f:
        json.dump(created, f, ensure_ascii=False, indent=1)

const BASE = "https://api.apiyi.com";
const HEADERS = {
  Authorization: process.env.APIYI_SYS_TOKEN,
  "Content-Type": "application/json",
};
const QUOTA_PER_USD = 500_000;

async function createToken(name, { quotaUsd = null, group = "default",
                                   models = null, days = 0 } = {}) {
  const body = {
    name,
    group,
    unlimited_quota: quotaUsd === null,
    remain_quota: quotaUsd === null ? 0 : Math.round(quotaUsd * QUOTA_PER_USD),
    expired_time: days ? Math.floor(Date.now() / 1000) + days * 86400 : -1,
  };
  if (models) body.models = models;

  const resp = await fetch(`${BASE}/api/token/`, {
    method: "POST",
    headers: HEADERS,
    body: JSON.stringify(body),
  });
  if (!resp.ok) throw new Error(`HTTP ${resp.status}`);
  const { data } = await resp.json();   // 这里的 key 已打码

  // 取明文：需要「模型密钥 · 查看密钥」权限
  const r2 = await fetch(`${BASE}/api/token/${data.id}/key`, { method: "POST", headers: HEADERS });
  if (!r2.ok) throw new Error(`HTTP ${r2.status}`);
  const { data: secret } = await r2.json();
  return { id: data.id, name: data.name, key: `sk-${secret.key}` };
}

const names = ["team-alice", "team-bob", "team-carol"];
for (const name of names) {
  const row = await createToken(name, { quotaUsd: 1, models: "gpt-5.6", days: 30 });
  console.log(row.name, row.id, row.key);
}

export APIYI_SYS_TOKEN='nap_YOUR_PERSONAL_ACCESS_TOKEN'   # 个人访问令牌

for NAME in team-alice team-bob team-carol; do
  ID=$(curl --compressed -s -X POST 'https://api.apiyi.com/api/token/' \
    -H "Authorization: $APIYI_SYS_TOKEN" \
    -H 'Content-Type: application/json' \
    -d "{\"name\":\"$NAME\",\"remain_quota\":500000,\"unlimited_quota\":false,\"group\":\"default\",\"expired_time\":-1}" \
    | jq -r '.data.id')
  KEY=$(curl --compressed -s -X POST "https://api.apiyi.com/api/token/$ID/key" \
    -H "Authorization: $APIYI_SYS_TOKEN" | jq -r '.data.key')
  printf '%s\tsk-%s\n' "$NAME" "$KEY"
done

三重限制怎么用

额度限制

remain_quota 是这把令牌能消费的额度上限，换算关系与余额查询一致：

换算规则

500,000 额度 = $1.00 美金 (USD)

例如给下游客户发一把最多消费 $10 的 Key，就设 remain_quota: 5000000 且 unlimited_quota: false。用量可以从令牌的 used_quota 字段读取。 remain_quota 是一次性的总额度，用完不会自动恢复。要「每天限额」，见下文场景：每把 Key 每天限额，次日自动恢复。

模型限制

models 是逗号分隔的白名单。设置后，用这把 Key 调用名单外的模型会被直接拒绝：

{
  "error": {
    "message": "该令牌无权使用模型：deepseek-chat"
  }
}

返回 HTTP 403，不产生扣费。不传 models 表示不限制。

有效期限制

expired_time 是 Unix 秒时间戳，-1 表示永不过期。例如发一把 30 天后失效的 Key：

import time
expired_time = int(time.time()) + 30 * 86400

查询令牌

curl --compressed -s 'https://api.apiyi.com/api/token/?p=0&page_size=100' \
  -H "Authorization: $APIYI_SYS_TOKEN" | jq '.data[] | {id, name, status, remain_quota, used_quota, models}'

关键字段：

字段	说明
`id`	令牌 ID，更新与删除时用
`key`	打码后的 Key，明文见「获取 Key 明文」
`status`	`1` = 启用，`2` = 禁用
`remain_quota` / `used_quota`	剩余 / 已用额度
`unlimited_quota`	是否不限额度
`models`	模型白名单，空表示不限
`expired_time`	过期时间戳，`-1` 表示永不过期

更新令牌

更新接口需要传完整对象，不是增量更新（patch）。正确做法是：先 GET 拿到令牌的完整对象 → 修改需要变更的字段 → 把整个对象 PUT 回去。只传要改的那几个字段会把其余字段清空。

import os
import requests

BASE = "https://api.apiyi.com"
HEADERS = {"Authorization": os.environ["APIYI_SYS_TOKEN"],
           "Content-Type": "application/json"}

# 1. 取回完整对象
token = requests.get(f"{BASE}/api/token/119431", headers=HEADERS, timeout=30).json()["data"]

# 2. 只改需要变的字段，其余原样保留
token["remain_quota"] = 2_500_000     # 提到 $5
token["models"] = "gpt-5.6,gemini-3-pro"

# 3. 整个对象 PUT 回去
resp = requests.put(f"{BASE}/api/token/", headers=HEADERS, json=token, timeout=30)
print(resp.json()["success"])

场景：每把 Key 每天限额，次日自动恢复

企业把 Key 发给工作流、成员或下游项目时，常见的诉求是「每把 Key 每天最多花 $5，第二天自动恢复」，这样某个工作流跑飞了，损失也只限于一天的额度。平台目前没有内置「每日额度」字段，但用上面的更新接口加一个每天零点跑一次的定时任务就能做到：每天把这几把 Key 的 remain_quota 改回当日上限。Key 本身不变，团队成员不用换 Key，当天额度用完后调用会被拒绝（不扣费），零点重置后自动恢复。

准备个人访问令牌

勾选 模型密钥 · 读取 和 模型密钥 · 写入 即可，不需要「查看密钥」。脚本跑在固定 IP 的服务器上时，建议给这把令牌设置 IP 白名单。

列出要限额的 Key 及每日上限

用「查询令牌」接口查到各 Key 的 id，填进下面脚本的 DAILY_BUDGET_USD。

每天 00:00 (UTC+8) 运行一次脚本

用 cron、云函数定时触发器或任意调度器都可以，见下文。

重置脚本

"""每天 00:00 (UTC+8) 运行一次：把指定令牌的额度重置为当日上限。"""
import json
import os
from datetime import datetime, timedelta, timezone
from pathlib import Path

import requests

BASE = "https://api.apiyi.com"
HEADERS = {"Authorization": os.environ["APIYI_SYS_TOKEN"],
           "Content-Type": "application/json"}
QUOTA_PER_USD = 500_000

# 令牌 ID → 每日上限（美元）
DAILY_BUDGET_USD = {
    119431: 5,     # team-alice
    119432: 5,     # team-bob
    119433: 20,    # workflow-prod
}
CARRY_OVERDRAFT = True   # 昨天超出上限的部分，从今天的额度里扣回

TZ = timezone(timedelta(hours=8))   # 按 UTC+8 划分「一天」
STATE = Path(__file__).with_name("daily_quota_state.json")


def main():
    today = datetime.now(TZ).date().isoformat()
    state = json.loads(STATE.read_text()) if STATE.exists() else {}

    for token_id, usd in DAILY_BUDGET_USD.items():
        last = state.get(str(token_id), {})
        if last.get("date") == today:
            continue                     # 今天已重置过，防止重复触发多发一天额度

        # 1. 取回完整对象
        token = requests.get(f"{BASE}/api/token/{token_id}",
                             headers=HEADERS, timeout=30).json()["data"]
        remain = token["remain_quota"]
        if "quota" in last:
            spent = (last["quota"] - remain) / QUOTA_PER_USD
            print(f"{token['name']}: 上一周期花费 ${spent:.2f}")

        # 2. 只改额度字段，其余原样保留
        quota = int(usd * QUOTA_PER_USD)
        if CARRY_OVERDRAFT and remain < 0:
            quota = max(quota + remain, 0)
        token["remain_quota"] = quota
        token["unlimited_quota"] = False

        # 3. 整个对象 PUT 回去
        resp = requests.put(f"{BASE}/api/token/", headers=HEADERS,
                            json=token, timeout=30).json()
        if not resp.get("success"):
            raise RuntimeError(f"令牌 {token_id} 重置失败：{resp.get('message')}")

        # 每把令牌成功后立即落盘，中途失败重跑时不会重复重置已完成的
        state[str(token_id)] = {"date": today, "quota": quota}
        STATE.write_text(json.dumps(state, indent=1))
        print(f"{token['name']}: 今日额度 ${quota / QUOTA_PER_USD:.2f}")


if __name__ == "__main__":
    main()

脚本做了三件额外的事：

防重复：同一天内重复触发（调度器补跑、手动重跑）不会再发一次额度
结转超支：额度是软上限（见下方说明），昨天超出的部分从今天扣回，长期看每天平均不超过上限；不需要的话把 CARRY_OVERDRAFT 改成 False
输出昨日花费：每次运行打印各 Key 上一周期花了多少，日志留着就是一份简易日报

定时运行

把令牌写进只有自己可读的环境变量文件，再用 cron 每天触发：

# /opt/apiyi-quota/env（chmod 600）
export APIYI_SYS_TOKEN='nap_YOUR_PERSONAL_ACCESS_TOKEN'

# crontab -e
# 服务器时区是 UTC+8：
0 0 * * * . /opt/apiyi-quota/env && python3 /opt/apiyi-quota/reset_daily_quota.py >> /opt/apiyi-quota/reset.log 2>&1
# 服务器时区是 UTC：00:00 (UTC+8) = 16:00 (UTC)，把开头改成 0 16 * * *

想按别的时区划分「一天」，同时改 cron 时间和脚本里的 TZ。

使用前要知道的几点

额度是软上限，不是精确的刹车。 额度检查发生在请求开始时，几个并发请求可能同时通过检查，单次很贵的请求（视频、4K 出图、超长上下文）也可能一次就越过上限，余额会被打成负数。并发越高、单价越高，超出越多。脚本的「结转超支」会把超出部分从次日扣回；如果某些 Key 不能有任何超支，就在自己的服务侧控制它的并发数，或者用 models 白名单把高单价模型排除在外。

重置是覆盖，不是累加：没用完的额度不会滚到第二天。另外，在控制台手动改了这些 Key 的额度，下次重置时会被覆盖
零点前后的在途请求：零点前发出、零点后才结束的请求，费用可能记进新的一天，金额一般很小
脚本没跑时 Key 会停在用完状态：结果是暂时不能调用，不会多花钱。建议给定时任务加失败告警
账户余额仍是总闸：各 Key 的每日额度加起来超过账户余额时，余额先耗尽，所有 Key 都会停
单个 Key 想临时多给点：直接用更新接口把它当天的 remain_quota 调高，次日照常重置回上限

禁用与删除

禁用（保留记录）

禁用后该 Key 立即失效，再用它调用模型会返回 401，但令牌记录和历史用量仍然保留。

token = requests.get(f"{BASE}/api/token/119431", headers=HEADERS, timeout=30).json()["data"]
token["status"] = 2      # 1 = 启用，2 = 禁用

requests.put(f"{BASE}/api/token/", headers=HEADERS,
             params={"status_only": "true"}, json=token, timeout=30)

删除（不可恢复）

curl --compressed -s -X DELETE 'https://api.apiyi.com/api/token/119431' \
  -H "Authorization: $APIYI_SYS_TOKEN"

批量删除同样在客户端循环即可：

for token_id in [119431, 119432, 119433]:
    requests.delete(f"{BASE}/api/token/{token_id}", headers=HEADERS, timeout=30)

删除是不可恢复操作。如果只是想临时停用，用上面的禁用方式，历史用量记录会保留下来便于对账。

常见问题

创建时返回的 key 怎么直接不能用？

创建接口返回的 key 是打码后的值（中间是一串 *），不能直接用。用返回的 id 调 POST /api/token/{id}/key 取明文（需勾「查看密钥」权限），再在前面拼上 sk-。早期脚本若直接用创建响应里的 key，换成个人访问令牌时需要补上这一步。

为什么我建出来的令牌一调用就提示额度不足？

最可能的原因是创建时既没传 remain_quota，也没把 unlimited_quota 设为 true —— 两者的缺省组合会建出一把额度为 0 的令牌。重新创建时显式指定其中之一即可。

传了 model_limits 或 allow_ips 为什么没有效果？

这两个字段（以及 model_limits_enabled）当前不生效，传入不会报错但也不会落库。限制可用模型请使用 models 字段；限制来源 IP 目前需要在你自己的服务侧实现。

能一次创建多把令牌吗？

服务端没有批量创建接口，在请求体里传 count 之类的参数不会生效。批量发放请在客户端循环调用创建接口，参考上面「批量创建」一节的示例。

一个账号最多能有多少把令牌？

单个用户最多 1000 个令牌，已禁用但未删除的也计入这个总量。达到上限后创建接口会失败，需要先删除不再使用的令牌。轮换 Key 时记得走到「删除」这一步，只禁用不删除会占着名额。

能不能限制每把 Key 每天的花费，第二天自动恢复？

平台没有内置「每日额度」字段，但可以用定时任务实现：每天 00:00 (UTC+8) 调更新接口，把这些 Key 的 remain_quota 改回当日上限。Key 不用换，当天用完会被拒绝且不扣费，次日自动恢复。完整脚本与注意事项见上文场景：每把 Key 每天限额，次日自动恢复。

更新令牌后其他字段被清空了？

更新接口需要传完整对象。先 GET 拿到完整对象，改完再整个 PUT 回去，不要只传要改的那几个字段。

禁用和删除有什么区别？

禁用（status: 2）后 Key 立即失效，但令牌记录与历史用量保留，可以随时改回 1 恢复。删除是不可恢复的，记录一并移除。临时停用建议用禁用。

怎么知道每把 Key 各自花了多少钱？

令牌对象的 used_quota 字段就是这把 Key 的累计消费（÷ 500,000 = 美元）。需要按时间段拆分或看每次调用的明细，去控制台日志页按令牌名筛选，见如何查看我的调用记录。

注意事项

个人访问令牌不是 API Key，两者不能互换

API Key（sk- 开头）用于 /v1/* 推理端点
个人访问令牌（nap_ 开头）用于 /api/* 管理端点，不能调用模型

报错对照：401 ACCESS_TOKEN_LEGACY_RETIRED 是仍在用已停用的旧系统令牌； 401 This access token may not be used from the current IP address. 是来源 IP 不在令牌白名单内； 403 ACCESS_TOKEN_SCOPE_DENIED 是令牌没勾这个接口需要的权限（见上方端点一览）。

妥善保管明文 Key「获取 Key 明文」接口返回的是可以直接调用模型的 Key。请注意：

不要把包含 key 的原始响应写进日志文件或提交进代码仓库
分发给团队成员时使用安全渠道，不要通过聊天群直接发送
这段明文不带 sk- 前缀，常见的密钥扫描工具可能扫不出来，不要依赖自动化检查兜底

操作建议

批量创建时建议在循环里加适度间隔，避免瞬时并发过高
给每把 Key 起有意义的 name（如 team-alice、prod-webhook），便于后续在日志里按 token_name 归因
定期轮换：新建 Key → 切流量 → 禁用旧 Key 观察一段时间 → 确认无调用后再删除

产品基础

基础 API

图片 API（官转）

视频 API（官转）

多模态理解 API

文本生成

音频 API（官转）

检索与安全

接口概述

额度限制

模型限制

有效期限制

如何获取个人访问令牌

端点一览

创建令牌

请求示例

请求字段

响应示例

获取 Key 明文

批量创建

三重限制怎么用

额度限制

换算规则

模型限制

有效期限制

查询令牌

更新令牌

场景：每把 Key 每天限额，次日自动恢复

重置脚本

定时运行

使用前要知道的几点

禁用与删除

禁用（保留记录）

删除（不可恢复）

常见问题

注意事项

相关文档

​接口概述

额度限制

模型限制

有效期限制

​如何获取个人访问令牌

​端点一览

​创建令牌

​请求示例

​请求字段

​响应示例

​获取 Key 明文

​批量创建

​三重限制怎么用

​额度限制

换算规则

​模型限制

​有效期限制

​查询令牌

​更新令牌

​场景：每把 Key 每天限额，次日自动恢复

​重置脚本

​定时运行

​使用前要知道的几点

​禁用与删除

​禁用（保留记录）

​删除（不可恢复）

​常见问题

​注意事项

相关文档

接口概述

如何获取个人访问令牌

端点一览

创建令牌

请求示例

请求字段

响应示例

获取 Key 明文

批量创建

三重限制怎么用

额度限制

模型限制

有效期限制

查询令牌

更新令牌

场景：每把 Key 每天限额，次日自动恢复

重置脚本

定时运行

使用前要知道的几点

禁用与删除

禁用（保留记录）

删除（不可恢复）

常见问题

注意事项